趁着有时间，整理一下Object常用的一些方法，加深记忆~~

entries

将对象转成键值对数组

Object.prototype.my_entries = function(obj){
    const res = [];
    for(let key in obj){
        console.log(key,  obj[key]);
        if(obj.hasOwnProperty(key)){
            //key本身还包含了原型上的方法，所以要过滤掉
            res.push([key, obj[key]]);
        }
    }
    return res;
}

fromEntries

跟entries相反，将键值对数组转成对象

Object.prototype.my_fromEntries = function(arr=[]){
    const res = {};
    for(let i = 0; i < arr.length; i++){
        const [key, value] = arr[i];
        res[key] = value;
    }
    return res;
}

keys

将对象的key转成一个数组合集

Object.prototype.my_keys = function(obj){
    const res = [];
    for(let key in obj){
        console.log(key);
        if(obj.hasOwnProperty(key)){
            //key本身还包含了原型上的方法，所以要过滤掉
            res.push(key);
        }
    }
    return res;
}

values

将对象的value转成一个数组合集

Object.prototype.my_values = function(obj){
    const res = [];
    for(let key in obj){
        console.log(key);
        if(obj.hasOwnProperty(key)){
            //key本身还包含了原型上的方法，所以要过滤掉
            res.push(obj[key]);
        }
    }
    return res;
}

assign

对象拷贝,接收多个对象，并将多个对象合成一个对象,
如果有重名属性，以后来的对象属性值为准

Object.prototype.my_assign = function(target, ...args){
    if(target === null || target === undefined){
        throw new Error('cannot canvert to Object');
    }
    target = Object(target);
    for(let nextObj in args){
        for(let key in nextObj){
            if(nextObj.hasOwnProperty(key)){
                target[key] = nextObj[key];
            }
        }
    }
    return target;
}

instanceOf

A instanceOf B，判断A是否是B的原型

Object.prototype.my_instanceOf = function(parent, child){
    const fp = parent.prototype;
    let cp = child.__proto__;
    while(cp){
        if(cp === fp){
            return true;
        }
        cp = cp.__proto__;//顺着原型链往上找
    }
    return false;
}

Object.is(x, y)

判断x是否等于y

Object.prototype.my_is = function (x, y) {
    if (x === y) {
        // 排除 -0 和 +0
        return x !== 0 || 1 / x === 1 / y
    }
    // 排除NaN
    return x !== x && y !== y
}