我有一个JavaScript对象,如下所示:

var p = {
    "p1": "value1",
    "p2": "value2",
    "p3": "value3"
};

我如何循环遍历p的所有元素(p1、p2、p3…)并获取它们的键和值?


当前回答

在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上此问题中所有最常见情况的性能比较:

对象文字迭代

其他回答

var p=[{“用户名”:“ordermanageadmin”,“user_id”:“2”,“resource_id”“Magento_Sales::actions”},{“用户名”:“ordermanageadmin_1”,“user_id”:“3”,“resource_id”“Magento_Sales::actions”}]for(p中的var值){for(值中的var键){if(p.hasOwnProperty(键)){console.log(键+“->”+p[key]);}}}

for(key in p) {
  alert( p[key] );
}

注意:可以对数组执行此操作,但也要对长度和其他财产进行迭代。

单行和更可读的代码可以。。

Object.entries(myObject).map(([key, value]) => console.log(key, value))

在可枚举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。

在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相同的顺序迭代财产。。。但忽略原型链。只迭代对象自己的可枚举财产。