对象常用的方法

思维导图

 

对象中常用的方法：  Object.prototype

1. hasOwnProperty 

• 方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）。 检测是否为私有属性
• 即使属性的值是 null 或 undefined，只要属性存在，hasOwnProperty 依旧会返回 true。检测的属性的 String 字符串形式表示的名称，或者 Symbol。

const object1 = {};
object1.property1 = 42;

console.log(object1.hasOwnProperty('property1'));
// expected output: true

console.log(object1.hasOwnProperty('toString'));
// expected output: false

console.log(object1.hasOwnProperty('hasOwnProperty'));
// expected output: false

2. toString

• 检测数据类型的  Object.prototype.toString.call([value])

var toString = Object.prototype.toString;

toString.call(new Date); // [object Date]
toString.call(new String); // [object String]
toString.call(Math); // [object Math]

不常用

•    + isPrototypeOf 方法用于测试一个对象是否存在于另一个对象的原型链上。
•     + valueOf方法返回指定对象的原始值。
•     + propertyIsEnumerable方法返回一个布尔值，表示指定的属性是否可枚举

  把Object作为一个普通对象，学习其静态私有属性方法  -> Object.xxx()

- **跟规则没关系的方法==3==个：**

  1. Object.assign(obj1,obj2,...)

合并两个(或多个)对象,让obj2及以后的对象替换obj1中的内容,返回obj1

    //Object.assign(obj1,obj2,...) 合并两个(或多个)对象,让obj2及以后的对象替换obj1中的内容,返回obj1
    const obj1 = { a: 1, b: 2 };
    const obj2 = { b: 4, c: 5 };

    const newObject = Object.assign(obj1, obj2);
    console.log(obj1);
    //{a: 1, b: 4, c: 5}
    console.log(newObject);
    //{a: 1, b: 4, c: 5}
    //newObject===obj1//true

2.Object.create(obj)

创建一个空对象，并且把obj作为其原型对象    返回值:一个新对象，带着指定的原型对象和属性。

   let obj = { name: "lisa" }
    let obj2 = Object.create(obj)
    console.log(obj2);
实现继承--------------------
 // Shape - 父类(superclass)
    function Shape() {
        this.x = 0;
        this.y = 0;
    }
    Shape.prototype.move = function (x, y) {
        this.x += x;
        this.y += y;
        console.info('Shape moved.');
    };

    // Rectangle - 子类(subclass)
    function Rectangle() {
        Shape.call(this); // call super constructor.
    }

    // 子类续承父类
    let son = Rectangle.prototype = Object.create(Shape.prototype);
    let son2 = Rectangle.prototype.constructor = Rectangle;
    console.log(son);
    console.log(son2);

3.Object.is(value1,value2)`

基于三个等于号，绝对相等进行比较的【ES6新增】        

  let obj = Object.is(NaN, NaN)
    console.log(obj);//true 这里可以判断一个值是不是NaN，做的也是全等比较

对象中属性操作的方法

1.`Object.defineProperty(obj,key,descriptor)`

:==对当前对象中的某个属性进行监听或劫持，以及设置一些规则==

    let obj = {
        name: 'lisa'
    };
    let proxy = { ...obj };
    Object.defineProperty(obj, 'name', {
        get() {
            // 当我们获取obj的name属性值的时候，会触发GETTER函数，方法返回的值就是获取的属性值
            console.log('GETTER');
            return proxy.name;
        },
        set(value) {
            // 当我们设置name属性值的时候，会触发SETTER函数，value是需要新设置的值
            console.log('SETTER', value);
            proxy.name = value;
        }
    });
    console.log(obj.name);
    obj.name = 'red';

• 2. `configurale:true`:是否可以基于delete删除name属性
• 3. `enumerable:true`:是否是可枚举的name属性，如果不可枚举，则for/in/Object.key()等操作无法遍历到该属性
• 4. ` writable:true`:是否可以修改值【只要设置了该描述，不管true或false，都不能使用get/set方法】
• 5.  `get(){return xxx}`:对获取obj.name属性操作进行拦截，return的值，就是真正获取到的值
• 6. set(value){xxx}`:对设置obj.name=value操作进行拦截，并执行函数体内的操作

• `7. Object.getOwnPropertyDescriptor(obj,key)`:获取obj中key属性所设置的规则的状态(可删除/枚举/修改..)

• 8.Object.getOwnPropertyDescriptors(obj)`:获取obj中每一个属性所设置的规则的状态

let obj = { name: 'lisa', age: 13 };
Object.defineProperty(obj, 'name', {
    // 是否可以基于delete删除
    configurable: false,
    // 是否是可以枚举的，如果是不可枚举的属性，则基于for/in循环或者Object.keys等操作都无法获取这个属性
    enumerable: false,
    // 是否可以修改值「不能和get/set同时设置」
    // writable: true,
    get() { },
    set() { }
}); 

获取当前对象不同类型的键或值==5==个：

1.`Object.getOwnPropertyNames(obj)`:获取当前对象所有非Symbol类型的私有属性【含不可枚举的】

    let obj = { name: 'xxx', age: 13, [Symbol('AA')]: 200 };
    Object.defineProperty(obj, 'name', { enumerable: false });
    let keys = Object.getOwnPropertyNames(obj);
    console.log(keys); //['name', 'age',] 

2.`Object.getOwnPropertySymbols(obj)`:获取当前对象所有**Symbol**类型的私有属性【含不可枚举的】

    let obj = { name: 'xxx', age: 13, [Symbol('AA')]: 200 };
    Object.defineProperty(obj, obj[Symbol('AA')], { enumerable: false });
    let keys = Object.getOwnPropertySymbols(obj);
    console.log(keys); //[Symbol(AA)

3.`Object.keys(obj)`:获取当前对象所有非Symbol类型且可枚举的私有属性名【不能获取不可枚举的】

    let obj = { name: 'xxx', age: 13, [Symbol('AA')]: 200 };
    Object.defineProperty(obj, "name", { enumerable: false });
    let keys = Object.keys(obj);
    console.log(keys); //['age']

4.Object.values(obj)`:获取当前对象所有非Symbol类型且可枚举的私有属性值

    let obj = { name: 'xxx', age: 13, [Symbol('AA')]: 200 };
    Object.defineProperty(obj, "name", { enumerable: false });
    let keys = Object.values(obj)
    console.log(keys); //['13']

5.  Reflect.ownKeys获取所有私有属性【包含各种类型及可枚举和不可枚举的】

    let obj = { name: 'xxx', age: 13, [Symbol('AA')]: 200 };
    Object.defineProperty(obj, "name", { enumerable: false });
    let keys =  Reflect.ownKeys(obj)
    console.log(keys); //['name', 'age', Symbol(AA)]

冻结：

• 不让其设置defineProperty劫持
• `Object.freeze(obj)`:冻结，把一个对象进行冻结，目的是让其不能在再基于Object.defineProperty做劫持，
• 后续可以基于`Object.isFrozen(obj):`检测对象是否是冻结的

   let obj = { name: 'lisa', age: 13 };
    Object.freeze(obj)
    Object.defineProperty(obj, 'name', {
        get() { },
        set() { }
    });
    //Uncaught TypeError: Cannot redefine property: name无法重新定义属性：name
    console.log(Object.isFrozen(obj));//true 检测对象是否是冻结的

设置和获取原型：

• -  Object.getPrototypeOf(obj)`:获取`obj.__proto__`指向的原型
•   - `Object.setPropertyOf(obj,property)`:设置obj原型对象`obj.__proto__===prototype`

 let obj = { name: 'lisa', age: 13 };
    let property = { name: 'red', age: 28 };
    Object.getPrototypeOf(obj)//constructor: ƒ Object()
    Object.setPrototypeOf(obj, property)//{name: 'lisa', age: 13}

 **阻止扩展*：不能再为其设置新的属性

•  - `Object.preventExtensions(obj)`:把obj变为不可扩展对象
•   - `Object.isExtensible(obj)`:判断一个对象是不是可扩展对象

let obj = { name: 'lisa', age: 13 };
    Object.preventExtensions(obj);
    obj.sex = "男"
    console.log(obj);//{name: 'lisa', age: 13,}
    console.log(Object.isExtensible(obj));//false不可扩展

**封存：**

• 不允许添加或删除对象中的属性,但允许修改对象中存在的属性
•   `Object.seal(obj)`:封存对象，不允许添加或删除对象中的属性,但允许修改对象中存在的属性
•   - `Object.isSealed(obj)`:判断一个对象是否封存了。

 let obj = { name: 'lisa', age: 13 };
    Object.seal(obj);
    obj.sex = "男";
    console.log(obj); //{ name: 'lisa', age: 13 }
    obj.age = 28;
    console.log(obj);//{name: 'lisa', age: 28}
    Object.isSealed(obj)//true 不允许添加或删除对象中的属性,但允许修改对象中存在的属性

- **对象的属性与二维数组互相转换：*

• `Object.entries(obj):`将对象中的每个==可枚举的==键值对转为数组，返回一个二维数组
•   - `Object.fromEntries(arr)`:将二维数组的各数据项，转换为对象，返回一个对象

 let obj = { name: 'lisa', age: 13 };
    let arr = Object.entries(obj)
    console.log(arr);//[Array(2) Array(2)]对象中的每个可枚举的键值对,转为数组返回一个二维数组