我被告知不要使用。。。在JavaScript中使用数组。为什么不呢?


当前回答

主要有两个原因:

One

就像其他人所说的那样,您可能会得到不在数组中或从原型继承的密钥。因此,假设库向Array或Object原型添加了一个属性:

Array.prototype.someProperty = true

您可以将其作为每个阵列的一部分:

for(var item in [1,2,3]){
  console.log(item) // will log 1,2,3 but also "someProperty"
}

可以使用hasOwnProperty方法解决此问题:

var ary = [1,2,3];
for(var item in ary){
   if(ary.hasOwnProperty(item)){
      console.log(item) // will log only 1,2,3
   }
}

但这对于使用for in循环迭代任何对象都是正确的。

Two

通常,数组中项目的顺序很重要,但for in循环不一定以正确的顺序迭代,这是因为它将数组视为对象,这是在JS中实现的方式,而不是数组。这看起来是一件小事,但它确实会破坏应用程序,而且很难调试。

其他回答

for/in使用两种类型的变量:哈希表(关联数组)和数组(非关联)。

JavaScript将自动确定其通过项目的方式。因此,如果您知道数组确实是非关联的,可以使用(var i=0;i<=arrayLen;i++),并跳过自动检测迭代。

但在我看来,最好使用for/in,自动检测所需的过程非常小。

对此的真正答案将取决于浏览器解析器/解释JavaScript代码的方式。它可以在浏览器之间更改。

我想不出不使用for/in的其他目的;

//Non-associative
var arr = ['a', 'b', 'c'];
for (var i in arr)
   alert(arr[i]);

//Associative
var arr = {
   item1 : 'a',
   item2 : 'b',
   item3 : 'c'
};

for (var i in arr)
   alert(arr[i]);

for in语句本身并不是一个“坏习惯”,但是它可能被错误地使用,例如,用于迭代数组或类似数组的对象。

for-in语句的目的是枚举对象财产。该语句将出现在原型链中,也会枚举继承的财产,这有时是不需要的。

此外,规范并不能保证迭代的顺序,这意味着如果要“迭代”数组对象,那么使用此语句无法确保财产(数组索引)将按数字顺序访问。

例如,在JScript(IE<=8)中,即使在Array对象上,枚举的顺序也定义为创建了财产:

var array = [];
array[2] = 'c';
array[1] = 'b';
array[0] = 'a';

for (var p in array) {
  //... p will be "2", "1" and "0" on IE
}

此外,谈到继承的财产,例如,如果您扩展Array.prototype对象(像MooTools这样的一些库),那么财产也会被枚举:

Array.prototype.last = function () { return this[this.length-1]; };

for (var p in []) { // an empty array
  // last will be enumerated
}

正如我之前所说的,迭代数组或类似数组的对象,最好的方法是使用顺序循环,例如普通的旧for/while循环。

如果只想枚举对象自己的财产(未继承的属性),可以使用hasOwnProperty方法:

for (var prop in obj) {
  if (obj.hasOwnProperty(prop)) {
    // prop is not inherited
  }
}

有些人甚至建议直接从Object.prototype调用该方法,以避免在有人向我们的对象添加名为hasOwnProperty的属性时出现问题:

for (var prop in obj) {
  if (Object.prototype.hasOwnProperty.call(obj, prop)) {
    // prop is not inherited
  }
}

因为。。。in通过持有数组的对象枚举,而不是数组本身。如果我向数组原型链中添加了一个函数,那么它也将包含在内。即。

Array.prototype.myOwnFunction = function() { alert(this); }
a = new Array();
a[0] = 'foo';
a[1] = 'bar';
for(x in a){
 document.write(x + ' = ' + a[x]);
}

这将写入:

0 = foo
1 = bar
myOwnFunction = function() { alert(this); }

而且,由于您永远无法确定不会向原型链中添加任何内容,因此只需使用for循环来枚举数组:

for(i=0,x=a.length;i<x;i++){
 document.write(i + ' = ' + a[i]);
}

这将写入:

0 = foo
1 = bar

此外,由于语义的原因,在treats数组(即与任何其他JavaScript对象相同)中使用的方法与其他流行语言不一致。

// C#
char[] a = new char[] {'A', 'B', 'C'};
foreach (char x in a) System.Console.Write(x); //Output: "ABC"

// Java
char[] a = {'A', 'B', 'C'};
for (char x : a) System.out.print(x);          //Output: "ABC"

// PHP
$a = array('A', 'B', 'C');
foreach ($a as $x) echo $x;                    //Output: "ABC"

// JavaScript
var a = ['A', 'B', 'C'];
for (var x in a) document.write(x);            //Output: "012"

以下是这种做法(通常)不好的原因:

对于in循环迭代它们自己的所有可枚举财产及其原型的可枚举财产。通常在数组迭代中,我们只需要迭代数组本身。即使您自己可能没有向数组中添加任何内容,但您的库或框架可能会添加一些内容。

例子:

Array.prototype.hithere=“此处”;var数组=[1,2,3];for(let el in array){//hithere属性也将被迭代控制台日志(el);}

对于in循环不能保证特定的迭代顺序。尽管现在大多数现代浏览器中通常都能看到isorder,但仍然没有100%的保证。对于in循环忽略未定义的数组元素,即尚未分配的数组元素。

例子::

常量arr=[];arr[3]=“foo”;//将阵列大小调整为4arr[4]=未定义;//添加另一个未定义值的元素//遍历数组,for循环确实显示了未定义的元素for(设i=0;i<arr.length;i++){控制台日志(arr[i]);}console.log('\n');//for in忽略未定义的元素for(let el in arr){控制台日志(arr[el]);}