在JavaScript中执行循环的最佳方法是什么

我偶然发现了几种JavaScript循环方法，我最喜欢的是：

for(var i = 0; i < a.length; i++){
    var element = a[i];
}

for（变量i=0；i

但是，正如在这里（）测试的那样，可能应该编写它，以便只计算一次长度

在jQuery中，有一个.each，您可以粘贴一个函数。我更喜欢这个，因为我不必像上面的解决方案那样键入两次数组

如果JavaScript支持宏，那就很容易实现自己的宏，但遗憾的是，它不支持宏

---

那个么你们用什么呢？

你们可以一直使用while循环，然后计算数组限制

Var max = a.length-1;
var i = 0;

while(i <= max)
{
var element = a[i];
i++;
}

Var max=a.length-1；
var i=0；
虽然（i我已经开始在相关的地方使用迭代器。性能是合理的，但更重要的是，它允许您封装循环逻辑：

function createIterator(x) {
    var i = 0;

     return function(){
       return x[i++];
    };
}

然后使用：

var iterator=createIterator(['a','b','c','d','e','f','g']);

iterator();

返回“a”

返回“b”

等等

要迭代整个列表并显示每个项目，请执行以下操作：

var current;

while(current=iterator())
{
    console.log(current);
}
对原来的小改进，只计算一次数组大小：

for(var i = 0, len = a.length; i < len; i++){ var element = a[i]; }

首先将长度存储在变量中

  var len = a.length;
  for (var i = 0; i < len; i++) {
    var element = a[i];
  }

var len=a.length；
对于（变量i=0；i
如果数组中有许多元素，并且速度是一个问题，那么您希望使用从最高到最低迭代的while循环

  var i = a.length;
  while( --i >= 0 ) {
    var element = a[i];
    // do stuff with element
  }  

我自己不使用它，但我的一位同事使用这种风格：

var myArray = [1,2,3,4];
for (var i = 0, item; item = myArray[i]; ++i) {
    alert(item);
}

与Ash的答案一样，如果数组中的值是“假”的，则会遇到问题。为了避免此问题，请将其更改为
（item=myArray[i]）！=undefined
我知道我参加聚会迟到了，但我对不依赖顺序的循环使用反向循环

与@Mr.Muskrat非常相似-但简化了测试：

var i = a.length, element = null;
while (i--) {
  element = a[i];
}

因此，首先确定完美的javascript循环，我相信它应该如下所示：

ary.each（函数（）{$arguments[0]）.remove（）；}）

这可能需要prototype.js库

接下来，您将对参数[0]部分产生反感，并从服务器框架自动生成代码。只有当梯子在海边时，这才有效

现在，您可以通过以下方式生成上述内容：

ary do:[：每个|每个元素移除]

这是完整的语法完成，并准确地转换为上述javascript。当人们阅读您的代码时，这会让以前从未使用过seasides原型集成的人头晕目眩。这肯定也会让你感觉很酷。更不用说你可以在这里获得极客的好处了。女孩们都喜欢
 我看不出使用（；；）循环的标准有什么问题。
小测验

var x;
var a = [];
// filling array
var t0 = new Date().getTime();
for( var i = 0; i < 100000; i++ ) {
    a[i] = Math.floor( Math.random()*100000 );
}

// normal loop
var t1 = new Date().getTime();
for( var i = 0; i < 100000; i++ ) {
    x = a[i];
}

// using length
var t2 = new Date().getTime();
for( var i = 0; i < a.length; i++ ) {
    x = a[i];
}

// storing length (pollution - we now have a global l as well as an i )
var t3 = new Date().getTime();
for( var i = 0, l = a.length; i < l; i++ ) {
    x = a[i];
}

// for in
var t4 = new Date().getTime();
for( var i in a ) {
    x = a[i];
}

// checked for in
var t5 = new Date().getTime();
for( var i in a ) {
    if (a.hasOwnProperty(i)) {
        x = a[i];
    }
}

var t6 = new Date().getTime();
var msg = 'filling array: '+(t1-t0)+'ms\n'+
          'normal loop: '+(t2-t1)+'ms\n'+
          'using length: '+(t3-t2)+'ms\n'+
          'storing length: '+(t4-t3)+'ms\n'+
          'for in: '+(t5-t4)+'ms\n'+
          'checked for in: '+(t6-t5)+'ms';
console.log( msg );

因此：-对于in的take-longest，使用length属性（这是一个属性，不需要计算）几乎与首先存储它一样快-这只比使用整数慢一点点。

for（）是循环数组的常用方法，每个人都期望并理解它。

它们都在它们运行的范围中添加了一个变量-i-这是此用途的通用名称，因此不应用于其他用途。首先存储长度会向作用域添加另一个var-l-，这是不必要的
很抱歉直截了当，但我看不出这是一种改进。您仍然会指定两次数组，在您的解决方案中，周围的环境受到两个变量的污染，而scrope不应超越while循环构造。鉴于Javascript中变量的作用域是封闭函数，环境无论如何都会受到“污染”，不是声明它的块。根据问题中给出的链接测试它，它至少与任何for循环实现一样快，如果不是更快的话。是的，我也一直在考虑使用迭代器。它们比简单的循环更好地封装了遍历的概念。但是，在您的示例中，如何在迭代器中打印所有元素呢？漂亮的闭包甜美。啊，我喜欢它们。如果你的迭代器没有HasNext函数，你怎么知道你什么时候到达了终点？如果您继续按照您的示例调用“迭代器”，您最终将得到超出范围的数组索引。对不起，我想我有点习惯于使用在试图访问数组末尾时抛出异常的语言来编写代码，这取决于JS在尝试这样做时不会抛出异常。如果你喜欢这个答案，你可能会感兴趣，Mochikit显然就是你所说的“最佳”的意思“最干净的”，对吧？有些人可能会说“最好的”“方法是以最快的方式去做，在这种情况下，答案可能不同……是的。我选择了“最佳”这个词，因为我想要一个循环解决方案，我可以随时使用，而不必真正考虑它。因此，当在100k元素上运行时，它的速度不能太慢，写入的时间也不能太长，等等。in循环用于迭代对象属性，虽然它们似乎适用于数组，但它们也将迭代“length”属性或任何其他动态添加的属性。这就是为什么它不能很好地与原型配合使用。第二个例子
i
可能是创建了一个globalwell，我来晚了，但这是正确的答案，应该被接受。对于未初始化的用户，i--子句保存一个比较（因为在JS测试中0=false）。警告1：颠倒顺序！警告2：可读性不是很好。警告3：缓存的for循环非常好，不需要>=0，只需将--i更改为i即可--
var myArray = [1,2,3,4];
for (var i = 0, item; item = myArray[i]; ++i) {
    alert(item);
}

var i = a.length, element = null;
while (i--) {
  element = a[i];
}

var x;
var a = [];
// filling array
var t0 = new Date().getTime();
for( var i = 0; i < 100000; i++ ) {
    a[i] = Math.floor( Math.random()*100000 );
}

// normal loop
var t1 = new Date().getTime();
for( var i = 0; i < 100000; i++ ) {
    x = a[i];
}

// using length
var t2 = new Date().getTime();
for( var i = 0; i < a.length; i++ ) {
    x = a[i];
}

// storing length (pollution - we now have a global l as well as an i )
var t3 = new Date().getTime();
for( var i = 0, l = a.length; i < l; i++ ) {
    x = a[i];
}

// for in
var t4 = new Date().getTime();
for( var i in a ) {
    x = a[i];
}

// checked for in
var t5 = new Date().getTime();
for( var i in a ) {
    if (a.hasOwnProperty(i)) {
        x = a[i];
    }
}

var t6 = new Date().getTime();
var msg = 'filling array: '+(t1-t0)+'ms\n'+
          'normal loop: '+(t2-t1)+'ms\n'+
          'using length: '+(t3-t2)+'ms\n'+
          'storing length: '+(t4-t3)+'ms\n'+
          'for in: '+(t5-t4)+'ms\n'+
          'checked for in: '+(t6-t5)+'ms';
console.log( msg );

filling array: 227ms
normal loop: 21ms
using length: 26ms
storing length: 24ms 
for in: 154ms
checked for in: 176ms