JS对象常用基本操作

1. Object.is()；用于判断两个对象的值是否相等(比较的是对象的地址)，也可以比较别的类型的值。

let obj1 = {
    name: 'xiao',
    age: 18,
    gender: '女',
    interest: {
        morning: 'read',
        noon: 'rest',
        night: 'music'
    }
}
let obj = obj1;
let isEqual = Object.is({a: 1}, {a: 1});
let isEqual2 = Object.is(obj, obj1);
console.log("isEqual", isEqual, Object.is(10,10));  //false true
console.log("isEqual2", isEqual2);  //true

 2. Object.assign(目标对象, 源对象)；用于将所有可枚举的自身属性从一个或多个源对象复制到目标对象。返回值是修改后的目标对象，是一个深拷贝的对象。

let obj = {
    a: 1
};
let obj2 = Object.assign(obj, {a: 3, b: 2})
console.log("obj2", obj2, Object.is(obj, obj2))  //{a: 3, b: 2} true

3. Object.entries()；返回对象自身可枚举属性键值对的数组。

let obj = {
    a: 1
};
let obj2 = Object.assign(obj, {a: 3, b: 2})
console.log("assign", Object.entries(obj2)); //[["a", 3], ["b": 2]]
for(let [key, value] of Object.entries(obj2)){
    console.log(key, value)
    //a 3
    //b 2
}

4. Object.key()；返回给定对象自身可枚举属性名的数组。(遍历对象的方式之一)

let obj = {
    a: 1
};
let obj2 = Object.assign(obj, {a: 3, b: 2})
console.log("assign", Object.keys(obj2)); //['a', 'b']

5. Object.values()；返回给定对象自身可枚举属性值的数组。(遍历对象的方式之一)

let obj1 = {
    name: 'xiao',
    age: 18,
    gender: '女',
    interest: {
        morning: 'read',
        noon: 'rest',
        night: 'music'
    }
}
console.log("assign", Object.values(obj1));

6. Object.prototype.hasOwnProperty()；判断对象自身是否有某个属性，不会沿着原型链查找，对象自己没有，原型链上面有，也是返回false。（不会深度查找）

let obj1 = {
    name: 'xiao',
    age: 18,
    gender: '女',
    interest: {
        morning: 'read',
        noon: 'rest',
        night: 'music'
    }
}
console.log("assign", obj1.hasOwnProperty("name"), obj1.hasOwnProperty("morning"), obj1.hasOwnProperty("school"));
//true false false

7. ‘属性名’ in 对象名；判断对象上是否有某个属性，会沿着原型链查找。

let obj1 = {
    name: 'xiao',
    age: 18,
    gender: '女',
    interest: {
        morning: 'read',
        noon: 'rest',
        night: 'music'
    }
}
console.log("assign", 'toString' in obj1, 'school' in obj1, 'name' in obj1);
//true false true

8. 删除对象的属性 Delete；使用delete删除对象属性的三种方式如下。

let obj1 = {
    name: 'xiao',
    age: 18,
    gender: '女',
    interest: {
        morning: 'read',
        noon: 'rest',
        night: 'music'
    }
}
delete obj1.name;
// delete obj1['name'];
// let name = 'name';
// delete obj1[name]
console.log("obj1", obj1) //{age: 18, gender: '女',interest: {morning: 'read',noon: 'rest',night: 'music'}}

9. 创建对象的方式之一：Object.creat(proto, prop)，proto--必须，新创建对象的原型对象，prop--可选，设置属性及属性描述，默认值为undefined；  用于创建一个新对象，使用现有的对象来提供新创建对象的原型对象。用此方法创建对象，还涉及到对象的数据属性和访问器属性，不熟悉的读者请自行查阅相关资料。

let obj = {
    a: 1
};
let obj3 = Object.create(obj, {
    //aa和aaa是obj3的数据属性
    aa: {
        value: 'aa',
        writable: false,         //默认false  不可更改
        enumerable: false,       //默认false  不可枚举
        configurable: false      //默认false  不可配置
    }, 
    aaa: {value: 'aaa'},
    //b是对象的访问器属性
    b: {
        configurable: false,
        get: function(){
            return this.value ? this.value : 10;
        },
        set: function(value){
            this.value = this.b + value;
        }
    }
})  //创建一个原型是obj，且拥有aa属性的对象
console.log("obj3", obj3.__proto__ === obj, obj3.a, obj3.__proto__) // true  {a: 1}
console.log("b", obj3.b);  //10
obj3.b = 20;
console.log("b", obj3.b) //30
console.log("obj3 is", obj3)
let obj4 = Object.create(Object.prototype)  //等价于用字面量形式let obj4 = {}创建的对象

10. 创建对象的方式之二：new Object()

let obj4 = new Object();
obj4.name = 'xiao',
obj4['age'] = 18,
obj4.say = function() {
    console.log("hello")
}
console.log("obj4",obj4)

 11. 创建对象的方式之三：使用构造函数

function Dog(name, age, color){
    this.name = name;
    this.age = age;
    this.color = color;
}
let dog = new Dog('xiaohei', 3, 'black') //此处的dog即为对象，构造对象
console.log("dog", dog.name, dog.age)  //xiaohei 3

12. for ...in；任意顺序迭代一个对象的除Symbol以外的可枚举属性，包括继承的可枚举属性还会得到对象原型链上的属性。(遍历对象的方式之二 )

let obj3 = Object.create(obj, {
    //aa和aaa是obj3的数据属性，不能通过for in遍历到
    aa: {value: 'aa'}, 
    aaa: {value: 'aaa'},
    //b是对象的访问器属性
    b: {
        configurable: false,
        get: function(){
            return this.value ? this.value : 10;
        },
        set: function(value){
            this.value = this.b + value;
        }
    }
})  //创建一个原型是obj，且拥有aa、aaa属性的对象
obj3.aaaa = 'aaaa';
for(let key in obj3){
    console.log(obj3[key]); //aaaa a
}

13. Object.getOwnPropertyNames()；该方法返回对象自身属性名组成的数组，包括不可枚举的属性以及访问器属性，不包括Symbol属性。(遍历对象的方式之三 )

let obj3 = Object.create(obj, {
    //aa和aaa是obj3的数据属性，不能通过for in遍历到
    aa: {value: 'aa'}, 
    aaa: {value: 'aaa'},
    //b是对象的访问器属性
    b: {
        configurable: false,
        get: function(){
            return this.value ? this.value : 10;
        },
        set: function(value){
            this.value = this.b + value;
        }
    }
})  //创建一个原型是obj，且拥有aa、aaa属性的对象
obj3.aaaa = 'aaaa';
obj3[Symbol('aaaaa')] = 'aaaaa';  //给对象添加一个可枚举的Symbol值
Object.getOwnPropertyNames(obj3).forEach((key) => {
    console.log("Object.getOwnPropertyNames", obj3[key]) // aa aaa 10 aaaa
})

14. Reflect.ownKeys；该方法返回对象自身所有属性名组成的数组，包括不可枚举的属性和 Symbol 属性。

let obj3 = Object.create(obj, {
    //aa和aaa是obj3的数据属性，不能通过for in遍历到
    aa: {value: 'aa'}, 
    aaa: {value: 'aaa'},
    //b是对象的访问器属性
    b: {
        configurable: false,
        get: function(){
            return this.value ? this.value : 10;
        },
        set: function(value){
            this.value = this.b + value;
        }
    }
})  //创建一个原型是obj，且拥有aa、aaa属性的对象
obj3.aaaa = 'aaaa';
obj3[Symbol('aaaaa')] = 'aaaaa';  //给对象添加一个可枚举的Symbol值
Reflect.ownKeys(obj3).forEach((key) => {
    console.log("Reflect.ownKeys", obj3[key]) // aa aaa 10 aaaa aaaaa
})

15. 合并对象的方法：{...obj1, ...obj2}，Object.assign()；这两种方法都是第一级是深拷贝，第二级开始浅拷贝。 

16. 如何判断对象是否为空对象：Object.key(obj).length == 0。

后期还有对对象的相关操作还会继续补充。