在可枚举JavaScript对象上进行循环的一个好方法是使用object.keys或object.entries并使用map函数，这对于ReactJS来说可能是非常棒和常见的。如下所示：

// assume items:

const items = {
  first: { name: 'phone', price: 400 },
  second: { name: 'tv', price: 300 },
  third: { name: 'sofa', price: 250 },
};

对于循环和显示ReactJS上的一些UI，如下所示：

~~~
<div>
  {Object.entries(items).map(([key, ({ name, price })]) => (
    <div key={key}>
     <span>name: {name}</span>
     <span>price: {price}</span>
    </div>
  ))}
</div>

实际上，我使用了两次析构函数赋值，一次用于获取key，一次是获取name和price。

前言：

对象财产可以是自己的（属性在对象本身上），也可以是继承的（不在对象本身或其原型上）。对象财产可以是可枚举的或非可枚举的。在许多属性枚举/数组中，不包含非数财产。属性名称可以是字符串或符号。许多属性枚举/数组都没有包含名称为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%！重要的}

在ECMAScript 5下，可以组合Object.keys（）和Array.protocol.forEach（）：

var obj = { first: "John", last: "Doe" };

Object.keys(obj).forEach(function(key) {
    console.log(key, obj[key]);
});

ECMAScript 6添加了。。。第页，共页：

for (const key of Object.keys(obj)) {
    console.log(key, obj[key]);
}

ECMAScript 8添加了Object.entries（），避免了查找原始对象中的每个值：

Object.entries(obj).forEach(
    ([key, value]) => console.log(key, value)
);

你可以组合。。。of、destructuring和Object.entries：

for (const [key, value] of Object.entries(obj)) {
    console.log(key, value);
}

Object.keys（）和Object.entries（）以与for相同的顺序迭代财产。。。但忽略原型链。只迭代对象自己的可枚举财产。

在ES6中，我们有众所周知的符号来公开一些以前的内部方法，您可以使用它来定义迭代器如何为这个对象工作：

var p = {
    "p1": "value1",
    "p2": "value2",
    "p3": "value3",
    *[Symbol.iterator]() {
        yield *Object.keys(this);
    }
};

[...p] //["p1", "p2", "p3"]

这将给出与用于…相同的结果。。。在es6循环中。

for(var key in p) {
    console.log(key);
}

但了解您现在使用es6的能力很重要！

在ECMAScript 5中，在literal-Object.keys的迭代字段中有了新的方法

您可以在MDN上看到更多信息

我的选择如下，作为当前版本浏览器（Chrome30、IE10、FF25）中的更快解决方案

var keys = Object.keys(p),
    len = keys.length,
    i = 0,
    prop,
    value;
while (i < len) {
    prop = keys[i];
    value = p[prop];
    i += 1;
}

您可以将此方法的性能与jsperf.com上的不同实现进行比较：

扩展实施对象键迭代对象文字迭代

您可以在Kangax的兼容表上看到浏览器支持

对于旧浏览器，您有简单而完整的polyfill

UPD:

perfjs.info上此问题中所有最常见情况的性能比较：

对象文字迭代

最接近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}`）；}