循环和迭代

如何遍历一个对象的所有属性

方法1 for in 循环对象的所有枚举属性,调用hasOwnProperty来忽略继承属性

let bus={
    name:"101"
}

for(var name in bus){
    if(bus.hasOwnProperty(name)){
        console.log('真正的属性',name)
    }else{
        console.log('继承的属性',name)     
    }
}

1 .for in :可枚举的实例属性,继承属性

方法2 Object.keys()

1 .可枚举的,实例属性,不含继承

方法3 lodash里面的forEach方法

image.png

1 .如果是对象,,他的所有值是通过Object.keys(Object(obj)).那感觉遍历对象的时候我们可以这样操作
2 .返回一个所有元素为字符串的数组，其元素来自于从给定的 object 上面可直接枚举的属性。这些属性的顺序与手动遍历该对象属性时的一致

方法4 Object.getOwnPropertyNames().这个其实不算

1 .返回一个数组,包含对象的所有实例属性名称,包括可枚举的和不可枚举的
2 .Object.getOwnPropertyNames(Math) 返回Math的所有属性

方法5 Reflect.ownKeys()

1 .

属性的总类-一个对象上面可能有这么多的属性

1 .自身可枚举的属性
2 .自身不可枚举的属性
3 .自身的symbol键
4 .继承的symbol键
5 .继承的可枚举属性
6 .继承的不可枚举属性

	in	for...in	Object.keys
自身可枚举	true	true	true
自身不可枚举	true	false	false
自身的symbol	true	false	false
继承的symbol	true	false	false
继承的可枚举	true	true	fasle
继承的不可枚举	true	false	fasle

总结1

1 .in可以遍历出全部的属性,强啊
2 .for ..in (自身可枚举和继承可枚举)
3 .Object.keys():只有自身可枚举

	hasOwnProperty	Reflect.OwnKeys()	Obj.getOwnPropertyNames
自身可枚举	true	true	true
自身不可枚举	true	true	true
自身的symbol	true	true	false
继承的symbol	false	false	false
继承的可枚举	false	false	fasle
继承的不可枚举	false	false	fasle

总结2

1 .hasOwnProperty自己的全都能看到,继承的全都看不到.注意他的关键词Own 和Reflect.Ownkeys()完全一致,Object.getOwnPropertyDescriptors 获取自己的全部属性.
2 .Obj.getOwnPropertyNames获取自己的,除了symbol
3 .Object.propertyIsEnumerable:只能获取自己除了可枚举的属性,也就是正常的和symbol

全部总结

1 .有own相关的,一律不能获取继承有关的
2 .那就是说,继承不继承的属性,其实只是和in for..in这俩有关系,其余剩下的都歇菜了

1 .in还是全部都可以
2 .for .. in 只能检查到继承的可枚举属性.

3 .也就是继承的不可枚举属性以及继承的Symbol无论怎么都看不到,上面所有的迭代方法.
4 .遍历对象所有的可枚举属性（自有的+继承的属性），使用 for...in
5 .遍历对象自有的所有可枚举属性（非继承属性），使用 Object.keys() 或 for...in + Objec.hasOwnProperty()
6 .获取对象所有继承属性（非自有属性），可以使用 for...in + Object.keys()
7 .遍历对象自有的所有可枚举和不可枚举属性（非继承属性），使用 Object.getOwnPropertyNames()
8 .获取对象自有的所有可枚举、不可枚举属性和继承属性，使用 for...in + Object.getOwnPropertyNames(obj) 或 for...in + Object.keys() + Object.getOwnPropertyNames(obj)
9 .Object.getOwnPropertySymbols() 返回自身所有symbol属性的数组

测试代码

 let parent={
            name:'parent'
            //继承可枚举
       }
       Object.defineProperty(parent, "age", {
        value: 1,
        enumerable:false
      });

       let parentSymbol=Symbol('parentSymbol')
       //继承symbol
       parent[parentSymbol]='parentSymbol'

       console.log(parent)
       //正常我们能看到的

       //先看能不能遍历出自己的三种类型的属性
       //in
       if('name' in parent && "age" in parent && parentSymbol in parent){
        //自身的全都可以看到
        //console.log('in is ok')
       }

       //for in 
       for(key in parent){
        //只能看到自身可枚举属性:name
       // console.log(key)
       }

       //Object.keys()
       //console.log(Object.keys(parent))
       //也是自身可枚举属性

       //hasOwnProperty
       if(parent.hasOwnProperty('name')&&parent.hasOwnProperty(parentSymbol)&&parent.hasOwnProperty('age')){
        console.log('hasoWnProperty is ok')
        //全都可以看到
       }
       
       //Reflect.OwnKeys()
       //console.log(Reflect.ownKeys(parent))

       //Object.getOwnPropertyNames()
       console.log(Object.getOwnPropertyNames(parent))