遍历对象属性

2020/09/15 04:31 · javascript ·  · 0评论
var obj = {
    name: "Simon",
    age: "20",
    clothing: {
        style: "simple",
        hipster: false
    }
}

for(var propt in obj){
    console.log(propt + ': ' + obj[propt]);
}

变量如何propt表示对象的属性?它不是内置方法或属性。为什么它包含对象中的每个属性?

遍历属性需要以下附加hasOwnProperty检查:

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

这是必要的,因为对象的原型包含该对象的其他属性,这些属性在技术上是对象的一部分。这些附加属性是从基础对象类继承的,但仍然是的属性obj

hasOwnProperty 只需检查一下这是否是该类的特定属性,而不是从基类继承的属性。


也可以hasOwnProperty通过对象本身进行调用

if (obj.hasOwnProperty(prop)) {
    // do stuff
}

但是,如果对象具有不相关的同名字段,则此操作将失败:

var obj = { foo: 42, hasOwnProperty: 'lol' };
obj.hasOwnProperty('foo');  // TypeError: hasOwnProperty is not a function

这就是为什么更安全地调用它的原因Object.prototype

var obj = { foo: 42, hasOwnProperty: 'lol' };
Object.prototype.hasOwnProperty.call(obj, 'foo');  // true

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

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(壁虎):4(2.0)
  • 铬:5
  • Internet Explorer:9

有关更多信息,请参见Mozilla开发人员网络Object.keys()的参考

我们现在处于2019年的男女生中,我们没有太多的时间来打字...所以,让我们来做一下这个酷炫的新奇ECMAScript 2016:

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

这是for...in statementMDNECMAScript spec)。

你可以把它读作“ FOR每个属性INobj对象,每个属性分配给PROPT依次变量”。

在最新的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 => ...)

这只是一个for...in循环。查看Mozilla上的文档

如果您的环境支持ES2017,那么我建议使用Object.entries

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

Mozillas Object.entries()文档所示:

所述Object.entries()方法返回在给定对象的自己的可枚举的属性[键,值]对的数组,在相同的顺序,通过提供一种用于... in循环(不同之处在于一个用于-in循环枚举原型链中的属性)。

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

// This step is not necessary with Object.entries
if (object.hasOwnProperty(property)) {
  // do stuff
}
if(Object.keys(obj).length) {
    Object.keys(obj).forEach(key => {
        console.log("\n" + key + ": " + obj[key]);
    });
}

// *** Explanation line by line ***

// Explaining the bellow line
// It checks if obj has at least one property. Here is how:
// Object.keys(obj) will return an array with all keys in obj.
// Keys are just the regular incremental numbers starting from 0.
// If there is no keys in obj, it will return empty array = []
// Then it will get its length. At this point, it checks: 
// If it has at least one element, it means it's bigger than 0 
// which evaluates to true and the bellow code will be executed.
// Else means it's length = 0 which evaluates to false
// NOTE: you can use Object.hasOwnProperty() instead of Object.keys(obj).length
if(Object.keys(obj).length) {

    // Explaining the bellow line
    // Just like in the previous line, this returns an array with
    // all keys in obj (because if code execution got here, it means 
    // obj has keys.) 
    // Then just invoke built-in javascript forEach() to loop
    // over each key in returned array and calls a call back function 
    // on each array element (key), using ES6 arrow function (=>)
    // Or you can just use a normal function ((key) { blah blah }).
    Object.keys(obj).forEach(key => {

        // The bellow line prints out all keys with their 
        // respective value in obj.
        // key comes from the returned array in Object.keys(obj)
        // obj[key] returns the value of key in obj
        console.log("\n" + key + ": " + obj[key]);
    });
}

jQuery允许您立即执行此操作:

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

Dominik的答案很完美,我只是喜欢这样做,因为它更容易阅读:

for (var property in object) {
    if (!object.hasOwnProperty(property)) continue;

    // Do stuff...
}

上面的答案有点烦人,因为在您确定它是一个对象之后,它们并没有解释您在for循环内所做的事情:您不会直接访问它!实际上,您仅交付了需要应用于OBJ的密钥:

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 [] since the key isn't literally named "someKey"

    // NOW you can treat it like an obj
    var shouldBeBar = myActualPropFromObj.b;
  }
}

这就是所有ECMA5安全。甚至可以在像Rhino这样the脚的JS版本中工作;)

添加ES2015的用法,Reflect.ownKeys(obj)并通过迭代器对属性进行迭代。

例如:

let obj = { a: 'Carrot', b: 'Potato', Car: { doors: 4 } };

可以被迭代

// logs each key
Reflect.ownKeys(obj).forEach(key => console.log(key));

如果您想直接在对象键的值上进行迭代,则可以定义一个iterator,就像JavaScipts的字符串,数组,类型数组,Map和Set的默认迭代器一样。

JS将尝试通过默认的迭代器属性进行迭代,该属性必须定义为Symbol.iterator

如果您希望能够遍历所有对象,则可以将其添加为Object的原型:

Object.prototype[Symbol.iterator] = function*() { 
    for(p of Reflect.ownKeys(this)){ yield this[p]; }
}

这将使您能够使用for ... of循环迭代对象的值,例如:

for(val of obj) { console.log('Value is:' + val ) }

注意:截至撰写此答案(2018年6月)时,所有其他浏览器均已启用,但IE支持for...of通过以下方式生成器和进行迭代Symbol.iterator

for ... in循环表示对象中的每个属性,因为它就像for循环一样。您通过执行以下操作在for ... in循环中定义了propt:

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

for ... in循环遍历对象的可枚举属性。定义的变量或放入for ... in循环的变量都会在每次访问下一个迭代的属性时更改。for ... in循环中的变量遍历键,但是它的值是键的值。例如:

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

您可以看到变量与变量值的不同之处。相反,for ... of循环则相反。

我希望这有帮助。

您可以使用Lodash。该文件

var obj = {a: 1, b: 2, c: 3};
_.keys(obj).forEach(function (key) {
    ...
});
Object.keys(obj).forEach(key =>
  console.log(`key=${key} value=${obj[key]}`)
);
let obj = {"a": 3, "b": 2, "6": "a"}

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

// a
// 3
// 2

您的for循环正在遍历对象的所有属性objpropt在for循环的第一行中定义。它是一个字符串,它是obj对象属性的名称在循环的第一次迭代中,propt将为“名称”。

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

您应该将其obj视为键值集合。

现在,您只需添加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);

如果运行节点,我建议:

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

虽然最受好评的答案是正确的,但这是一个替代用例,即如果您要遍历一个对象并想最后创建一个数组。使用.map代替forEach

const newObj = Object.keys(obj).map(el => {
    //ell will hold keys 
   // Getting the value of the keys should be as simple as obj[el]
})

还添加了递归方法:

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

for..in循环的作用是创建一个新变量(var someVariable),然后将给定对象的每个属性一一存储在该新变量(someVariable)中。因此,如果使用块{},则可以进行迭代。考虑以下示例。

var obj = {
     name:'raman',
     hobby:'coding',
     planet:'earth'
     };

for(var someVariable in obj) {
  //do nothing..
}

console.log(someVariable); // outputs planet

在这里,我迭代每个节点并创建有意义的节点名称。如果您注意到,instanceOf Array和instanceOf Object几乎可以做同样的事情(在我的应用程序中,我给出了不同的逻辑)

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的回答的启发。但是此解决方案具有更好的性能和较少的歧义

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

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

我想补充上面的答案,因为您可能与Javascript有不同的意图。JSON对象和Javascript对象是不同的事物,您可能想使用上面提出的解决方案遍历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]);
    }
}

遍历and 和of 的属性时0您可能会惊讶地看到控制台日志记录1这些对象是序列,序列的索引是Javascript中该对象的属性。prop1prop2prop3_1

递归遍历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]);

            }

     }
}

要进一步细化接受的答案值得一提的是,如果你实例化对象有var object = Object.create(null)那么object.hasOwnProperty(property)将触发类型错误。为了安全起见,您需要像这样从原型中调用它:

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

选中此链接将对https://www.w3schools.com/jsref/tryit.asp?filename=tryjsref_state_forin有帮助

var person = {fname:"John", lname:"Doe", age:25}; 

  var text = "";
  var x;
  for (x in person) {
    text += person[x] + " "; // where x will be fname,lname,age
   }
Console.log(text);

检查类型

您可以通过以下方式检查propt如何表示对象属性

typeof propt

发现它只是一个字符串(属性名称)。由于for-injs“内置”循环的工作方式,它提供了对象中的每个属性

本文地址:http://javascript.askforanswer.com/bianliduixiangshuxing.html
文章标签: ,   ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!