ES6中对象新增的方法

属性的简洁表示法

ES6 允许在大括号里面直接写入变量和函数，作为对象的属性和方法。这样的书写更加简洁。
const foo = 'bar';
const baz = {
    foo
};
console.log(baz); // { foo: 'bar' }

function f(name, age) {
  return {
      name,
      age
  };
}

// 等同于
// function f(name, age) {
//     return {
//         name: name,
//         age: age
//     };
// }

console.log('信息', f('李四', 23));
// 输出的信息是 {age: 23 name: "李四"}

let birth = '2022-3-27';
const Person = {
    name: '张三',
    //等同于birth: birth
    birth,
    // 等同于hello: function (){}
    hello() {
        console.log('我的名字叫:', this.name);
    }
};
// Person.hello(); // 我的名字叫:张三

//没有返回值时，默认返回 undefined。下面这一条语句会被执行两次
console.log('信息', Person.hello());
// 第1次的值： 我的名字叫:张三
// 第2次的值： undefined

注意，简写的对象方法不能用作构造函数，会报错。
let Person = {
  name: '张三',
  hello: function() {
    console.log('你好呀')
  },
  like() {
    console.log('简写的对象方法不能用作构造函数==>error会报错')
  }
};
new Person.hello() // 不会报错
new Person.like(); //会报错

ES6对象属性遍历的5种方式

ES6 一共有 5 种方法可以遍历对象的属性。
1==>for...in
for...in循环遍历对象自身的和继承的可枚举属性（不含 Symbol 属性）。

const obj = { h: 180,w: 125}
for (let keysName in obj) {
  console.log(keysName);
  // h w 输出的是key值哈
}


2==>Object.keys(obj)
Object.keys返回一个数组，
包括对象自身的（不含继承的）所有可枚举属性（不含 Symbol 属性）的键名。
const obj = {
    height: 180,
    weight: 125,
}
console.log(Object.keys(obj)) //['height', 'weight']


3==>Object.getOwnPropertyNames(obj) 【了解即可】
Object.getOwnPropertyNames返回一个数组，
包含对象自身【所有的属性】。[其自身的可枚举和不可枚举属性的名称被返回]
【不含 Symbol 属性】的键名。
let obj = {};
let a = Symbol("a");
let b = Symbol.for("b");
obj[a] = "localSymbol";
obj[b] = "globalSymbol";
let objectSymbols = Object.getOwnPropertySymbols(obj);
console.log(objectSymbols.length); // 2
console.log(objectSymbols) // [Symbol(a), Symbol(b)]
console.log(objectSymbols[0]) // Symbol(a)

4==>Object.getOwnPropertySymbols(obj)
Object.getOwnPropertySymbols返回一个数组，包含对象自身的所有 Symbol 属性的键名。


5==>Reflect.ownKeys(obj)
Reflect.ownKeys返回一个数组，包含对象自身的（不含继承的）所有键名。
不管键名是 Symbol 或字符串，也不管是否可枚举。
const obj = {
  height: 180,
  weight: 125,
}
console.log(Reflect.ownKeys(obj))
//['height', 'weight']

以上的 5 种方法遍历对象的键名，都遵守同样的属性遍历的次序规则。

JavaScript中的可枚举属性与不可枚举属性

在JavaScript中，对象的属性分为可枚举和不可枚举之分，
它们是由属性的 enumerable 值决定的。
可枚举性决定了这个属性能否被for…in查找遍历到。

属性的枚举性会影响以下三个函数的结果：
for…in
Object.keys()
JSON.stringify

Object.is()

ES5 比较两个值是否相等，只有两个运算符。
相等运算符（==）和严格相等运算符（===）。
它们都有缺点，前者会自动转换数据类型。
后者的NaN不等于自身，以及+0等于-0。
JavaScript 缺乏一种运算，只要两个值是一样的，它们就应该相等。
于是，ES6提出来了一种同值相等的算法，来解决这个问题。
console.log('==>', Object.is('bar', 'bar'))
// true
console.log(Object.is({}, {}))
// false

+0 === -0 //true
NaN === NaN // false

Object.is(+0, -0) // false
Object.is(NaN, NaN) // true

Object.assign对象合并

Object.assign()方法用于对象的合并。
将源对象（source）的所有可枚举属性，复制到目标对象（target。

const target = { a: 1 };
const source1 = { b: 2 };
const source2 = { c: 3 ,b:22};
Object.assign(target, source1, source2);
target // {a:1, b:22, c:3}

Object.assign需要注意的点

需要注意的点:Object.assign()方法的第一个参数是目标对象，后面的参数都是源对象。
由于undefined和null无法转成对象，所以如果它们作为参数，就会报错。
Object.assign(undefined) // 报错
Object.assign(null) // 报错

如果非对象参数出现在源对象的位置即非首参数，
那么处理规则有所不同。
首先，这些参数都会转成对象，如果无法转成对象，就会跳过。
这意味着，如果undefined和null不在首参数，就不会报错。
let obj = {a: 1};
Object.assign(obj, undefined) === obj // true
Object.assign(obj, null) === obj // true

特别注意：其他类型的值（即数值、布尔值）不在首参数，也不会报错。
但是，除了字符串会以数组形式，拷贝入目标对象。

-- 字符串会以数组形式拷贝入目标对象
const str1 = 'abc';
const obj = Object.assign({}, str1);
console.log(obj); // { "0": "a", "1": "b", "2": "c" }
为什么字符串会以数组形式拷贝进入目标对象呢？
这是因为:只有字符串的包装对象，会产生可枚举属性。

-- 数字不会拷入目标对象
const str2 = 123;
const obj = Object.assign({}, str2);
console.log(obj); // {}

-- 最后补充一点：
Object.assign()拷贝的属性是有限制的，
只拷贝源对象的自身属性（不拷贝继承属性），
也不拷贝不可枚举的属性（enumerable: false）。
Object.assign()方法实行的是浅拷贝，而不是深拷贝。