遍历对象属性

var obj = { name: "Simon", age: "20", clothing: { style: "simple", hipster: false } } for(var propt in obj){ alert(propt + ': ' + obj[propt]); } 

variablespropt如何表示对象的属性？ 这不是一个内置的方法或属性。 那么为什么它会提出对象中的每个属性？

Answer 1

迭代属性需要额外的hasOwnProperty检查：

 for (var property in object) { if (object.hasOwnProperty(property)) { // do stuff } } 

这是必要的，因为对象的原型包含对象的附加属性，这在技术上是对象的一部分。 这些附加属性是从基础对象类inheritance的，但仍然是object属性。

hasOwnProperty只是简单地检查这是否是这个类的特定属性，而不是从基类inheritance的属性。

Answer 2

从JavaScript 1.8.5开始，您可以使用Object.keys(obj)来获取在对象本身上定义的一组属性（对obj.hasOwnProperty(key)返回true）。

 Object.keys(obj).forEach(function(key,index) { // key: the name of the object key // index: the ordinal position of the key within the object }); 

这比使用for-in循环更好（和可读）。

它支持这些浏览器：

• Firefox（Gecko）：4（2.0）
• Chrome：5
• Internet Explorer：9

查看Mozilla开发者networkingObject.keys（）的更多信息。

Answer 3

这是在for...in statement （ MDN ， ECMAScript规范 ）。

您可以将其读为“对于obj对象中的每个属性，将每个属性依次分配给PROPTvariables”。

Answer 4

我们在2017年的女孩和家伙，我们没有那么多时间打字…所以让我们来做这个很酷的新花式ECMAScript 2016：

 Object.keys(obj).map(e => console.log(`key=${e} value=${obj[e]}`)); 

Answer 5

这只是一个循环。 在Mozilla上查看文档 。

Answer 6

在即将到来的ES版本中，您可以使用Object.entries ：

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

要么

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

如果你只是想遍历这些值，那么使用Object.values：

 for (const value of Object.values(obj)) { } 

要么

 Object.values(obj).forEach(value => ...) 

Answer 7

 for (property in object) { ... } 

Answer 8

jQuery允许你现在这样做：

 $.each( obj, function( key, value ) { alert( key + ": " + value ); }); 

Answer 9

 let obj = {"a": 3, "b": 2, "6": "a"} Object.keys(obj).map((item) => {console.log("item", obj[item])}) // a // 3 // 2 

Answer 10

你可以使用Lodash。 文档

 var obj = {a: 1, b: 2, c: 3}; _.keys(obj).forEach(function (key) { ... }); 

Answer 11

JavaScript中的对象是属性的集合，因此可以在每个语句中循环使用。

你应该把obj看作一个关键的价值集合。

Answer 12

现在，只需添加一个Symbol.iterator方法，就可以将标准JS对象转换为可迭代对象。 然后你可以直接使用for of循环并直接赋值，甚至可以在对象上使用扩展运算符。 凉。 让我们看看我们如何做到这一点：

 var o = {a:1,b:2,c:3}, a = []; o[Symbol.iterator] = function*(){ var ok = Object.keys(this); i = 0; while (i < ok.length) yield this[ok[i++]]; }; for (var value of o) console.log(value); // or you can even do like a = [...o]; console.log(a); 

Answer 13

您的for循环遍历对象obj所有属性。 propt在for循环的第一行定义。 它是一个string，是obj对象的属性的名称。 在循环的第一个迭代中， propt将是“名称”。

Answer 14

for … in循环表示对象中的每个属性，因为它就像for循环一样。 你在for循环中定义了propt：

  for(var propt in obj){ alert(propt + ': ' + obj[propt]); } 

一个for … in循环遍历一个对象的枚举属性。 无论你定义了哪个variables，或者放入for … in循环，每当它转到下一个迭代的属性时都会改变。 for … in循环中的variables遍历键，但其值是键的值。 例如：

  for(var propt in obj) { console.log(propt);//logs name console.log(obj[propt]);//logs "Simon" } 

你可以看到variables和variables的值有什么不同。 相反，一个for …的循环则相反。

我希望这有帮助。

Answer 15

还join了recursion的方式：

 function iterate(obj) { // watch for objects we've already iterated so we won't end in endless cycle // for cases like var foo = {}; foo.bar = foo; iterate(foo); var walked = []; var stack = [{obj: obj, stack: ''}]; while(stack.length > 0) { var item = stack.pop(); var obj = item.obj; for (var property in obj) { if (obj.hasOwnProperty(property)) { if (typeof obj[property] == "object") { // check if we haven't iterated through the reference yet var alreadyFound = false; for(var i = 0; i < walked.length; i++) { if (walked[i] === obj[property]) { alreadyFound = true; break; } } // new object reference if (!alreadyFound) { walked.push(obj[property]); stack.push({obj: obj[property], stack: item.stack + '.' + property}); } } else { console.log(item.stack + '.' + property + "=" + obj[property]); } } } } } 

用法：

 iterate({ foo: "foo", bar: { foo: "foo"} }); 

Answer 16

如果你的环境支持ES2017，那么我会推荐Object.entry ：

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

如Mozilla的Object.entries（）文档所示：

Object.entries（）方法以与for … in循环提供的顺序相同的顺序返回给定对象自己的可枚举属性[key，value]对的数组（不同之处在于for-in循环枚举原型链中的属性也是如此）。

基本上使用Object.entries，我们可以放弃以前for … in循环所需的以下额外步骤：

 // This step is not necessary with Object.entries if (object.hasOwnProperty(property)) { // do stuff } 

Answer 17

我想添加上面的答案，因为你可能有不同的意图从Javascript。 一个JSON对象和一个Javascript对象是不同的东西，你可能想要使用上面提出的解决scheme遍历JSON对象的属性，然后感到惊讶。

假设你有一个JSON对象：

 var example = { "prop1": "value1", "prop2": [ "value2_0", value2_1"], "prop3": { "prop3_1": "value3_1" } } 

迭代其“属性”的错误方法：

 function recursivelyIterateProperties(jsonObject) { for (var prop in Object.keys(example)) { console.log(prop); recursivelyIterateProperties(jsonObject[prop]); } } 

在遍历prop1和prop2和prop3_1的属性时，您可能会看到控制台日志logging为0等。 这些对象是序列，序列的索引是Javascript中该对象的属性。

recursion迭代JSON对象属性的更好方法是首先检查该对象是否是序列：

 function recursivelyIterateProperties(jsonObject) { for (var prop in Object.keys(example)) { console.log(prop); if (!(typeof(jsonObject[prop]) === 'string') && !(jsonObject[prop] instanceof Array)) { recursivelyIterateProperties(jsonObject[prop]); } } } 

Answer 18

在这里我迭代每个节点并创build有意义的节点名称。 如果你注意到，instanceOf数组和instanceOf对象几乎是做同样的事情（在我的应用程序，我给不同的逻辑，虽然）

 function iterate(obj,parent_node) { parent_node = parent_node || ''; for (var property in obj) { if (obj.hasOwnProperty(property)) { var node = parent_node + "/" + property; if(obj[property] instanceof Array) { //console.log('array: ' + node + ":" + obj[property]); iterate(obj[property],node) } else if(obj[property] instanceof Object){ //console.log('Object: ' + node + ":" + obj[property]); iterate(obj[property],node) } else { console.log(node + ":" + obj[property]); } } } } 

请注意 – 我受到了Ondrej Svejdar的回答的启发。 但是这个解决scheme有更好的性能和更less的含糊

Answer 19

你基本上想要遍历对象中的每个属性。

的jsfiddle

 var Dictionary = { If: { you: { can: '', make: '' }, sense: '' }, of: { the: { sentence: { it: '', worked: '' } } } }; function Iterate(obj) { for (prop in obj) { if (obj.hasOwnProperty(prop) && isNaN(prop)) { console.log(prop + ': ' + obj[prop]); Iterate(obj[prop]); } } } Iterate(Dictionary); 

Answer 20

如果运行节点，我会build议：

 Object.keys(obj).forEach((key, index) => { console.log(key); }); 

Answer 21

为了进一步细化被接受的答案，值得注意的是，如果你用var object = Object.create(null)实例化对象，那么object.hasOwnProperty(property)将触发TypeError。 所以为了安全起见，你需要从原型中调用它：

 for (var property in object) { if (Object.prototype.hasOwnProperty.call(object, property)) { // do stuff } } 

Answer 22

上面的答案有点烦人，因为在你确定它是一个对象之后，他们没有解释你在for循环中做了什么：你不直接访问它！ 您实际上只交付了您需要应用于OBJ的KEY：

 var obj = { a: "foo", b: "bar", c: "foobar" }; // We need to iterate the string keys (not the objects) for(var someKey in obj) { // We check if this key exists in the obj if (obj.hasOwnProperty(someKey)) { // someKey is only the KEY (string)! Use it to get the obj: var myActualPropFromObj = obj[someKey]; // Since dynamic, use [] // NOW you can treat it like an obj var shouldBeFoo = myActualPropFromObj.b; } } 

这是所有ECMA5安全。 甚至可以在Rhino等蹩脚的JS版本中使用。

Answer 23

什么for..in循环确实是它创build一个新variables（var someVariable），然后将给定对象的每个属性一个接一个地存储在这个新variables（someVariable）中。 因此如果你使用block {}，你可以迭代。 考虑下面的例子。

 var obj = { name:'raman', hobby:'coding', planet:'earth' }; for(var someVariable in obj) { //do nothing.. } console.log(someVariable); // outputs planet