最接近python的enumerate函数的解决方案：

for key, value in enumerate(object):
    # Do something

是Object.entries（）和for of循环的组合：

for(let [key, value] of Object.entries(object)) {
    // Do something
}

let对象={key1:“value1”，key2:“value2”，key3:“value3”，key4:“value4”，key5:“value5”};for（let[key，value]of Object.entries（Object））{console.log（`${key}->${value}`）；}

您必须使用for in循环

但在使用这种循环时要非常小心，因为这将沿着原型链循环所有财产。

因此，在循环中使用for时，请始终使用hasOwnProperty方法来确定迭代中的当前属性是否真的是要检查的对象的属性：

for (var prop in p) {
    if (!p.hasOwnProperty(prop)) {
        //The current property is not a direct property of p
        continue;
    }
    //Do your logic with the property here
}

Object.keys（obj）：数组检索所有可枚举自身（非继承）财产的所有字符串值键。

因此，通过使用hasOwnProperty测试每个对象键，它提供了与您想要的相同的键列表。您不需要额外的测试操作，因为Object.keys（obj）.forEach（function（key）｛｝）应该更快。让我们来证明一下：

var uniqid=函数（）{var text=“”，i＝0，可能=“ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvxyz”；对于（；i<32；i++）{text+=可能的charAt（数学地板（数学随机（）*可能的长度））；}返回文本；}, 周期＝100000，obj＝{}，p1，p2，p3，钥匙//使用随机财产填充对象Array.apply（null，Array（CYCLES））.forEach（function（）{obj[uniqid（）]=新日期（）});//方法#1p1=performance.now（）；Object.keys（obj）.forEach（函数（键）{var waste=obj[key]；});p2=performance.now（）；console.log（“Object.keys方法耗时”+（p2-p1）+“毫秒”）；//方法#2for（在obj中键入）{if（obj.hasOwnProperty（键））{var waste=obj[key]；}}p3=performance.now（）；console.log（“for…in/hasOwnProperty方法花费了”+（p3-p2）+“毫秒”）；

在我的Firefox中，我有以下结果

Object.keys方法耗时40.21101451665163毫秒。对于in/hasOwnProperty方法耗时98.26163508463651毫秒。

在Chrome上，差异更大http://codepen.io/dsheiko/pen/JdrqXa

PS2：在ES6（EcmaScript 2015）中，您可以更好地迭代可迭代对象：

let map=new map（）.set（'a'，1）.set（'b'，2）；for（let对映射）{console.log（对）；}//或let map=新地图([[错误，'否']，[真，'是']，]);map.forEach（（value，key）=>{console.log（键，值）；});

前言：

对象财产可以是自己的（属性在对象本身上），也可以是继承的（不在对象本身或其原型上）。对象财产可以是可枚举的或非可枚举的。在许多属性枚举/数组中，不包含非数财产。属性名称可以是字符串或符号。许多属性枚举/数组都没有包含名称为Symbol的财产。

2018年，您可以选择循环访问对象的财产（以下是一些示例）：

for-in[MDN，spec]-一种循环结构，循环遍历对象的可枚举财产的名称，包括名称为字符串的继承属性keys[MDN，spec]-一个函数，提供对象自己的可枚举财产的名称数组，这些属性的名称是字符串。Object.values[MDN，spec]-提供对象自身可枚举财产值数组的函数。Object.entries[MDN，spec]-提供对象自身可枚举财产的名称和值数组的函数（数组中的每个条目都是[name，value]数组）。Object.getOwnPropertyNames[MDN，spec]-一个函数，提供对象自己的财产（即使是不可枚举的属性）的名称数组，这些属性的名称是字符串。Object.getOwnPropertySymbols[MDN，spec]-一个函数，提供对象自己的财产（即使是不可枚举的属性）的名称数组，其名称为Symbols。Reflect.ownKeys[MDN，spec]-一个函数，提供对象自己的财产（即使是非枚举属性）的名称数组，无论这些名称是字符串还是符号。如果需要对象的所有财产，包括非枚举继承的属性，则需要使用循环和object.getPrototypeOf[MDN，spec]，并在原型链中的每个对象上使用object.getOwnPropertyNames、object.getOwnPropertySymbols或Reflect.ownKeys（此答案底部的示例）。

对于除in之外的所有元素，您将在数组上使用某种循环构造（for、for、forEach等）。

示例：

中的：

//要从中继承的原型对象，具有名为property的字符串常量p＝{answer:42}；//我们将看到的对象继承自`p`const o=对象创建（p）；//名为property的字符串o.question=“生命、宇宙和一切”；//名为属性的符号o[Symbol（“author”）]=“Douglas Adams”；for（o中的常量名称）{常量值=o[名称]；console.log（`$｛name｝=$｛value｝`）；}

Object.keys（带有for of循环，但可以使用任何循环构造）：

//要从中继承的原型对象，具有名为property的字符串常量p＝{answer:42}；//我们将看到的对象继承自`p`const o=对象创建（p）；//名为property的字符串o.question=“生命、宇宙和一切”；//名为属性的符号o[Symbol（“author”）]=“Douglas Adams”；for（Object.keys（o）的常量名称）{常量值=o[名称]；console.log（`$｛name｝=$｛value｝`）；}

对象值：

//要从中继承的原型对象，具有名为property的字符串常量p＝{answer:42}；//我们将看到的对象继承自`p`const o=对象创建（p）；//名为property的字符串o.question=“生命、宇宙和一切”；//名为属性的符号o[Symbol（“author”）]=“Douglas Adams”；for（Object.values（o）的常量值）{console.log（`${value}`）；}

对象条目：

//要从中继承的原型对象，具有名为property的字符串常量p＝{answer:42}；//我们将看到的对象继承自`p`const o=对象创建（p）；//名为property的字符串o.question=“生命、宇宙和一切”；//名为属性的符号o[Symbol（“author”）]=“Douglas Adams”；for（Object.entries（o）的常量[名称，值]）{console.log（`$｛name｝=$｛value｝`）；}

Object.getOwnPropertyName:

//要从中继承的原型对象，具有名为property的字符串常量p＝{answer:42}；//我们将看到的对象继承自`p`const o=对象创建（p）；//名为property的字符串o.question=“生命、宇宙和一切”；//名为属性的符号o[Symbol（“author”）]=“Douglas Adams”；for（Object.getOwnPropertyNames（o）的常量名称）{常量值=o[名称]；console.log（`$｛name｝=$｛value｝`）；}

Object.getOwnPropertySymbols：

//要从中继承的原型对象，具有名为property的字符串常量p＝{answer:42}；//我们将看到的对象继承自`p`const o=对象创建（p）；//名为property的字符串o.question=“生命、宇宙和一切”；//名为属性的符号o[Symbol（“author”）]=“Douglas Adams”；for（Object.getOwnPropertySymbol（o）的常量名称）{常量值=o[名称]；console.log（`${String（name）}=${value}`）；}

反射所有键：

//要从中继承的原型对象，具有名为property的字符串常量p＝{answer:42}；//我们将看到的对象继承自`p`const o=对象创建（p）；//名为property的字符串o.question=“生命、宇宙和一切”；//名为属性的符号o[Symbol（“author”）]=“Douglas Adams”；for（Reflect.ownKeys（o）的常量名称）{常量值=o[名称]；console.log（`${String（name）}=${value}`）；}

所有财产，包括继承的非枚举属性：

//要从中继承的原型对象，具有名为property的字符串常量p＝{answer:42}；//我们将看到的对象继承自`p`const o=对象创建（p）；//名为property的字符串o.question=“生命、宇宙和一切”；//名为属性的符号o[Symbol（“author”）]=“Douglas Adams”；for（让深度=0，当前=o；当前；++深度，当前=Object.getPrototypeOf（当前））{for（Reflect.ownKeys（当前）的常量名称）{常量值=o[名称]；console.log（`[$｛depth｝]$｛String（name）｝=$｛字符串（value）｝`）；}}.作为控制台包装{最大高度：100%！重要的}

下面是另一种迭代对象的方法。

变量p={“p1”：“值1”，“p2”：“值2”，“p3”：“值3”};Object.keys（p）.forEach（key=>{console.log（key，p[key]）}）

Object.entries（）函数：

变量p={“p1”：“值1”，“p2”：“值2”，“p3”：“值3”};for（Object.entries（p）中的var i）{var key=对象条目（p）[i][0]；var value=对象条目（p）[i][1]；console.log（'key['+i+']='+key+'+'value['+i+']='+value）；}