javascript - 一个用于临时结果的局部范围属性数组是否比许多全局变量更好？

Question

如果您在线搜索脚本解决方案，所提供的示例通常使用 var a = 'something'; 将所有变量声明为全局变量； var b = 123; 在函数启动这些变量的算法之前。然后在函数内，有时会声明更多全局变量以保存在结果之间，直到函数返回算法正在执行的输出。

我现在想知道在对象内的函数内将一个变量声明一次作为数组以将所有中间结果作为属性保存是否更有效？

例如，当循环次数为 100.000 次时，example1 或 example2 是否会导致更多内存使用？

在循环中使用全局变量的全局函数

var a = 10, b = 2.33, s = 'example1'

function do1000Times(a,b,s) {
  var result = '';
  for (var i = 0; i < 1000; i++) {
     var half = a/2;
     var multi = half*b;
     result += s+' half of A multiplied by B = '+multi+"\n";
     a = half;
  } // end of loop
  console.log(result);
  return result;
} // end of function

do1000Times(a,b,s) // execute the function

与仅具有局部参数的对象执行相同的循环

const run1000Times = {
    temp : [],
    result : '',
    run : function(val1,val2,str) {
        this.result = '';
        for (this.temp.i = 0; this.temp.i < 1000; this.temp.i++) {
         this.temp.half = val1/2;
         this.temp.multi = this.temp.half*val2;
         this.result += str+' half of A multiplied by B = '+this.temp.multi+"\n";
         val1 = this.temp.half;
        } // end of loop
    console.log(this.result);
    return this.result;         
    } // end of run
} // end of object

run1000Times.run(10, 2.33, 'example2') // execute run inside object

由于绝对数组引用，语法可读性较差但可能更快/更有效？

const loopXTimes = {
    temp : [],
    run : function(val1,val2,str,loop) {
     this.temp[3] = ''; // [3] holds result
      for (this.temp[0] = 0; this.temp[0] < loop; this.temp[0]++) {
        // temp[0] holds iteration count
         this.temp[1] = val1/2; // [1] holds result a;
         this.temp[2] = this.temp[1]*val2; // [2] holds result b;
         this.temp[3] += str+' half of A multiplied by B = '+this.temp[2]+"\n";
         val1 = this.temp[1];
        } // end of loop
  console.log(this.temp[3]);
  return this.temp[3];      
  } // end of run
} // end of object

loopXTimes.run(10, 2.33, 'example3', 1000);

Answer 1

这些示例在范围方面没有任何区别。两者都只使用局部变量。参数也是局部的。

如果一个函数使用全局变量而另一个函数使用局部变量，则内存使用没有区别。

在比较中使用常量 < 1000或变量 < loop循环设置为 1000 没有区别。 Javascript 内部优化 whicheffer 是最有效的。

要使用较新的关键字 const或 let在 var使编码更加具体和安全。它不会变得更快或减少内存消耗。 let 范围更近，但与另一个对象中的绑定(bind)相比，它没有任何区别。绑定(bind)只是对变量或常量的绑定(bind) - 相同的速度和相同大小(32 位)的内存位置。

基本上每个变量都有完全相同的 32 位内存使用。这就是 Javascript 的实现方式，通常情况下效果最好。如果必须的话，使用(耗时的)位操作将 32 个 bool 值存储在一个变量中，否则只需让程序中的几个 bool 值每个都使用 32 位。它是最适合硬件的内存位置的大小。要在内存位置存储更多内容，您还可以查看 typed arrays .

在循环中，将绑定(bind)到许多不同对象中的变量或将其展平以将变量直接放入循环中没有区别。在这两种情况下都是一步绑定(bind)。 Javascript 通过在必要时对全局进行局部声明来优化。它还优化了一步绑定(bind)的深度点引用。

有时直接引用对象可能比通过分配变量来制作大量副本更好。 每个副本(实例)都需要空间和时间。例如传递一个对象而不是它的值更好。 Javascript 具有按值传递的意思，对象引用只是一个要传递的值。

大多数时候没有使用 try micro-optimize 代码，因为内部编译器优化会处理它。

现在回答您的问题:一个用于临时结果的局部范围属性数组是否比许多全局变量更好？

将全局变量存储在窗口对象中通常不是一个好的做法。如果必须循环窗口对象(我怀疑内部 JS 会这样做)，则需要更多时间。但是点操作(使用 .key )仍然是相同的速度，与大小或它在内存中的位置无关。索引(使用 ['key'] )也是相同的 - 实际上是 obj['key']等于 obj.key . Javascript 中的一切都是对象，甚至是数组!

如果你的意思是函数中的全局变量与将其存储在数组中相比它根本没有时间或空间差异当谈论从变量中检索值与索引或引用相比时 - 它是相同的。编译器将它们视为对内存中值的绑定(bind)。

将大小为 1000 的数组与代码中 1000 个变量中的相同数据进行比较，在编译和优化后仍然没有内存增益。编译器将变量存储在内存块中(可以看作是一个数组)。