Object 对象与方法

JavaScript 对象是键值对的容器
键值对通常写法为 name : value (键与值以冒号分割)。
键值对在 JavaScript 对象通常称为 对象属性。

1. 访问对象属性
   两种方式: obj.property 或 obj [“property”]
2. 访问对象方法
   obj.property()
3. 对象object循环遍历

.each()可以遍历数组和对象

 $.each(obj,function(key,value){
   console.log("键："+key+";"+"键值："+obj[key]);
})

for…in，for…of

for(key in obj){
    console.log("姓名："+key+";"+"对应值："+obj[key]);
             }
for(val of arr){ //类似数组对象
    console.log("对应值："+val );
 }

for…of
ES6 方法。for…of 循环可以遍历数组、Set 和 Map 结构、某些类似数组的对象（比如 arguments 对象、DOM NodeList 对象）、Generator 对象，以及字符串。

object返回迭代器的方法

entries() values() keys()
Object.keys(obj)返回数组，内容是可直接枚举的属性

for(let key of Object.keys(obj)){
    console.log(key,obj[key]);
}

Object.values()返回一个数组，内容自身的（不含继承的）所有可遍历属性的键值 ES6方法。

for(let value of Object.values(obj)){
    console.log(value);
}

Object.entries() 返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历属性的键值对数组 ES6方法。

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

Reflect.ownKeys()返回一个数组，包含对象自身的所有属性，不管属性名是 Symbol 还是字符串，也不管是否可枚举。ES6方法。

for(let key of Reflect.ownKeys(obj)){
    console.log(key,obj[key]);
}

对象转换数组

扩展运算符（…）

扩展运算符（…）也可以将某些数据结构转为数组
arguments对象的转换

 function foo() {
            var args = [...arguments];
        }

NodeList对象的转换

[...document.querySelectorAll('p')]

ES6

• Array.prototype.slice.call(obj)
  借用了数组原型中的slice方法，返回一个数组。slice方法的内部实现：

Array.prototype.slice = function (start, end) {
            let result = new Array();
            start = start || 0;
            end = end || this.length;  //使用call之后this指向了类数组对象 
            for (let i = start; i < end; i++) {
                result.push(this[i]);
            }
            return result;
        }

通用的转换函数

 var toArray = function (Ob) {
            try {
                return Array.prototype.slice.call(Ob);
            } catch (e) {
                var arr = [];
                for (var i = 0, len = s.length; i < len; i++) {
                    arr[i] = s[i];
                }
                return arr;
            }
        }
        let object1 = {
            '0': 3,
            '1': 13,
            '2': 23,
            '3': 33,
            'length': 5,
            'name': 330
        }
        console.log(toArray(object1) + '      ' + 'Array.prototype.slice.call(obj)');

• Array.from()
  将两类对象转为真正的数组：类数组对象和可遍历（iterable）对象（包括ES6新增的数据结构Set和Map）

 let object3 = {
            '0': 3,
            '1': 13,
            '2': 23,
            '3': 33,
        };
 
        function* createIterator(obj) {
            for (let value in obj) {
                yield obj[value];
            };
        };
 
        let iterator = createIterator(object3);  //
        console.log(iterator);
        let arr3 = Array.from(iterator);
        console.log(Array.from(object3))// [3, 13, 23, 33]
 
        // 默认情况下，开发者定义的对象都是不可迭代对象，但如果给 Symbol.iterator 属性添加一个生成器，则可以将其变为可迭代对象
        obj[Symbol.iterator] = function* () {
            for (let value in this) {
                yield this[value]
            }
        }
        let arr = Array.from(obj)
        // [3, 13, 23, 33]
 
        // 判断对象是否为可迭代对象的方法
        typeof obj[Symbol.iterator] === 'function'
        //把NodeList对象转换为数组，然后使用数组的forEach方法
        let ps = document.querySelectorAll('p');
        Array.from(ps).forEach(p => {
            console.log(p);
        });
        //只要是部署了Iterator接口的数据结构，Array.from都能将其转换为数组
        Array.from('zjl');