ES6中對象新增方法

1.object.is()判斷兩個值是否相等

  <script type="text/javascript">
            
        var flag1 = Object.is('foo', 'foo');
        console.log(flag1);//true
        
        var flag2 = Object.is('', '');
        console.log(flag2);//true


        var flag3 = Object.is({}, {});
        console.log(flag3);//false


        var flag4 = Object.is(0, -0);
        console.log(flag4);//false
        
        var flag5 = Object.is(NaN, NaN);//true
        console.log(flag5)
  </script>

2.Object.assign() 方法用於對象的合並，將源對象（source）的所有可枚舉屬性，復制到目標對象（target）。

Object.assign方法的第一個參數是目標對象，后面的參數都是源對象。

注意，如果目標對象與源對象有同名屬性，或多個源對象有同名屬性，則后面的屬性會覆蓋前面的屬性。

<script type="text/javascript">
            /*
             * object.asign() 
             */
            var target = {name:"小米"};
            var source1 = {
                age: 23,
                sex: 1,
                name: "xiaoming"
            };
            var source2 = {father:"大明"};
            
            console.log(Object.assign(target, source1, source2));//{name: "xiaoming", age: 23, sex: 1, father: "大明"} 
</script>

3.Object.keys()，Object.values()，Object.entries()

Object.keys方法，返回一個數組，成員是參數對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵名。

var obj = { foo: 'bar', baz: 42 };
Object.keys(obj)
// ["foo", "baz"]

ES2017 引入了跟Object.keys配套的Object.values和Object.entries，作為遍歷一個對象的補充手段，供for...of循環使用。

let {keys, values, entries} = Object;
let obj = { a: 1, b: 2, c: 3 };

for (let key of keys(obj)) {
  console.log(key); // 'a', 'b', 'c'
}

for (let value of values(obj)) {
  console.log(value); // 1, 2, 3
}

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

Object.values方法返回一個數組，成員是參數對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵值。

const obj = { foo: 'bar', baz: 42 };
Object.values(obj)
// ["bar", 42]

返回數組的成員順序，與本章的《屬性的遍歷》部分介紹的排列規則一致。

const obj = { 100: 'a', 2: 'b', 7: 'c' };
Object.values(obj)
// ["b", "c", "a"]

上面代碼中，屬性名為數值的屬性，是按照數值大小，從小到大遍歷的，因此返回的順序是b、c、a。

Object.values只返回對象自身的可遍歷屬性。

 

如果Object.values方法的參數是一個字符串，會返回各個字符組成的一個數組

Object.values('foo')
// ['f', 'o', 'o']

如果參數不是對象，Object.values會先將其轉為對象。由於數值和布爾值的包裝對象，都不會為實例添加非繼承的屬性。所以，Object.values會返回空數組。

Object.values(42) // []
Object.values(true) // []

 

Object.entries()方法返回一個數組，成員是參數對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵值對數組。

const obj = { foo: 'bar', baz: 42 };
Object.entries(obj)
// [ ["foo", "bar"], ["baz", 42] ]

 

Object.entries的基本用途是遍歷對象的屬性。

let obj = { one: 1, two: 2 };
for (let [k, v] of Object.entries(obj)) {
  console.log(
    `${JSON.stringify(k)}: ${JSON.stringify(v)}`
  );
}
// "one": 1
// "two": 2

Object.entries方法的另一個用處是，將對象轉為真正的Map結構。

const obj = { foo: 'bar', baz: 42 };
const map = new Map(Object.entries(obj));
map // Map { foo: "bar", baz: 42 }

Object.fromEntries()方法是Object.entries()的逆操作，用於將一個鍵值對數組轉為對象。

Object.fromEntries([
  ['foo', 'bar'],
  ['baz', 42]
])
// { foo: "bar", baz: 42 }

// 例一
const entries = new Map([
  ['foo', 'bar'],
  ['baz', 42]
]);

Object.fromEntries(entries)
// { foo: "bar", baz: 42 }

// 例二
const map = new Map().set('foo', true).set('bar', false);
Object.fromEntries(map)
// { foo: true, bar: false }