如何在JavaScript中循环或枚举一个对象？

单行和更易读的代码可以通过使用链式方法来实现。

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

在查看这里的所有答案后，由于我的JSON对象是干净的，因此不需要hasOwnProperty进行处理；添加任何额外的javascript处理是没有意义的。这就是我正在使用的全部内容：

for (var key in p) {
    console.log(key + ' => ' + p[key]);
    // key is key
    // value is p[key]
}

通过使用 原型 和 forEach() 方法，应该跳过原型链上的属性:

Object.prototype.each = function(f) {
    var obj = this
    Object.keys(obj).forEach( function(key) { 
        f( key , obj[key] ) 
    });
}


//print all keys and values
var obj = {a:1,b:2,c:3}
obj.each(function(key,value) { console.log(key + " " + value) });
// a 1
// b 2
// c 3

有趣的是，这些回答中的人们涉及了Object.keys()和for...of，但从未将它们结合起来使用：

var map = {well:'hello', there:'!'};
for (let key of Object.keys(map))
    console.log(key + ':' + map[key]);

_{因为对象不是迭代器，所以你不能仅使用 for...of 来循环遍历一个 Object , 使用 for...index 或者 .forEach() 循环遍历 Object.keys() 不够优雅和高效。}

你可以使普通的对象关联可迭代！直接使用高级特性 for...of ，表现像 Map 一样
DEMO 可在Chrome和FF中运行（我假设此处使用了ES6）

var ordinaryObject = {well:'hello', there:'!'};
for (let pair of ordinaryObject)
    //key:value
    console.log(pair[0] + ':' + pair[1]);

//or
for (let [key, value] of ordinaryObject)
    console.log(key + ':' + value);

只要您包含下面我的 shim：

//makes all objects iterable just like Maps!!! YAY
//iterates over Object.keys() (which already ignores prototype chain for us)
Object.prototype[Symbol.iterator] = function() {
    var keys = Object.keys(this)[Symbol.iterator]();
    var obj = this;
    var output;
    return {next:function() {
        if (!(output = keys.next()).done)
            output.value = [output.value, obj[output.value]];
        return output;
    }};
};

不需要创建一个真正的 Map 对象，它没有良好的语法糖。

var trueMap = new Map([['well', 'hello'], ['there', '!']]);
for (let pair of trueMap)
    console.log(pair[0] + ':' + pair[1]);

事实上，使用这个shim后，如果你仍然想利用Map的其他功能（而不是将它们全部shim进去），同时还想使用漂亮的对象表示法，由于对象现在是可迭代的，所以你现在可以直接从中创建一个Map！

//shown in demo
var realMap = new Map({well:'hello', there:'!'});

//no prototype manipulation
function getObjIterator(obj) {
    //create a dummy object instead of adding functionality to all objects
    var iterator = new Object();

    //give it what the shim does but as its own local property
    iterator[Symbol.iterator] = function() {
        var keys = Object.keys(obj)[Symbol.iterator]();
        var output;

        return {next:function() {
            if (!(output = keys.next()).done)
                output.value = [output.value, obj[output.value]];
            return output;
        }};
    };

    return iterator;
}

现在，您可以将其视为普通函数进行调用，不会影响任何其他内容。

var realMap = new Map(getObjIterator({well:'hello', there:'!'}))

for (let pair of getObjIterator(ordinaryObject))

没有理由不能工作。

欢迎来到未来。

在 Object.keys() 上使用 for-of

例如：

let object = {
  "key1": "value1",
  "key2": "value2",
  "key3": "value3"
};

for (let key of Object.keys(object)) {
  console.log(key + " : " + object[key])
}

Object.keys(obj)：数组

检索所有可枚举的自有（非继承）属性中，值为字符串类型的键名。

所以它会提供与通过使用 hasOwnProperty 测试每个对象键相同的键列表。你不需要进行额外的测试操作，只需使用Object.keys( obj ).forEach(function( key ){})即可，而且它被认为更快。让我们来证明一下：

var uniqid = function(){
   var text = "",
     i = 0,
     possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
   for( ; i < 32; i++ ) {
     text += possible.charAt( Math.floor( Math.random() * possible.length ) );
   }
   return text;
  }, 
  CYCLES = 100000,
  obj = {}, 
  p1,
  p2,
  p3,
  key;

// Populate object with random properties
Array.apply( null, Array( CYCLES ) ).forEach(function(){
 obj[ uniqid() ] = new Date()
});

// Approach #1
p1 = performance.now();
Object.keys( obj ).forEach(function( key ){
 var waste = obj[ key ];
});

p2 = performance.now();
console.log( "Object.keys approach took " + (p2 - p1) + " milliseconds.");

// Approach #2
for( key in obj ) {
 if ( obj.hasOwnProperty( key ) ) {
  var waste = obj[ key ];
 }
}

p3 = performance.now();
console.log( "for...in/hasOwnProperty approach took " + (p3 - p2) + " milliseconds.");

在我的Firefox中，我得到了以下结果：

• 使用 Object.keys 方法的运行时间为40.21101451665163毫秒。
• 使用 for...in/hasOwnProperty 方法的运行时间为98.26163508463651毫秒。

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

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

let map = new Map().set('a', 1).set('b', 2);
for (let pair of map) {
    console.log(pair);
}

// OR 
let map = new Map([
    [false, 'no'],
    [true,  'yes'],
]);
map.forEach((value, key) => {
    console.log(key, value);
});

将您的对象传递给 Object.keys()。这将返回一个数组，其中包含对象中的所有键。然后，您可以使用 map 循环遍历该数组。在 map 迭代中，使用 obj[key] 其中 obj 是您的对象，key 是当前值，即可获取该键/属性的值。

const obj = { name: "Jane", age: 50 };

Object.keys(obj).map( key => {
    console.log(key, obj[key]);
});