标签: local-variables

我对在Ruby中动态设置局部变量感兴趣.不创建方法,常量或实例变量.

所以类似于:

args[:a] = 1
args.each_pair do |k,v|
  Object.make_instance_var k,v
end
puts a
> 1

我特别想要局部变量,因为所讨论的方法存在于模型中,我不想污染全局或对象空间.

class C
end

var = "I am a local var outside"

C.class_eval do
   def self.a_class_method
     puts var 
   end
end

我知道,这是不正确的,因为def创建了一个新的范围.我也知道use define_method可以在不创建新范围的情况下创建实例方法,但我的观点是如何定义类方法.

我的功能将被召唤数千次.如果我想让它更快,将局部函数变量更改为静态是否有用？我背后的逻辑是,因为静态变量在函数调用之间是持久的,所以它们仅在第一次分配时,因此,每个后续调用都不会为它们分配内存并且会变得更快,因为内存分配步骤没有完成.

此外,如果上述情况属实,那么使用全局变量而不是参数会更快地在每次调用时将信息传递给函数吗？我认为参数的空间也分配在每个函数调用上,以允许递归(这就是递归占用更多内存的原因),但由于我的函数不是递归的,如果我的推理是正确的,那么理论上取下参数它更快.

我知道我想要做的这些事情是可怕的编程习惯,但请告诉我它是否明智.无论如何我会试一试,但请告诉我你的意见.

嗨,大家好,我有一个简单的函数和一个全局变量.

为什么myname undefined不是字符串"global"？

var myname = "global"; // global variable
function func() {
    alert(myname); // "undefined"
    var myname = "local";
    alert(myname); // "local"
}
func();

是不是可以引用在该函数范围之外定义的外部变量？在这个全局变量......

我如何解决这个问题,以便undefined从全局变量中得到一个？

请看以下示例:

public void init() {
    final Environment env = new Environment();
    Runtime.getRuntime().addShutdownHook(new Thread() {
        public void run() {
             env.close();
        }
     });
}

首先,env存储在哪里？是吗:

• 由编译器复制到引用它的内部类的隐藏成员变量中
• 复制到堆上并在其上引用
• 留在堆栈上,不知何故在那里引用
• 别的

我的猜测是第一个选择.

其次,执行这样做会产生任何性能问题(而不是简单地创建env类的成员变量并引用它),特别是如果要创建大量引用最终局部变量的内部类构造.

我发现了一个建议使用的答案

var list = new ArrayList();

我很惊讶在这里找到一个原始类型,我只是想知道:确实var使用<>"自动？

(与此同时,答案改为使用<String>,但我仍然对这里的"原则"感到好奇)

我看到其他的问题,比如这个,但它们都使用了钻石操作:

var list = new ArrayList<>();

现在我只想知道:是否会var改变我们应该(不)使用原始类型的方式？或者这个建议<>只是遗漏了不好的做法？

这样的事情(是的,这不涉及一些边缘情况 - 这不是重点):

int CountDigits(int num) {
    int count = 1;
    while (num >= 10) {
        count++;
        num /= 10;
    }
    return count;
}

Run Code Online (Sandbox Code Playgroud)

你对此有何看法？也就是说,使用函数参数作为局部变量.
两者都放在堆栈上,性能几乎相同,我想知道这方面的最佳实践方面.
当我为这个函数添加一个额外的冗余线路时,我觉得自己像个白痴int numCopy = num,但它确实让我感到烦恼.
你怎么看？这应该避免吗？

这是我想知道的一些问题.鉴于以下代码,我们可以确定其输出吗？

void f() {
  int i = 0; 
  z: if(i == 1) goto x; else goto u; 
  int a; 
  x: if(a == 10) goto y; 
  u: a = 10; i = 1; goto z; 
  y: std::cout << "finished: " << a; 
}

这是否保证finished: 10根据C++标准输出？或者编译器可以占用a存储到的寄存器,何时goto到达之前的位置a？

在线程外部定义的局部变量似乎从内部可见,因此以下两种用法Thread.new看起来是相同的:

a = :foo
Thread.new{puts a} # => :foo
Thread.new(a){|a| puts a} # => :foo

该文件给出了一个例子:

arr = []
a, b, c = 1, 2, 3
Thread.new(a,b,c){|d, e, f| arr << d << e << f}.join
arr #=> [1, 2, 3]

但由于a,b,c都可从创建的线程内,这也应该是一样的:

arr = []
a, b, c = 1, 2, 3
Thread.new{d, e, f = a, b, c; arr << d << e << f}.join
arr #=> [1, 2, …

从java内存模型中,我们知道每个线程都有自己的线程堆栈,并且局部变量放在每个线程自己的线程堆栈中.

而其他线程无法访问这些局部变量.

那么在这种情况下,我们应该同步局部变量？