在nodeJs中有没有使用数组大小​​循环数组的方法？

Question

假设我有

myArray = ['item1', 'item2']

我试过

for (var item in myArray) {console.log(item)}

打印     0     1

我希望拥有什么     ITEM1     ITEM2

是否有其他语法无法使用

for (var i = 0; i < myArray.length; i++)

Answer 1

您可以使用Array.forEach

＆＃13;

＆＃13;

var myArray = ['1','2',3,4]

myArray.forEach(function(value){
  console.log(value);
});

＆＃13;

＆＃13;

＆＃13;

Answer 2

你可能想要的是for...of，这是一个相对较新的构造，用于枚举可迭代对象的值：

let myArray = ["a","b","c","d"];
for (let item of myArray) {
  console.log(item);
}

...与for...in不同，后者枚举属性名称（在数组的情况下可能是 ¹ 数字索引）。您的循环显示意外结果，因为您没有使用属性名称通过bracket notation获取相应的值...但您可以：

let myArray = ["a","b","c","d"];
for (let key in myArray) {
  let value =  myArray[key]; // get the value by key
  console.log("key: %o, value: %o", key, value);
}

_{¹ 很遗憾，有人可能已将enumerable properties添加到不数字的数组或其原型链中指数......或者他们可能已经指定了一个指数，在临时范围内留下未指定的指数。这些问题很好地解释了here。主要的一点是，最好明确地从0循环到array.length - 1，而不是使用for...in。}

所以，这不是（正如我原先认为的那样）一个学术问题，即：

  

不考虑实用性，在遍历数组时，可能是否可以避免length？

根据your comment（强调我的）：

  

[...]为什么我需要计算数组的大小，而解释器可以知道它。

你对Array.length有误导的厌恶。它不是即时计算的;只要数组的长度发生变化，它就会更新。你不会通过避免它来获得性能提升（除了缓存数组长度而不是访问属性）：

现在，即使你确实获得了一些边际绩效增长，我也怀疑它是否足以证明处理上述问题的风险是合理的。

Answer 3

要打印'item1'，'item2'，此代码将有效。

var myarray = ['hello', ' hello again'];

for (var item in myarray) {
    console.log(myarray[item])
}

Answer 4

在ES5中，没有使用length属性迭代稀疏数组的有效方法。在ES6中，您可以使用for...of。举个例子：

'use strict';

var arr = ['one', 'two', undefined, 3, 4],
    output;

arr[6] = 'five';

output = '';
arr.forEach(function (val) {
    output += val + ' ';
});
console.log(output);

output = '';
for (var i = 0; i < arr.length; i++) {
    output += arr[i] + ' ';
}
console.log(output);

output = '';
for (var val of arr) {
    output += val + ' ';
};
console.log(output);

<!-- results pane console output; see http://meta.stackexchange.com/a/242491 -->
<script src="//gh-canon.github.io/stack-snippet-console/console.min.js"></script>

可用于在密集数组上安全迭代的所有数组方法都使用通过调用length internaly创建的对象的ToObject属性。例如，请参阅forEach方法中使用的算法：http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.18 但是在es6中，您可以安全地使用for...of来迭代稀疏数组。

另见Are Javascript arrays sparse?。

Answer 5

使用迭代器...

var myarray = ['hello', ' hello again'];
processArray(myarray[Symbol.iterator](), () => {
    console.log('all done')
})
function processArray(iter, cb) {
    var curr = iter.next()
    if(curr.done)
        return cb()
    console.log(curr.value)
    processArray(iter, cb)
}

更深入的概述：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols

Answer 6

    var count=0;
    let myArray = '{"1":"a","2":"b","3":"c","4":"d"}'
    var data = JSON.parse(myArray);
    for (let key in data) {
      let value =  data[key]; // get the value by key
      console.log("key: , value:", key, value);
      count = count + 1;
    }
   console.log("size:",count);

Answer 7

这是自然的javascript选项

var myArray = ['1','2',3,4]

myArray.forEach(function(value){
  console.log(value);
});

但是，如果在forEach循环中使用 await ，则该方法将不起作用，因为forEach不是异步的。 您将被迫使用第二个答案或其他等效的答案：

let myArray = ["a","b","c","d"];
for (let item of myArray) {
  console.log(item);
}

或者您可以创建一个此处解释的asyncForEach：

  

https://codeburst.io/javascript-async-await-with-foreach-b6ba62bbf404

Answer 8

使用名为map的内置Javascript函数。 .map（）将完成您正在寻找的确切事情！