简单的单线解决方案：

arr=[“桌子”，“椅子”]；//解决方案arr.map（（e）=>{控制台日志（e）；返回e；});

阵列循环：

for(var i = 0; i < things.length; i++){
    var thing = things[i];
    console.log(thing);
}

对象循环：

for(var prop in obj){
    var propValue = obj[prop];
    console.log(propValue);
}

您可以使用map，这是一种函数式编程技术，也可以在Python和Haskell等其他语言中使用。

[1,2,3,4].map( function(item) {
     alert(item);
})

一般语法为：

array.map(func)

一般来说，func需要一个参数，这是数组的一个项。但在JavaScript的情况下，它可以接受第二个参数，即项目的索引，以及第三个参数，也就是数组本身。

array.map的返回值是另一个数组，因此可以这样使用：

var x = [1,2,3,4].map( function(item) {return item * 10;});

现在x是[10,20,30,40]。

您不必内联编写函数。它可能是一个单独的功能。

var item_processor = function(item) {
      // Do something complicated to an item
}

new_list = my_list.map(item_processor);

这相当于：

 for (item in my_list) {item_processor(item);}

除非你没有得到new_list。

三个主要选项：

对于（var i=0；i<xs.length；i++）｛console.log（xs[i]）；｝xs.forEach（（x，i）=>console.log（x））；for（xs的常量x）｛console.log（x）；｝

下面是详细的示例。

---

1.循环顺序：

var myStringArray=[“Hello”，“World”]；var arrayLength=myStringArray.length；for（var i=0；i<arrayLength；i++）{console.log（myStringArray[i]）；//做点什么}

Pros

适用于各种环境可以使用break和continue流控制语句

Cons

过于冗长迫切的容易出现一个错误（有时也称为围栏柱错误）

2.阵列.原型.每个：

ES5规范引入了许多有益的数组方法。其中一个是Array.prototype.forEach，它为我们提供了一种简单的方法来遍历数组：

常量数组=[“一”，“二”，“三”]array.forEach（函数（项，索引）{console.log（项，索引）；});

在撰写ES5规范发布之时（2009年12月）已近十年，它已被桌面、服务器和移动环境中的几乎所有现代引擎实现，因此使用它们是安全的。

使用ES6箭头函数语法，它更加简洁：

array.forEach(item => console.log(item));

箭头功能也被广泛实现，除非您计划支持古老的平台（例如Internet Explorer 11）；你去也很安全。

Pros

非常简短和简洁。声明的

Cons

无法使用中断/继续

通常，您可以通过在迭代数组元素之前过滤数组元素来代替中断命令循环的需要，例如：

array.filter(item => item.condition < 10)
     .forEach(item => console.log(item))

请记住，如果您正在迭代一个数组以从中构建另一个数组，则应该使用map。我见过很多次这种反模式。

反模式：

const numbers = [1,2,3,4,5], doubled = [];

numbers.forEach((n, i) => { doubled[i] = n * 2 });

地图的正确使用情况：

常量=[1,2,3,4,5]；常量doubled=numbers.map（n=>n*2）；console.log（加倍）；

此外，如果您试图将数组缩减为一个值，例如，您希望对一个数字数组求和，则应使用reduce方法。

反模式：

const numbers = [1,2,3,4,5];
const sum = 0;
numbers.forEach(num => { sum += num });

正确使用reduce：

常量=[1,2,3,4,5]；常量sum=数字。减少（（total，n）=>total+n，0）；console.log（总和）；

3.声明的ES6：

ES6标准引入了可迭代对象的概念，并定义了用于遍历数据的新构造，即for。。。声明。

此语句适用于任何类型的可迭代对象，也适用于生成器（任何具有\[Symbol.iiterator\]属性的对象）。

根据定义，数组对象是ES6中内置的可迭代对象，因此可以对它们使用以下语句：

let colors = ['red', 'green', 'blue'];
for (const color of colors){
    console.log(color);
}

Pros

它可以遍历大量对象。可以使用正常的流量控制语句（中断/继续）。用于迭代串行异步值。

Cons

如果您的目标是较旧的浏览器，则转译的输出可能会让您大吃一惊。

不用于。。。在里面

@zipcodeman建议使用for。。。在语句中，但对于迭代数组，应该避免for-in，该语句旨在枚举对象财产。

它不应用于类似数组的对象，因为：

迭代的顺序没有保证；数组索引不能按数字顺序访问。还枚举了继承的财产。

第二点是它会给您带来很多问题，例如，如果您扩展Array.prototype对象以在其中包含一个方法，那么该属性也会被枚举。

例如：

Array.prototype.foo=“foo！”；var数组=[‘a’，‘b’，‘c’]；for（数组中的变量i）{console.log（array[i]）；}

上面的代码将控制台日志“a”、“b”、“c”和“foo！”。

如果您使用一些严重依赖原生原型扩充的库（如MooTools），这可能是一个特别的问题。

如前所述，for-in语句用于枚举对象财产，例如：

变量obj={“a”：1，“b”：2，“c”：3};for（obj中的var属性）{if（obj.hasOwnProperty（prop））{//或如果（Object.protype.hasOwnProperty.call（obj，prop））安全。。。console.log（“prop:”+prop+“value:”+obj[prop]）}}

在上面的示例中，hasOwnProperty方法允许您仅枚举自己的财产。就是这样，只有对象物理上具有的财产，没有继承的财产。

我建议您阅读以下文章：

枚举VS迭代

如果有人对Array迭代可用的多种机制的性能方面感兴趣，我准备了以下JSPerf测试：

https://jsperf.com/fastest-array-iterator

结果：

传统的for（）迭代器是迄今为止最快的方法，尤其是在缓存数组长度时。

let arr = [1,2,3,4,5];

for(let i=0, size=arr.length; i<size; i++){
    // Do something
}

Array.prototype.forEach（）和Array.prototype.map（）方法是最慢的近似方法，可能是函数调用开销的结果。

如果您想使用jQuery，它的文档中有一个很好的示例：

 $.each([ 52, 97 ], function( index, value ) {
      alert( index + ": " + value );
 });