注意：
这个问题依然适用于
for...of循环。 不要使用for...in来遍历一个数组，而是用它来遍历一个对象的属性。话虽如此，这段代码
我理解在JavaScript中基本的for...in语法如下：
for (var obj in myArray) {
// ...
}
但是我该如何获取循环的计数器/索引？
var i = 0;
for (var obj in myArray) {
alert(i)
i++
}
for (var i = 0; i < myArray.length; i++) {
var obj = myArray[i]
alert(i)
}
但我更愿意使用更简单的for-in循环。我认为它们看起来更好，并且更有意义。
是否有更简单或更优雅的方法？
for i, obj in enumerate(myArray):
print i
for…in 循环遍历的是属性名，而不是值，并且顺序不确定（即使在 ES6 后也是如此）。你不应该使用它来遍历数组。对于数组，可以使用 ES5 的forEach 方法，该方法将值和索引都传递给你提供的函数：
var myArray = [123, 15, 187, 32];
myArray.forEach(function (value, i) {
console.log('%d: %s', i, value);
});
// Outputs:
// 0: 123
// 1: 15
// 2: 187
// 3: 32
或者是ES6的Array.prototype.entries，它现在已经在当前浏览器版本中得到支持：
for (const [i, value] of myArray.entries()) {
console.log('%d: %s', i, value);
}
对于通用可迭代对象（您将使用 for…of 循环而不是 for…in 循环的情况），没有内置方法，但是可以使用 for…of 循环：
function* enumerate(iterable) {
let i = 0;
for (const x of iterable) {
yield [i, x];
i++;
}
}
for (const [i, obj] of enumerate(myArray)) {
console.log(i, obj);
}
Object.keys(obj).forEach，但它只包括自己的属性；而for…in则包括原型链上任何可枚举的属性。let是具有块级作用域的var。const是不可变的。 - Ry-myArray.forEach(function (value, *i*) (重点在于我)。这太完美了。我知道一定有比我一直在做的那个 myArray.indexOf(value) 垃圾更好的方法。+1。 - Braden Best%d 格式化整数，%s 格式化字符串。它们受 printf 的启发。规范正在 https://console.spec.whatwg.org/#formatter 进行中。 - Ry-forEach 的缺点是，内部的 await 作用域限定在函数参数中，而不是外部作用域。因此，如果你想在循环内部使用 await，你可能需要使用 .entries()。 - user1338062在ES6中，使用for...of循环是一个很好的选择，可以像这样获取for...of中的索引。
for (let [index, val] of array.entries()) {
// your code goes here
}
Array.entries()返回一个迭代器，这使得它可以在for-of循环中使用；不要将其与返回键值对数组的Object.entries()混淆。next() 方法的对象，每次调用它都会返回数组中后续的条目。它里面没有（可见的）数据；你通过调用 next() 来获取底层对象中的数据，而 for-of 在幕后执行此操作。抄送 @tonyg - Shog9await能够按顺序工作，而forEach则不能。 - geoidesicArray。 for...of适用于任何Iterable。您可能需要使用for (const [index, value] of [...array].entries())将其转换为Array。可迭代对象包括HTMLCollection、NodeList和其他DOM类。 - ShortFuselet 而不是 const？ - Ben这个怎么样？
let numbers = [1,2,3,4,5]
numbers.forEach((number, index) => console.log(`${index}:${number}`))
array.forEach 这个方法有一个 index 参数，它表示当前在数组中处理的元素的索引。
break不可用，因此foreach循环不利于优化。 - Zhong Ri小数组集合的解决方案：
for (var obj in arr) {
var i = Object.keys(arr).indexOf(obj);
}
arr - 数组， obj - 当前元素的键， i - 计数器/索引
注意：方法keys()在IE版本<9中不可用，您应该使用Polyfill代码。 https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/keys
var i = 0; 和 i++; 更短更高效。此外，它不适用于不是自身属性的可枚举属性。 - Ry-For-in循环遍历对象的属性。不要在数组上使用它们，即使它们有时可以工作。
对象属性没有索引，它们都是相等的，并且不需要按照确定的顺序运行。如果您想计算属性数，您将不得不设置额外的计数器（就像您在第一个示例中所做的那样）。
遍历数组：
var a = [];
for (var i=0; i<a.length; i++) {
i // is the index
a[i] // is the item
}
遍历对象：
var o = {};
for (var prop in o) {
prop // is the property name
o[prop] // is the property value - the item
}
(var i=0; i<a.length; i++)，因为这会浪费资源。应该使用(var i=0, var len = a.length; i<len; i++)。 - Félix Sanzvar i=0; i<a.length; i++) 是标准的循环模式，在任何好的 JavaScript 引擎中都进行了优化。 - Bergivar i=0; i<a.length; i++ 是最佳实践。 - Bergi正如其他人所说，你不应该使用for..in来迭代数组。
for ( var i = 0, len = myArray.length; i < len; i++ ) { ... }
如果你想要更简洁的语法，你可以使用forEach：
myArray.forEach( function ( val, i ) { ... } );
如果您想使用此方法，请确保包含ES5 shim以添加对旧版浏览器的支持。
rushUp 给出的答案是正确的，但这种方法更加方便。
for (let [index, val] of array.entries() || []) {
// your code goes here
}
|| []是不必要的，并且永远不会被使用；array.entries()总是真值。 - Ry-entries。这似乎对许多开发人员来说很不直观，因此我创建了这个性能基准测试。
它的速度快了约6倍。主要原因是不需要：a）多次访问数组，b）转换索引。
const eachWithIndex = (iterable) => {
return {
*[Symbol.iterator]() {
let i = 0
for(let val of iterable) {
i++
yield [i, val]
}
}
}
}
const isPrime = (n) => {
for (i = 2; i < Math.floor(Math.sqrt(n) + 1); i++) {
if (n % i == 0) {
return false
}
}
return true
}
let primes = {
*[Symbol.iterator]() {
let candidate = 2
while (true) {
if (isPrime(candidate)) yield candidate
candidate++
}
}
}
for (const [i, prime] of eachWithIndex(primes)) {
console.log(i, prime)
if (i === 100) break
}eachWithIndex[Symbol.iterator] 的函数，而不是一个名为 eachWithIndex 的函数？eachWithIndex 不满足可迭代接口，这也正是 Symbol.iterator 的全部意义所在。 - Ry-eachWithIndex 改为接受可迭代对象并返回闭合的复合迭代器。 - akurtsereachWithIndex的函数，可以与任何可迭代对象一起使用。eachWithKey，使用for...in可以处理对象。// example generator (returns an iterator that can only be iterated once)
function* eachFromTo(start, end) { for (let i = start; i <= end; i++) yield i }
// convers an iterable to an array (potential infinite loop)
function eachToArray(iterable) {
const result = []
for (const val of iterable) result.push(val)
return result
}
// yields every value and index of an iterable (array, generator, ...)
function* eachWithIndex(iterable) {
const shared = new Array(2)
shared[1] = 0
for (shared[0] of iterable) {
yield shared
shared[1]++
}
}
console.log('iterate values and indexes from a generator')
for (const [val, i] of eachWithIndex(eachFromTo(10, 13))) console.log(val, i)
console.log('create an array')
const anArray = eachToArray(eachFromTo(10, 13))
console.log(anArray)
console.log('iterate values and indexes from an array')
for (const [val, i] of eachWithIndex(anArray)) console.log(val, i)
alert(obj)吗？ - gen_Eric