您可以使用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。

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

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

有多种方法可以在javascript中实现。下面是处理数组的常用方法。

方法1：

const students = ["Arun","Jos","John","Kiran"]
for (var index = 0; index < students.length; index++) {
  console.log(students[index]);
}

方法2：

students.forEach（（学生，索引）=>console.log（学生））；

方法3：

for (const student of students) {
      console.log(student);
}
  

for（myStringArray的常量）{

（直接回答你的问题：现在你可以了！）

大多数其他答案都是正确的，但他们没有提到（截至本文撰写之时）ECMAScript 6 2015正在为执行迭代带来一种新的机制。。循环的。

这种新语法是在JavaScript中迭代数组的最优雅的方式（只要不需要迭代索引）。

它目前可与Firefox 13+、Chrome 37+一起使用，并且不能与其他浏览器一起使用（请参阅下面的浏览器兼容性）。幸运的是，我们有JavaScript编译器（如Babel），允许我们今天使用下一代功能。

它也适用于Node.js（我在0.12.0版本上测试过它）。

迭代数组

// You could also use "let" or "const" instead of "var" for block scope.
for (var letter of ["a", "b", "c"]) {
   console.log(letter);
}

迭代对象数组

const band = [
  {firstName : 'John', lastName: 'Lennon'},
  {firstName : 'Paul', lastName: 'McCartney'}
];

for(const member of band){
  console.log(member.firstName + ' ' + member.lastName);
}

循环发电机：

（示例摘自https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of)

function* fibonacci() { // A generator function
  let [prev, curr] = [1, 1];
  while (true) {
    [prev, curr] = [curr, prev + curr];
    yield curr;
  }
}

for (const n of fibonacci()) {
  console.log(n);
  // Truncate the sequence at 1000
  if (n >= 1000) {
    break;
  }
}

兼容性表：http://kangax.github.io/compat-table/es6/#test-用于。。第页，共页

规范：http://wiki.ecmascript.org/doku.php?id=harmony:iterators

}

是的，假设您的实现包括for。。。在ECMAScript 2015（“Harmony”版本）中引入的功能。。。现在这是一个相当安全的假设。

它的工作原理如下：

// REQUIRES ECMASCRIPT 2015+
var s, myStringArray = ["Hello", "World"];
for (s of myStringArray) {
  // ... do something with s ...
}

或者更好，因为ECMAScript 2015还提供了块范围的变量：

// REQUIRES ECMASCRIPT 2015+
const myStringArray = ["Hello", "World"];
for (const s of myStringArray) {
  // ... do something with s ...
}
// s is no longer defined here

（变量s在每次迭代中都是不同的，但只要不在循环体中修改，它仍然可以在循环体内部声明为常量。）

关于稀疏数组的一个注意事项：JavaScript中的数组实际存储的项目可能不像其长度所报告的那么多；该数字仅比存储值的最高索引大一个。如果数组包含的元素少于其长度所指示的元素，则称为稀疏。例如，只有索引3、12和247处的项的数组是完全合法的；这种数组的长度是248，尽管它实际上只存储3个值。如果您试图访问任何其他索引处的项，则该数组将显示为具有未定义的值，但该数组与实际存储有未定义值的数组不同。您可以从许多方面看到这种差异，例如，在Node REPL显示阵列的方式中：

> a              // array with only one item, at index 12
[ <12 empty items>, 1 ]
> a[0]           // appears to have undefined at index 0
undefined
> a[0]=undefined // but if we put an actual undefined there
undefined
> a              // it now looks like this
[ undefined, <11 empty items>, 1 ]

因此，当您想要“循环遍历”数组时，您需要回答一个问题：是要在其长度所指示的整个范围内循环，并为任何缺失的元素处理未定义的元素，还是只处理实际存在的元素？这两种方法都有大量的应用；这取决于您使用数组的目的。

如果使用for..遍历数组。。中，循环的主体执行长度次，并且对于数组中实际不存在的任何项，循环控制变量设置为undefined。根据“使用”代码的细节，这种行为可能是您想要的，但如果不是，您应该使用不同的方法。

当然，有些开发人员别无选择，只能使用不同的方法，因为无论出于什么原因，他们的目标是一个尚不支持的JavaScript版本。。。属于

只要您的JavaScript实现符合先前版本的ECMAScript规范（例如，它排除了9之前版本的Internet Explorer），那么您就可以使用Array#forEach迭代器方法而不是循环。在这种情况下，您将传递一个函数，对数组中的每个项进行调用：

var myStringArray = [ "Hello", "World" ];
myStringArray.forEach( function(s) { 
     // ... do something with s ...
} );

如果您的实现支持ES6+，当然可以使用箭头函数：

myStringArray.forEach( s => { 
     // ... do something with s ...
} );

不同于。。。of，.forEach只为数组中实际存在的元素调用函数。如果传递了具有三个元素且长度为248的假设数组，它将只调用函数三次，而不是248次。如果这是您想要处理稀疏数组的方式，那么即使您的解释器支持。。。属于

最后一个选项是显式计数循环，适用于所有版本的JavaScript。您只需从0到小于长度的1进行计数，并将计数器用作索引。基本循环如下所示：

var i, s, myStringArray = [ "Hello", "World" ], len = myStringArray.length;
for (i=0; i<len; ++i) {
  s = myStringArray[i];
  // ... do something with s ...
}

这种方法的一个优点是可以选择如何处理稀疏数组。上面的代码将运行循环体的整个长度，对于任何缺失的元素，s都设置为undefined，就像for。。属于如果您希望只处理稀疏数组中实际存在的元素，例如.forEach，则可以在索引上添加一个简单的in测试：

var i, s, myStringArray = [ "Hello", "World" ], len = myStringArray.length;
for (i=0; i<len; ++i) {
  if (i in myStringArray) {
    s = myStringArray[i];
    // ... do something with s ...
  }
}

根据实现的优化，将长度值分配给局部变量（而不是在循环条件中包含完整的myStringArray.length表达式）可以显著提高性能，因为它每次都会跳过属性查找。您可以在循环初始化子句中看到长度缓存，如下所示：

var i, len, myStringArray = [ "Hello", "World" ];
for (len = myStringArray.length, i=0; i<len; ++i) {

显式计数循环还意味着您可以访问每个值的索引（如果需要的话）。该索引还作为一个额外的参数传递给传递给forEach的函数，因此您也可以这样访问它：

myStringArray.forEach( (s,i) => {
   // ... do something with s and i ...
});

对于of不会为您提供与每个对象关联的索引，但只要您正在迭代的对象实际上是Array的实例（而不是..of的其他可迭代类型之一），您就可以使用Array#entries方法将其更改为[index，item]对的数组，然后对其进行迭代：

for (const [i, s] of myStringArray.entries()) {
  // ... do something with s and i ...
}

用于。。。在其他人提到的语法中，用于循环对象的财产；因为JavaScript中的Array只是一个具有数字属性名称（以及自动更新的长度属性）的对象，理论上可以用它循环Array。但问题是它并不局限于数字属性值（记住，即使是方法实际上也只是值为闭包的财产），也不能保证按数字顺序迭代。因此，对于。。。in语法不应用于循环数组。

var array=['hai'，'hello'，'how'，'are'，'you']$（文档）.ready（函数（）{$（'#clickButton'）.click（函数（）{对于（var i=0；i<array.length；i++）{警报（阵列[i]）}})})<script src=“https://ajax.googleapis.com/ajax/libs/jquery/1.8.1/jquery.min.js“></script><input id=“clickButton”value=“click Me”type=“button”/><div id=“show”></div>