如何遍历或枚举JavaScript对象？

我有一个如下的JavaScript对象：

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

现在，我想遍历所有p元素（ p1 ， p2 ， p3 ...），并获取它们的键和值。我怎样才能做到这一点？

我可以根据需要修改JavaScript对象。我的最终目标是遍历一些键值对，如果可能的话，我想避免使用eval 。

#1楼

通过原型用foreach（），它应跳过原型链属性：

Object.prototype.each = function(f) {var obj = thisObject.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

#2楼

如果我们不提及循环对象的替代方法，那么这个问题将是不完整的。

如今，许多知名的JavaScript库都提供了自己的方法来遍历集合，即遍历数组，对象和类似数组的对象 。这些方法使用方便，并且与任何浏览器完全兼容。

如果使用jQuery ，则可以使用jQuery.each()方法。它可以用来无缝地遍历对象和数组：
```
 $.each(obj, function(key, value) { console.log(key, value); }); 
```
在Underscore.js你可以找到方法_.each()它遍历元素的列表，每个收益依次为提供的功能（要注意在iteratee函数参数的顺序！）：
```
 _.each(obj, function(value, key) { console.log(key, value); }); 
```
Lo-Dash提供了几种遍历对象属性的方法。基本的_.forEach() （或别名_.each() ）对于循环遍历对象和数组很有用，但是具有length属性的（！）对象被视为数组，并且为避免这种现象，建议使用_.forIn()和_.forOwn()方法（这些方法也首先使用value参数）：
```
 _.forIn(obj, function(value, key) { console.log(key, value); }); 
```
_.forIn()遍历对象的自身和继承的可枚举属性，而_.forOwn()仅遍历对象的自身属性（基本上检查hasOwnProperty函数）。对于简单的对象和对象文字，这些方法中的任何一种都可以正常工作。

通常，所有描述的方法对于任何提供的对象都具有相同的行为。除了使用native for..in循环通常比任何抽象方法jQuery.each()例如jQuery.each() 都快，这些方法更易于使用，需要更少的编码并提供更好的错误处理。

#3楼

在ECMAScript 5中，您可以在文字的迭代字段中使用新方法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的compat表上看到的浏览器支持

对于旧的浏览器，您可以使用简单而完整的 polyfill

UPD：

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

对象文字迭代

#4楼

仅JavaScript代码没有依赖项：

var p = {"p1": "value1", "p2": "value2", "p3": "value3"};
keys = Object.keys(p);   // ["p1", "p2", "p3"]for(i = 0; i < keys.length; i++){console.log(keys[i] + "=" + p[keys[i]]);   // p1=value1, p2=value2, p3=value3
}

#5楼

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); });

#6楼

我会这样做，而不是在每个for ... in循环中检查obj.hasOwnerProperty 。

var obj = {a : 1};
for(var key in obj){//obj.hasOwnProperty(key) is not needed.console.log(key);
}
//then check if anybody has messed the native object. Put this code at the end of the page.
for(var key in Object){throw new Error("Please don't extend the native object");
}

#7楼

如果还想遍历不可枚举的属性 ，则可以使用Object.getOwnPropertyNames(obj)返回直接在给定对象上找到的所有属性（无论是否可枚举）的数组。

 var obj = Object.create({}, { // non-enumerable property getFoo: { value: function() { return this.foo; }, enumerable: false } }); obj.foo = 1; // enumerable property Object.getOwnPropertyNames(obj).forEach(function (name) { document.write(name + ': ' + obj[name] + '<br/>'); });

#8楼

使用纯JavaScript时，循环可能非常有趣。似乎只有ECMA6（新的2015 JavaScript规范）可以控制循环。不幸的是，在我撰写本文时，浏览器和流行的集成开发环境（IDE）仍在努力完全支持新功能。

乍一看，这是ECMA6之前的JavaScript对象循环：

for (var key in object) {if (p.hasOwnProperty(key)) {var value = object[key];console.log(key); // This is the key;console.log(value); // This is the value;}
}

另外，我知道这个问题超出了范围，但是在2011年，ECMAScript 5.1仅为数组添加了forEach方法，该方法基本上创建了一种新的改进的方法来遍历数组，同时仍将旧的冗长且令人困惑的for循环留给不可迭代的对象。但是奇怪的是，这种新的forEach方法不支持break ，而break会导致各种其他问题。

基本上在2011年，除了许多流行的库（jQuery，Underscore等）决定重新实现之外，在JavaScript中没有真正可靠的循环方法。

截至2015年，我们现在有了更好的开箱即用的方式来循环（和中断）任何对象类型（包括数组和字符串）。当推荐成为主流时，JavaScript中的循环最终将是这样：

for (let [key, value] of Object.entries(object)) {console.log(key); // This is the key;console.log(value); // This is the value;
}

请注意，自2016年6月18日起，大多数浏览器将不支持上述代码。即使在Chrome中，您也需要启用此特殊标志才能使其正常工作： chrome://flags/#enable-javascript-harmony

在成为新标准之前，仍然可以使用旧方法，但是流行的库中还有其他选择，甚至对于那些不使用这些库的人来说，甚至还有轻量级的选择。

#9楼

有趣的是，这些答案中的人都涉及到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...in （无论是否检查.hasOwnProperty() ），因为这也有些混乱，因此，除了我上面的回答以外，我在这里说...}

您可以使普通对象关联迭代！ 就像Map一样，直接将for...of
可以在Chrome和FF中运行的DEMO （我仅假设使用ES6）

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

只要您在下面包含我的垫片：

//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]);

实际上，使用此填充程序，如果您仍然想利用Map的其他功能（而不是全部填充），但仍想使用整洁的对象表示法，因为对象现在是可迭代的，您现在可以从中制作Map！

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

对于那些不喜欢填充或一般不喜欢prototype的人，可以随意在window上创建函数，然后调用类似getObjIterator()的函数。

//no prototype manipulation
function getObjIterator(obj) {//create a dummy object instead of adding functionality to all objectsvar iterator = new Object();//give it what the shim does but as its own local propertyiterator[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))

没有理由不起作用。

欢迎来到未来。

#10楼

如果有人需要遍历带有条件的arrayObjects ：

 var arrayObjects = [{"building":"A", "status":"good"},{"building":"B","status":"horrible"}]; for (var i=0; i< arrayObjects.length; i++) { console.log(arrayObjects[i]); for(key in arrayObjects[i]) { if (key == "status" && arrayObjects[i][key] == "good") { console.log(key + "->" + arrayObjects[i][key]); }else{ console.log("nothing found"); } } }

#11楼

由于es2015越来越流行，因此我发布了此答案，其中包括使用generator和iterator来平滑地迭代[key, value]对。 Ruby等其他语言也有可能。

好的，这是一个代码：

const MyObject = {'a': 'Hello','b': 'it\'s','c': 'me','d': 'you','e': 'looking','f': 'for',[Symbol.iterator]: function* () {for (const i of Object.keys(this)) {yield [i, this[i]];}}
};for (const [k, v] of MyObject) {console.log(`Here is key ${k} and here is value ${v}`);
}

有关如何执行迭代器和生成器的所有信息，可以在开发人员Mozilla页面上找到。

希望它可以帮助某人。

编辑：

ES2017将包含Object.entries ，这将使对象中的[key, value]对迭代更加容易。现在已经知道，根据ts39阶段信息，它将成为标准的一部分。

我认为是时候更新我的答案，让它变得比现在更新鲜了。

const MyObject = {'a': 'Hello','b': 'it\'s','c': 'me','d': 'you','e': 'looking','f': 'for',
};for (const [k, v] of Object.entries(MyObject)) {console.log(`Here is key ${k} and here is value ${v}`);
}

您可以在MDN页面上找到有关用法的更多信息

#12楼

考虑到ES6，我想添加自己的糖勺，并提供另一种方法来迭代对象的属性。

由于普通的JS对象不是开箱即用的不可迭代的，因此我们无法使用for..of循环来对其内容进行迭代。但是没有人能阻止我们使其变得可迭代 。

让我们有book对象。

let book = {title: "Amazing book",author: "Me",pages: 3
}book[Symbol.iterator] = function(){let properties = Object.keys(this); // returns an array with property nameslet counter = 0;let isDone = false;let next = () => {if(counter >= properties.length){isDone = true;}return { done: isDone, value: this[properties[counter++]] }}return { next };
}

既然我们做到了，我们就可以这样使用它：

for(let pValue of book){console.log(pValue);
}
------------------------
Amazing book
Me
3

或者，如果您知道ES6 生成器的功能，那么您当然可以使上面的代码更短。

book[Symbol.iterator] = function *(){let properties = Object.keys(this);for (let p of properties){yield this[p];}}

当然，可以通过使Object在prototype级别可迭代来对所有对象应用这种行为。

Object.prototype[Symbol.iterator] = function() {...}

而且，符合迭代协议的对象可以与新的ES2015功能扩展运算符一起使用，因此我们可以将对象属性值读取为数组。

let pValues = [...book];
console.log(pValues);
-------------------------
["Amazing book", "Me", 3]

或者您可以使用解构分配：

let [title, , pages] = book; // notice that we can just skip unnecessary values
console.log(title);
console.log(pages);
------------------
Amazing book
3

您可以使用上面提供的所有代码签出JSFiddle 。

#13楼

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

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

这将产生与在es6循环中使用for ...相同的结果。

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

但是了解使用es6现在所具有的功能很重要！

#14楼

您可以向所有对象添加一个简单的forEach函数，以便可以自动循环遍历任何对象：

Object.defineProperty(Object.prototype, 'forEach', {value: function (func) {for (var key in this) {if (!this.hasOwnProperty(key)) {// skip loop if the property is from prototypecontinue;}var value = this[key];func(key, value);}},enumerable: false
});

对于那些不喜欢“ -... ”方法的人：

Object.defineProperty(Object.prototype, 'forEach', {value: function (func) {var arr = Object.keys(this);for (var i = 0; i < arr.length; i++) {var key = arr[i];func(key, this[key]);}},enumerable: false
});

现在，您可以简单地调用：

p.forEach (function(key, value){console.log ("Key: " + key);console.log ("Value: " + value);
});

如果您不想与其他forEach-Methods发生冲突，可以使用唯一的名称来命名。

#15楼

使用Angular时遇到类似的问题，这是我找到的解决方案。

步骤1.获取所有对象键。使用Object.keys。此方法返回给定对象自己的可枚举属性的数组。

步骤2.创建一个空数组。这是所有属性都将存在的地方，因为您的新ngFor循环将指向此数组，所以我们必须全部捕获它们。 步骤3.反复抛出所有键，并将每个键推入创建的数组中。这就是代码中的样子。

    // Evil response in a variable. Here are all my vehicles.
let evilResponse = { "car" : { "color" : "red","model" : "2013"},"motorcycle": { "color" : "red","model" : "2016"},"bicycle": { "color" : "red","model" : "2011"}
}
// Step 1. Get all the object keys.
let evilResponseProps = Object.keys(evilResponse);
// Step 2. Create an empty array.
let goodResponse = [];
// Step 3. Iterate throw all keys.
for (prop of evilResponseProps) { goodResponse.push(evilResponseProps[prop]);
}

这是原始帖子的链接。 https://medium.com/@papaponmx/looping-over-object-properties-with-ngfor-in-angular-869cd7b2ddcc

#16楼

Object.keys()方法返回给定对象自己的可枚举属性的数组。在这里了解更多

 var p = { "p1": "value1", "p2": "value2", "p3": "value3" }; Object.keys(p).map((key)=> console.log(key + "->" + p[key]))

#17楼

这是另一种遍历对象的方法。

  var p = { "p1": "value1", "p2": "value2", "p3": "value3" }; Object.keys(p).forEach(key => { console.log(key, p[key]) })

#18楼

  var p =[{"username":"ordermanageadmin","user_id":"2","resource_id":"Magento_Sales::actions"}, {"username":"ordermanageadmin_1","user_id":"3","resource_id":"Magento_Sales::actions"}] for(var value in p) { for (var key in value) { if (p.hasOwnProperty(key)) { console.log(key + " -> " + p[key]); } } }

#19楼

从ES06开始，您可以使用

let arrValues = Object.values( yourObject) ;

它返回对象值的数组，并且不从Prototype中提取值！

MDN DOCS Object.values（）

和钥匙（在这里我已经回答了）

let arrKeys   = Object.keys(yourObject);

#20楼

前言：

对象属性可以是自己的 （属性在对象本身上），也可以是继承的 （不在对象本身上，在其原型之一上）。
对象属性可以是可枚举的或不可枚举的 。不可枚举的属性被排除在许多属性枚举/数组之外。
属性名称可以是字符串或符号。名称为Symbol的属性被排除在许多属性枚举/数组之外。

在2018年，您可以使用以下选项遍历对象的属性（以下示例如下所示）：

for-in [ MDN ， spec ] —一个循环结构，循环遍历对象的可枚举属性的名称，包括名称为字符串的继承属性
Object.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 。原型链（此答案底部的示例）。

除for-in外，它们都for-in数组上使用某种循环构造（ for ， for-of ， forEach等）。

例子：

for-in ：

 // A prototype object to inherit from, with a string-named property const p = {answer: 42}; // The object we'll look at, which inherits from `p` const o = Object.create(p); // A string-named property o.question = "Life, the Universe, and Everything"; // A symbol-named property o[Symbol("author")] = "Douglas Adams"; for (const name in o) { const value = o[name]; console.log(`${name} = ${value}`); }

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

 // A prototype object to inherit from, with a string-named property const p = {answer: 42}; // The object we'll look at, which inherits from `p` const o = Object.create(p); // A string-named property o.question = "Life, the Universe, and Everything"; // A symbol-named property o[Symbol("author")] = "Douglas Adams"; for (const name of Object.keys(o)) { const value = o[name]; console.log(`${name} = ${value}`); }

Object.values ：

 // A prototype object to inherit from, with a string-named property const p = {answer: 42}; // The object we'll look at, which inherits from `p` const o = Object.create(p); // A string-named property o.question = "Life, the Universe, and Everything"; // A symbol-named property o[Symbol("author")] = "Douglas Adams"; for (const value of Object.values(o)) { console.log(`${value}`); }

Object.entries ：

 // A prototype object to inherit from, with a string-named property const p = {answer: 42}; // The object we'll look at, which inherits from `p` const o = Object.create(p); // A string-named property o.question = "Life, the Universe, and Everything"; // A symbol-named property o[Symbol("author")] = "Douglas Adams"; for (const [name, value] of Object.entries(o)) { console.log(`${name} = ${value}`); }

Object.getOwnPropertyNames ：

 // A prototype object to inherit from, with a string-named property const p = {answer: 42}; // The object we'll look at, which inherits from `p` const o = Object.create(p); // A string-named property o.question = "Life, the Universe, and Everything"; // A symbol-named property o[Symbol("author")] = "Douglas Adams"; for (const name of Object.getOwnPropertyNames(o)) { const value = o[name]; console.log(`${name} = ${value}`); }

Object.getOwnPropertySymbols ：

 // A prototype object to inherit from, with a string-named property const p = {answer: 42}; // The object we'll look at, which inherits from `p` const o = Object.create(p); // A string-named property o.question = "Life, the Universe, and Everything"; // A symbol-named property o[Symbol("author")] = "Douglas Adams"; for (const name of Object.getOwnPropertySymbols(o)) { const value = o[name]; console.log(`${String(name)} = ${value}`); }

Reflect.ownKeys ：

 // A prototype object to inherit from, with a string-named property const p = {answer: 42}; // The object we'll look at, which inherits from `p` const o = Object.create(p); // A string-named property o.question = "Life, the Universe, and Everything"; // A symbol-named property o[Symbol("author")] = "Douglas Adams"; for (const name of Reflect.ownKeys(o)) { const value = o[name]; console.log(`${String(name)} = ${value}`); }

所有属性 ，包括继承的不可枚举的属性：

 // A prototype object to inherit from, with a string-named property const p = {answer: 42}; // The object we'll look at, which inherits from `p` const o = Object.create(p); // A string-named property o.question = "Life, the Universe, and Everything"; // A symbol-named property o[Symbol("author")] = "Douglas Adams"; for (let depth = 0, current = o; current; ++depth, current = Object.getPrototypeOf(current)) { for (const name of Reflect.ownKeys(current)) { const value = o[name]; console.log(`[${depth}] ${String(name)} = ${String(value)}`); } }

 .as-console-wrapper { max-height: 100% !important; }

#21楼

在最新的ES脚本中，您可以执行以下操作：

Object.entries(p);

#22楼

Object.entries()函数：

 var p = { "p1": "value1", "p2": "value2", "p3": "value3" }; for (var i in Object.entries(p)){ var key = Object.entries(p)[i][0]; var value = Object.entries(p)[i][1]; console.log('key['+i+']='+key+' '+'value['+i+']='+value); }

#23楼

在ECMAScript 5下，您可以组合Object.keys()和Array.prototype.forEach() ：

var obj = { first: "John", last: "Doe" };Object.keys(obj).forEach(function(key) {console.log(key, obj[key]);
});

ECMAScript 6 for...of添加for...of ：

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)
);

您可以结合for...of ，destructuring和Object.entries ：

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

Object.keys()和Object.entries()以与for...in循环相同的顺序迭代属性， 但忽略原型链 。仅迭代对象自身的可枚举属性。

#24楼

您还可以使用Object.keys（）并遍历如下所示的对象键来获取值：

 var p = { "p1": "value1", "p2": "value2", "p3": "value3" }; Object.keys(p).forEach((key)=> { console.log(key +' -> '+ p[key]); });

#25楼

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

喜欢：

let object = {"key1": "value1""key2": "value2""key3": "value3"
};for (var key of Object.keys(p)) {console.log(key + " : " + object[key])
}

#26楼

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

注意：您可以在数组上执行此操作，但是也将遍历length和其他属性。

#27楼

您可以像这样遍历它：

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

请注意， key将不采用属性的值，而只是索引值。

#28楼

您可以使用for-in循环，如其他人所示。但是，您还必须确保获得的键是对象的实际属性，而不是来自原型。

这是代码段：

 var p = { "p1": "value1", "p2": "value2", "p3": "value3" }; for (var key in p) { if (p.hasOwnProperty(key)) { console.log(key + " -> " + p[key]); } }

用Object.keys（）替代：

 var p = { 0: "value1", "b": "value2", key: "value3" }; for (var key of Object.keys(p)) { console.log(key + " -> " + p[key]) }

请注意，使用for-of而不是for-in ，如果不使用它将在命名属性上返回undefined，并且Object.keys（）确保仅使用对象自己的属性，而不使用整个原型链属性

#29楼

您必须使用for-in循环

但是在使用这种循环时要非常小心，因为这会沿原型链循环所有属性 。

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

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

#30楼

在查看完所有答案之后，我自己的用法不需要hasOwnProperty，因为我的json对象是干净的；添加任何额外的javascript处理确实没有任何意义。这就是我正在使用的：

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

#31楼

 var p = { "p1": "value1", "p2": "value2", "p3": "value3" }; for (var key in p) { if (p.hasOwnProperty(key)) { console.log(key + " = " + p[key]); } }

 <p> Output:<br> p1 = values1<br> p2 = values2<br> p3 = values3 </p>