ES6 对象的新增方法

//Object.is()判断两值是否相等
let isFooEqual = Object.is('foo', 'foo');
console.log('foo'=='foo','foo'==='foo',isFooEqual);
let isObjectEqual = Object.is({}, {});
console.log({} == {}, {} === {}, isObjectEqual);
let isZeroEqual = Object.is(+0, -0);
console.log( +0 == -0, +0 === -0,isZeroEqual);
let isNaNEqual = Object.is(NaN, NaN);
console.log( NaN == NaN, NaN === NaN,isNaNEqual);

//ES5实现方法
Object.defineProperty(Object, 'is', {
    value: function (x, y) {
        if (x === y) {
            //针对+0不等于-0的情况
            return x !== 0 || 1 / x == 1 / y;
        }
        //针对NaN的情况
        return x !== x && y !== y;
    },
    configurable: true,
    enumerable: false,
    writable: true
});

//Object.assign();合并对象,只拷贝对象自身可枚举的属性
//如果不是对象会转为对象在返回
let assignNomalValue = Object.assign(2);
console.log(assignNomalValue)

const v1 = "abc";//字符串会产生枚举属性，所以这些属性能够被拷贝
const v2 = true;
const v3 = 10;
const objAssign = Object.assign({}, v1, v2, v3);
console.log(objAssign);//{ '0': 'a', '1': 'b', '2': 'c' }

//对于数组的处理
let numbers = Object.assign([1, 2, 3], [4, 5]);//将数组作为对象来处理
console.log(numbers);//[ 4, 5, 3 ]

//Object.getOwnPropertyDescriptors()
let ownPropertyDescriptors = Object.getOwnPropertyDescriptors(objAssign);

console.log(ownPropertyDescriptors);
/*{ '0':
   { value: 'a',
     writable: true,
     enumerable: true,
     configurable: true },
  '1':
   { value: 'b',
     writable: true,
     enumerable: true,
     configurable: true },
  '2':
   { value: 'c',
     writable: true,
     enumerable: true,
     configurable: true } }
*/
let ownPropertyDescriptor = Object.getOwnPropertyDescriptor(objAssign, '1');
console.log(ownPropertyDescriptor,ownPropertyDescriptor.prototype);
/*
* { value: 'b',
  writable: true,
  enumerable: true,
  configurable: true } undefined
*/

//Object.keys   Object.values   Object.entries
/*
* 不考虑Number Boolean Symbol类型的属性*/

let {keys, values, entries} = Object;
let objEntryObject = {a:1,b:2, c: 3}
for (let key of keys(objEntryObject)) {
    console.log(key);
}

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

for (let [key,value] of entries(objEntryObject)) {
    console.log([key,value]);
}
/**
 a
 b
 c
 1
 2
 3
 [ 'a', 1 ]
 [ 'b', 2 ]
 [ 'c', 3 ]
 */

// Object.fromEntres() 是Object.entries()的逆操作，用于将一个键值对数组转为对象
// 特别适合将Map结构转为对象
const entriesMap = new Map([
    ['foo', 'bar'],
    ['baz', 42]
]);
// let fromEntries = Object(entriesMap);
// console.log(fromEntries);

//对象不构成单独的作用域
const cat = {
    lives :0,
    jumps:()=>{
        this.lives--;
    }
}
console.log(cat.jumps());//undefined    此时的this指向全局作用域

let undefineIsVlaue = 0 in [undefined, undefined, undefined];
console.log(undefineIsVlaue);
let notExistIsVlaue = 0 in [, , ];
console.log(notExistIsVlaue);
let undefineArr = [undefined, undefined, undefined];
undefineArr.forEach(obj=>{
    console.log("undefineIsVlaue-forEach",obj);
})
undefineArr.map(obj=>{
    console.log("undefineIsVlaue-map",obj);
})
let notExistForEachArr = [,1,2];
let notExistMapArr = [,1,2];

notExistForEachArr.forEach(obj=>console.log(obj))
notExistMapArr.map(obj=>console.log(obj))
console.log(notExistForEachArr, notExistMapArr);
/*
* forEach，filter(),reduce,every(),some()      都会跳过空位
* map()                                        会跳过空位，但会保留这个值
* join()和toString()                           会将空位视为undefined，而undefined和null会被处理成空字符串*/