标签: local-variables

在 JS 中，创建一个变量以进行重用是一个很好的做法，而不是访问深层对象结构中的值：

for (var i = 0, l = arr.length; i < l; ++i) {
  var someValueINeedOftenHere = arr[i].path.to.value;
  // do several things with this var..
}

因此，我们不是在这个深层对象结构中查找值，而是将其存储在本地，并且可以一遍又一遍地重用它。这应该是一个很好的实践，不仅因为它可以让您编写更干净的代码，而且还因为性能。

因此，当我编写 C++ 代码时，我必须迭代一个包含大量结构/对象的向量。那么是一样的，还是没有关系？

所以从 Java 9 开始，我们可以使用 var 来声明局部变量：

var s = "cool";

有没有办法在声明字段时使用类似的构造？

class Container {
  final var s = "cool"; // does not compile tmk
}

据我所知，似乎不像。

我很高兴地了解到，从 Lua 5.4 开始，Lua 支持常量 ( const) 和要关闭的 ( close) 变量！但是，在测试这些关键字时，它们似乎根本没有做任何事情。我编写了以下代码来对功能进行采样，以更好地掌握它们的确切用法：

function f()
  local const x = 3
  print(x)
  x = 2
  print(x)
end

f()

function g()
  local close x = {}
  setmetatable(x, {__close = function() print("closed!") end})
end

g()

我为文件命名constCheck.lua并使用lua constCheck.lua. 输出如下：

3
2

我期待在调用 时出现错误f()，或者至少要打印3两次，相反，它似乎重新分配x没有任何问题。此外，我期待调用g()打印出“关闭！” 当x在函数结束时离开作用域时，但这并没有发生。我找不到很多关于这些关键字用法的例子。我是否正确使用它们？做他们的工作？

笔记： lua -v => Lua 5.4.0 Copyright (C) 1994-2020 Lua.org, PUC-Rio

我有一个这样的函数：

(defun lookup-data (index-key)
   (let* ((key-table '("key0" "key1" "key2" ...))
          (index       (position index-key key-table :test #'string-equal))
          ...
   ; do stuff with index, among other things
 )

键表（实际上只是一个字符串列表，但它被用作将字符串映射到索引号的查找表）是读取时已知的文字值。我想也许它应该被制作为defparameteror defconstant，但它没有在这个函数之外的任何地方使用。我认为它是一个字面量意味着大多数编译器可以按原样对其进行基于常量的优化，但是我还应该做些什么来将其标记为常量吗？这里有哪些选项？

这是参考本主题中的讨论, 如何将char指针作为C++函数的out参数

在下面的代码中,我在哪里释放pTemp的内存？这不是必需的吗？如果不是字符数组而不是整数数组,事情会不会发生变化？

void SetName( char **pszStr )
{
    char* pTemp = new char[10];
    strcpy(pTemp,"Mark");
    *pszStr = pTemp;
}

int main(int argc, char* argv[])
{
    char* pszName = NULL;
    SetName( &pszName );
    cout<<"Name - "<< pszName << endl;
    delete [] pszName;
    cin.get();
    return 0;
}

#include <stdio.h>
void func(int **);

int main()
{

  int *arr[2];

  func(arr);

  printf("value [1] = %d \n",*arr[0]);

  printf("value [2] = %d \n",*arr[1]);
  return 0;
}

void func(int **arr)
{
  int j = 10;
  arr[0] = &j;
  arr[1] = &j;
}

使用gcc成功编译代码.但是,输出是:

value [1] = 10 

value [2] = 32725 

第二个值是垃圾值.为什么会这样？如何正确使用双指针访问数组？

我有一个关于Ruby解释器如何分配变量的问题:

我经常使用这个:

return foo if (foo = bar.some_method)

some_method返回一个对象或nil.

但是,当我尝试这个:

return foo if (true && (foo = bar.some_method))

我得到:NameError:未定义的局部变量或方法foo for main:Object.

导致第二行出错的第一行和第二行之间的评估有何不同？

我一直在假设,并且我确实相信我有经验,用Java原始数字初始化long或浮动本地原语将产生编译器错误.

例如

float f = 10;
long l = 5;

并且正确的方法是写上面的内容

float f = 10f;
long l = 5l;

然而,我现在发现编译器在没有f和l免责声明的情况下愉快地编译.我错过了什么吗？

我正在尝试使用宏来转换一些变量声明:

function test():Void {
    var someComp:Component = __SOME_MACRO__();

    // Or...
    @getCompById var someComp:Component;

    // Or even simpler...
    getCompById(someComp, Component); //do some fancy macro magic...
    // Also, if it's not possible/easy with a variable ...
    getCompById("someComp", Component); //with a string of the variable name.
}

......对此:

function test() {
    var someComp:Component = cast container.getCompById("someComp");
}

我更倾向于第三种选择(语法更短,结果相同).

但是我不知道如何编写宏(它应该将String作为参数吗？表达式？)以及如何正确地将其作为宏表达式返回.

这是我到目前为止的(破碎)代码:

macro static function getCompById(someVar:Expr, typeVar:Expr) {
    return macro {
        var someVar:typeVar = cast container.getCompById("someVar");
    };
}

有任何想法吗？

loopCommon Lisp中的工具允许使用多个价值累积条款maximize.
现在,它也可以提供可变var的maximize条款:

(loop for x from 0 to 10 maximize (func x) into var)

我的问题是:

是否有可能作为var一个新的局部变量引入let？

一个示例场景是:

(let ((var -1)) ; assume numeric result
  (loop for x from 0 to 10 maximize (func x) into var))

x具有数值并不重要,仅用于说明目的.