优化的方法是缓存数组的长度并使用单个变量模式，使用单个var关键字初始化所有变量。

var i, max, myStringArray = ["Hello", "World"];for (i = 0, max = myStringArray.length; i < max; i++) {alert(myStringArray[i]);
// Do something}

如果迭代顺序无关紧要，那么你应该尝试反向循环。它是最快的，因为它减少了开销条件测试，并且递减在一条语句中：

var i,myStringArray = ["item1","item2"];for (i =  myStringArray.length; i--) {alert(myStringArray[i]);}

或者使用而循环更好更干净：

var myStringArray = ["item1","item2"],i = myStringArray.length;while(i--) {// Do something with fruits[i]}

最优雅快捷的方式

var arr = [1, 2, 3, 1023, 1024];for (var value; value = arr.pop();) {value + 1}

http://jsperf.com/native-loop-performance/8

编辑（因为我错了）

比较循环遍历100000项数组的方法，并每次使用新值执行最小操作。

• http://jsben.ch/#/BQhED

准备：

<script src="//code.jquery.com/jquery-2.1.0.min.js"></script><script src="//cdnjs.cloudflare.com/ajax/libs/underscore.js/1.6.0/underscore-min.js"></script><script>Benchmark.prototype.setup = function() {// Fake function with minimal action on the valuevar tmp = 0;var process = function(value) {tmp = value; // Hold a reference to the variable (prevent engine optimisation?)};        
// Declare the test Arrayvar arr = [];for (var i = 0; i < 100000; i++)arr[i] = i;};</script>

测试：

<a href="http://jsperf.com/native-loop-performance/16"title="http://jsperf.com/native-loop-performance/16"><img src="http://i.imgur.com/YTrO68E.png" title="Hosted by imgur.com" /></a>

那么，这个怎么样：

for (var key in myStringArray) {console.log(myStringArray[key]);}

在JavaScript中循环数组有多种方法。

泛型循环：

var i;for (i = 0; i < substr.length; ++i) {// Do something with `substr[i]`}

ES5为每个人：

substr.forEach(function(item) {// Do something with `item`});

jQuery.each：

jQuery.each(substr, function(index, item) {// Do something with `item` (or `this` is also `item` if you like)});

查看这个以获取详细信息，或者您也可以检查MDN以通过JavaScript中的数组进行循环&使用jQuery检查每个jQuery。

例如，我在Firefox控制台中使用：

[].forEach.call(document.getElementsByTagName('pre'), function(e){console.log(e);})

您可以使用querySelectorAll来获得相同的结果

document.querySelectorAll('pre').forEach( (e) => {console.log(e.textContent);})

<pre>text 1</pre><pre>text 2</pre><pre>text 3</pre>

当然，这是低效的，许多人鄙视它，但它是最接近提到的：

var myStringArray = ["Hello","World"];myStringArray.forEach(function(f){// Do something})

导言

自从我上大学以来，我已经用Java，JavaScript，Pascal，ABAP，PHP，进度4GL，C/C++以及其他一些我现在想不出的语言进行编程。

虽然它们都有自己的语言特性，但每种语言都有许多相同的基本概念。这些概念包括过程/函数、IF语句、FOR循环和WHILE循环。

传统的for循环

传统的for循环有三个组成部分：

1. 初始化：在第一次执行look块之前执行
2. 条件：每次在执行循环块之前检查一个条件，如果为false，则退出循环
3. 事后的想法：每次执行循环块后执行

这三个组件由;符号相互分隔。这三个组件中每个组件的内容都是可选的，这意味着以下是尽可能最小的for循环：

for (;;) {// Do stuff}

当然，您需要在for循环中的某个地方包含if(condition === true) { break; }或if(condition === true) { return; }以使其停止运行。

但是，通常情况下，初始化用于声明索引，条件用于将该索引与最小值或最大值进行比较，事后的想法用于增加索引：

for (var i = 0, length = 10; i < length; i++) {console.log(i);}

使用传统的for循环遍历数组

遍历数组的传统方法是这样的：

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

或者，如果你喜欢向后循环，你这样做：

for (var i = myArray.length - 1; i > -1; i--) {console.log(myArray[i]);}

然而，有许多可能的变体，例如这个：

for (var key = 0, value = myArray[key], length = myArray.length; key < length; value = myArray[++key]) {console.log(value);}

…或者这个…

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

…或者这个：

var key = 0, value;for (; value = myArray[key++];){console.log(value);}

哪一个效果最好，很大程度上取决于个人品味和你正在实现的具体用例。

请注意，所有浏览器都支持这些变体，包括非常非常旧的浏览器！

while循环

for循环的一种替代方法是while循环。要循环遍历数组，您可以这样做：

var key = 0;while(value = myArray[key++]){console.log(value);}

与传统的for循环一样，即使是最古老的浏览器也支持while循环。

此外，请注意，每个这时候循环都可以重写为for循环。例如，上面的while循环的行为与这个for-loop完全相同：

for(var key = 0; value = myArray[key++];){console.log(value);}

For...in和for...of

在JavaScript中，你也可以这样做：

for (i in myArray) {console.log(myArray[i]);}

但是，应该小心使用，因为它的行为在所有情况下都与传统的for循环不同，并且需要考虑潜在的副作用。有关更多详细信息，请参阅为什么在数组迭代中使用"for… in"是个坏主意？。

作为#0的替代方案，现在也有#1。以下示例显示了for...of循环和for...in循环之间的区别：

var myArray = [3, 5, 7];myArray.foo = "hello";
for (var i in myArray) {console.log(i); // logs 0, 1, 2, "foo"}
for (var i of myArray) {console.log(i); // logs 3, 5, 7}

此外，您需要考虑没有Internet Explorer版本支持for...of（边缘12+支持），并且for...in至少需要Internet Explorer 10。

Array.prototype.forEach()

for-loops的替代方法是#1，它使用以下语法：

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

所有现代浏览器以及Internet Explorer 9及更高版本都支持Array.prototype.forEach()。

图书馆

最后，许多实用程序库也有自己的foreach变体。AFAIK，三个最流行的是这些：

#0，在jQuery：

$.each(myArray, function(key, value) {console.log(value);});

#0，在<强>Underscore.js：

_.each(myArray, function(value, key, myArray) {console.log(value);});

#0，在洛破折号：

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

简短的回答：是的。你可以这样做：

var myArray = ["element1", "element2", "element3", "element4"];
for (i = 0; i < myArray.length; i++) {console.log(myArray[i]);}

在浏览器控制台中，您可以看到打印的“element1”、“element2”等内容。

如果你想使用jQuery，它的留档中有一个很好的例子：

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

最好使用顺序for循环：

for (var i = 0; i < myStringArray.length; i++) {// Do something}

在JavaScript中有几种方法可以做到这一点。前两个示例是JavaScript示例。第三个使用JavaScript库，即jQuery使用.each()函数。

var myStringArray = ["hello", "World"];for(var i in myStringArray) {alert(myStringArray[i]);}

var myStringArray = ["hello", "World"];for (var i=0; i < myStringArray.length; i++) {alert(myStringArray[i]);}

var myStringArray = ["hello", "World"];$.each(myStringArray, function(index, value){alert(value);})

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>

var myStringArray = ["hello", "World"];myStringArray.forEach(function(val, index){console.log(val, index);})

var obj = ["one","two","three"];
for(x in obj){console.log(obj[x]);}

数组循环：

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);}

在JavaScript中，有很多解决方案可以循环数组。

下面的代码是流行的

/** Declare inputs */const items = ['Hello', 'World']
/** Solution 1. Simple for */console.log('solution 1. simple for')
for (let i = 0; i < items.length; i++) {console.log(items[i])}
console.log()console.log()
/** Solution 2. Simple while */console.log('solution 2. simple while')
let i = 0while (i < items.length) {console.log(items[i++])}
console.log()console.log()
/** Solution 3. forEach*/console.log('solution 3. forEach')
items.forEach(item => {console.log(item)})
console.log()console.log()
/** Solution 4. for-of*/console.log('solution 4. for-of')
for (const item of items) {console.log(item)}
console.log()console.log()

在我看来，最好的方法是使用Array.for每个函数。如果你不能使用它，我建议从MDN获取Poly填充。为了使它可用，这当然是在JavaScript中迭代数组的最安全方法。

Array.prototype.for每个（）

正如其他人所说，这几乎总是你想要的：

var numbers = [1,11,22,33,44,55,66,77,88,99,111];var sum = 0;numbers.forEach(function(n){sum += n;});

这确保了在处理数组的范围内需要的任何东西都保持在该范围内，并且您只处理数组的值，而不是对象属性和其他成员，这就是for .. in所做的。

在大多数情况下，使用常规的C风格for循环是有效的。重要的是要记住循环中的所有内容都与程序的其余部分共享其范围，{}不会创建新的范围。

因此：

var sum = 0;var numbers = [1,11,22,33,44,55,66,77,88,99,111];
for(var i = 0; i<numbers.length; ++i){sum += numbers[i];}
alert(i);

将输出“11”-这可能是也可能不是你想要的。

一个工作的jsFiddle示例：https://jsfiddle.net/workingClassHacker/pxpv2dh5/7/

有，您可以在JavaScript中使用循环执行相同的操作，但不限于。在JavaScript中有很多方法可以对数组进行循环。假设您在下面有这个数组，并且您想对其进行循环：

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

这些是解决方案：

1）for循环

for循环是JavaScript中循环数组的常见方式，但它不被认为是大型数组的最快解决方案：

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

（2）循环

年间循环被认为是遍历长数组的最快方式，但它在JavaScript代码中通常使用较少：

let i=0;
while (arr.length>i) {console.log(arr[i]);i++;}

3）边做边做
do while和while做了同样的事情，有一些语法差异如下：

let i=0;do {console.log(arr[i]);i++;}while (arr.length>i);

这些是执行JavaScript循环的主要方法，但还有更多方法可以做到这一点。

我们还使用for in循环来循环JavaScript中的对象。

还要看看JavaScript中数组上的map()、filter()、reduce()等函数。它们可能比使用while和for更快更好。

如果您想了解有关JavaScript中数组上的异步函数的更多信息，这是一篇很好的文章。

函数式编程已经在有充分的理由：功能技术可以帮助您编写更容易编写的声明性代码一目了然，重构和测试。

函数式编程的基石之一是它的特殊用途列表和列表操作。而这些东西正是听起来像是：事物的数组，以及你对它们所做的事情。但功能性思维模式对他们的态度与你有所不同可以期待

这篇文章将仔细看看我喜欢称之为“大三个“列表操作：map、filter和duce。包装你的头围绕这三个功能是朝着能够编写干净的功能代码，并打开了巨大的大门功能强大的函数式和反应式编程技术。

这也意味着你再也不用写for循环了。

阅读更多>>这里：

似乎所有的变体都被列出了，除了forEach和豆沙：

_.forEach([1, 2], (value) => {console.log(value);});

一个简单的单行解决方案：

arr = ["table", "chair"];
// Solutionarr.map((e) => {console.log(e);return e;});

在JavaScript中循环遍历函数式编程方式中的数组的一些用例：

1.只需循环遍历数组

const myArray = [{x:100}, {x:200}, {x:300}];
myArray.forEach((element, index, array) => {console.log(element.x); // 100, 200, 300console.log(index); // 0, 1, 2console.log(array); // same myArray object 3 times});

注意：Array.prototype.for严格来说，每个（）不是一个函数，因为它作为输入参数的函数不应该返回一个值，因此不能被视为一个纯函数。

2.检查数组中的任何元素是否通过测试

const people = [{name: 'John', age: 23},{name: 'Andrew', age: 3},{name: 'Peter', age: 8},{name: 'Hanna', age: 14},{name: 'Adam', age: 37}];
const anyAdult = people.some(person => person.age >= 18);console.log(anyAdult); // true

3.转换到新数组

const myArray = [{x:100}, {x:200}, {x:300}];
const newArray= myArray.map(element => element.x);console.log(newArray); // [100, 200, 300]

注意：map（）方法创建一个新数组，其结果是对调用数组中的每个元素调用提供的函数。

4.总结一个特定的属性，并计算其平均值

const myArray = [{x:100}, {x:200}, {x:300}];
const sum = myArray.map(element => element.x).reduce((a, b) => a + b, 0);console.log(sum); // 600 = 0 + 100 + 200 + 300
const average = sum / myArray.length;console.log(average); // 200

5.基于原始数组创建一个新数组，但不修改它

const myArray = [{x:100}, {x:200}, {x:300}];
const newArray= myArray.map(element => {return {...element,x: element.x * 2};});
console.log(myArray); // [100, 200, 300]console.log(newArray); // [200, 400, 600]

6.计算每个类别的数量

const people = [{name: 'John', group: 'A'},{name: 'Andrew', group: 'C'},{name: 'Peter', group: 'A'},{name: 'James', group: 'B'},{name: 'Hanna', group: 'A'},{name: 'Adam', group: 'B'}];
const groupInfo = people.reduce((groups, person) => {const {A = 0, B = 0, C = 0} = groups;if (person.group === 'A') {return {...groups, A: A + 1};} else if (person.group === 'B') {return {...groups, B: B + 1};} else {return {...groups, C: C + 1};}}, {});
console.log(groupInfo); // {A: 3, C: 1, B: 2}

7.根据特定条件检索数组的子集

const myArray = [{x:100}, {x:200}, {x:300}];
const newArray = myArray.filter(element => element.x > 250);console.log(newArray); // [{x:300}]

注意：filter（）方法创建一个新数组，其中包含通过所提供函数实现的测试的所有元素。

8.对数组进行排序

const people = [{ name: "John", age: 21 },{ name: "Peter", age: 31 },{ name: "Andrew", age: 29 },{ name: "Thomas", age: 25 }];
let sortByAge = people.sort(function (p1, p2) {return p1.age - p2.age;});
console.log(sortByAge);

9.在数组中找到一个元素

const people = [ {name: "john", age:23},{name: "john", age:43},{name: "jim", age:101},{name: "bob", age:67} ];
const john = people.find(person => person.name === 'john');console.log(john);

Array.prototype.find（）方法返回数组中满足提供的测试函数的第一个元素的值。

参考文献

• Array.prototype.some（）
• Array.prototype.for每个（）
• Array.prototype.map（）
• Array.prototype.filter（）
• Array.prototype.sort（）
• 扩展语法
• Array.prototype.find（）

如果有人对可用于数组迭代的多种机制的性能方面感兴趣，我准备了以下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()方法是最慢的近似，可能是函数调用开销的结果。

正式的（也许是旧的）方法是Array.prototype.forEach(...)：

var arr = ["apple", "banana", "cherry", "mango"];arr.forEach(function(item, index, _) {console.log("[" + index + "] = '" + item + "'");});

深奥

let a= ["Hello", "World"];
while(a.length) { console.log( a.shift() ); }

性能测试

今天（2022-11-13）我对Chrome107、Safari15.2和Firefox 106进行了测试。

结论

• 解决方案C和D在所有数组的所有浏览器上都是快速或最快的。
• 解决方案A和B在所有数组的所有浏览器上都是最慢的

搜索结果

详情

我执行3个测试：

• 小型-用于2个元素数组（如OP）-您可以运行它这里
• 媒体-10K元素数组-你可以运行它这里
• Big-for100K元素数组-你可以运行它这里

下面的代码片段展示了测试中使用的代码。

function A(a) {let r=0;while(a.length) r+= a.shift().length;return r;}
function B(a) {let r=0;for(i in a) r+= a[i].length;return r;}
function C(a) {let r=0;for(x of a) r+= x.length;return r;}
function D(a) {let r=0;for (i=0; i<a.length; ++i) r+= a[i].length;return r;
}
function E(a) {let r=0;a.forEach(x=> r+= x.length);return r;}
let arr= ["Hello", "World!"];[A,B,C,D,E].forEach(f => console.log(`${f.name}: ${f([...arr])}`))

以下是介质数组Chrome的示例结果：

JavaScript中的数组遍历备忘单

给定一个数组，您可以通过以下多种方式之一遍历它。

1.经典for

const myArray = ['Hello', 'World'];
for (let i = 0; i < myArray.length; i++) {console.log(myArray[i]);}

2.for...of

const myArray = ['Hello', 'World'];
for (const item of myArray) {console.log(item);}

3.Array.prototype.forEach()

const myArray = ['Hello', 'World'];
myArray.forEach(item => {console.log(item);});

4.while

const myArray = ['Hello', 'World'];let i = 0;
while (i < myArray.length) {console.log(myArray[i]);i++;}

5.do...while

const myArray = ['Hello', 'World'];let i = 0;
do {console.log(myArray[i]);i++;} while (i < myArray.length);

6.队列样式

const myArray = ['Hello', 'World'];

while (myArray.length) {console.log(myArray.shift());}

7.堆栈样式

备注：这个列表反向打印。

const myArray = ['Hello', 'World'];
while (myArray.length) {console.log(myArray.pop());}

//Make arrayvar array = ["1","2","3","4","5","6","7","8","9","10"]//Loopfor(var i = 0; i < array.length; i++){console.log((i+1) + " --> " + array[i])}

对于i的实际数字，如果需要，您需要将(i+1)更改为i或(i)。
希望有帮助

6种不同的方法循环遍历数组

您可以通过许多不同的方法循环遍历数组。我从上到下整理了我最喜欢的6种方法。

1.使用for循环

当它简单地循环遍历数组时，for循环是我的首选。

let array = [1, 2, 3, 4, 5];for (let i = 0; i < array.length; i++) {console.log(array[i]);}

2.使用foreach循环

forEach循环是一种遍历数组的现代方式。此外，它提供了对数组和元素的更多灵活性和控制。

let array = [1, 2, 3, 4, 5];array.forEach((element) => {console.log(element);});

3.使用for. of

for...of循环让您可以直接访问数组元素。

let array = [1, 2, 3, 4, 5];for (let element of array) {console.log(element);}

4.使用for… in循环

for...in为您提供了一个键，您可以使用它访问数组元素。

let array = [1, 2, 3, 4, 5];for(let index in array){console.log(array[index]);}

5.使用if循环

虽然循环也可用于循环遍历数组。

let array = [1, 2, 3, 4, 5];let length = array.length;while(length > 0){console.log(array[array.length - length]);length--;}

6.使用do…这时循环

同样，我使用do...while循环

let array = [1, 2, 3, 4, 5];let length = array.length;do {console.log(array[array.length - length]);length--;}while (length > 0)

数组迭代有4种方式：

// 1: for
for (let i = 0; i < arr.length; ++i) {console.log(arr[i]);}
// 2: forEach
arr.forEach((v, i) => console.log(v));
// 3: for in
for (let i in arr) {console.log(arr[i]);}
// 4: for of
for (const v of arr) {console.log(v);}

总结:1和3个解决方案创建额外的变量，2-创建额外的函数上下文。最好的方法是第四个-“for of”。

考虑这个：

const ITEMS = ['One','Two','Three']let item=-1
//Then, you get looping with every call of:
ITEMS[item=item==ITEMS.length-1?0:item+1]

在javascript中有多种方法可以做到这一点。以下是处理数组的常见方法。

方法一：

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

方法二：

students.forEach((student, index) => console.log(student));

方法三：

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

此答案提供了循环和数组函数的替代方法来迭代数组。

在某些情况下，使用递归实现而不是传统的循环和回调是有意义的。特别是，如果你必须使用多个数组或嵌套数组。你避免编写嵌套循环来访问来自多个数组的数据。我还发现这段代码更容易读写。

/**array is the array your wish to iterate.response is what you want to return.index increments each time the function calls itself.**/
const iterateArray = (array = [], response = [], index = 0) => {const data = array[index]
// If this condition is met. The function returns and stops calling itself.if (!data) {return response}// Do work...response.push("String 1")response.push("String 2")
// Do more work...
// THE FUNCTION CALLS ITSELFiterateArray(data, response, index+=1)}
const mainFunction = () => {const text = ["qwerty", "poiuyt", "zxcvb"]
// Call the recursive functionconst finalText = iterateArray(text)console.log("Final Text: ", finalText()}

假设传递给iterateArray的数组包含对象而不是字符串。每个对象都包含另一个数组。您必须运行嵌套循环才能访问内部数组，但如果您递归迭代，则不会。

您也可以将iterateArray作为Promise。

const iterateArray = (array = [], response = []) =>new Promise(async (resolve, reject) => {const data = array.shift()// If this condition is met, the function returns and stops calling itself.if (!data) {return resolve(response)}
// Do work here...
const apiRequestData = data.innerArray.find((item) => {item.id === data.sub_id})
if (apiRequestData) {try {const axiosResponse = await axios.post("http://example.com",apiRequestData)if (axiosResponse.status === 200) {response.push(apiRequestData)} else {return reject("Data not found")}} catch (error) {reject(error)}} else {return reject("Data not found")}// THE FUNCTION RESOLVES AND CALLS ITSELFresolve(iterateArray(data, response))})