es6标准入门教程学习（三）

9.对象的拓展

1.

const cart = {
  _wheels: 4,
  get wheels () {
    return this._wheels;
  },
  set wheels (value) {
    if (value < this._wheels) {
      throw new Error('数值太小了！');
    }
    this._wheels = value;
  }
}

2.

const obj = {
  get foo() {},
  set foo(x) {}
};
obj.foo.name
// TypeError: Cannot read property 'name' of undefined
const descriptor = Object.getOwnPropertyDescriptor(obj, 'foo');
descriptor.get.name // "get foo"
descriptor.set.name // "set foo"

bind方法创造的函数，name属性返回bound加上原函数的名字；Function构造函数创造的函数，name属性返回anonymous

const key1 = Symbol('description');
const key2 = Symbol();
let obj = {
  [key1]() {},
  [key2]() {},
};
obj[key1].name // "[description]"
obj[key2].name // ""

如果对象的方法是一个Symbol值，那么name属性返回的是这个Symbol值的描述

3.属性的可枚举和遍历

let obj = { foo: 123 };
Object.getOwnPropertyDescriptor(obj, 'foo')
//  {
//    value: 123,    
//    writable: true,
//    enumerable: true,
//    configurable: true   change
//  }

enumerable '可枚举' false  表示某些操作会忽略当前属性

四个操作会忽略enumerable 为false的属性

for..in	之便利对象自身和继承的可枚举的属性
Object.keys()	返回对象自身所有可枚举属性的键名，忽略继承属性
JSON.stringify()	只川航话对象自身可枚举的属性，忽略继承属性
Object.assign()	忽略 enumerable 为false的属性，只拷贝对象自身的可枚举的属性，忽略继承属性

es6规定，所有Class的原型方法都是不可枚举的

属性的遍历

for...in	循环遍历自身和继承的属性（不含Symbol属性）
Object.key(obj)	返回一个数组，包括自身的所有可枚举属性
Object.getOwnPropertyNames(obj)	返回一个数组，包含自身的所有属性（不包括Symbol）但包括不可枚举属性
Object.getOwnPropertySymbols(obj)	返回一个数组，包换所有Symbol属性键名
Reflect.ownKey()	返回一个数组，包换对象本身的所有键名（Symbol+不可枚举）

遍历的规则

1. 遍历所有数值键，按照数值升序排列
2. 遍历所有字符串键，按照加入时间升序排列
3. 遍历所有Symbol键，按照加入时间升序排列

4.super关键字

this指向当前对象，super指向原型对象

super关键字表示原型对象时，只能用在对象的方法之中（js引擎中，super.foo等同于Object.getPropertyOf(this).foo或Object.getPropertyOf(this).foo.call(this)

5.对象的扩展运算符

let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
x // 1
y // 2
z // { a: 3, b: 4 }

解构赋值必须是最后一个参数（出现第二次，解构赋值出现第八百次，解构赋值的拷贝是浅拷贝）

const o = Object.create({ x: 1, y: 2 });
o.z = 3;
let { x, ...newObj } = o;//浅拷贝，只能赋值自身属性
let { y, z } = newObj;
x // 1
y // undefined
z // 3

扩展运算符后面是一个字符串=》类数组对象

let aClone = { ...a };
// 等同于
let aClone = Object.assign({}, a);

对象扩展运算，相当于Object.assign()

完整拷贝

// 写法一
const clone1 = {
  __proto__: Object.getPrototypeOf(obj),
  ...obj
};
// 写法二
const clone2 = Object.assign(
  Object.create(Object.getPrototypeOf(obj)),
  obj
);
// 写法三
const clone3 = Object.create(
  Object.getPrototypeOf(obj),
  Object.getOwnPropertyDescriptors(obj)
)

拓展运算符可以合并两个对象

var a={...A,...B}
var a=Object.assign({},A,B)

6.链判断运算符?：

7.x=true||5

10.对象的新增方法

Object.is()	判断相等 +0 ！= -0 NaN == NaN
Object.assign()	对象合并 浅拷贝 同名属性替换 数组覆盖
Object.getOwnPropertyDescriptors()	返回所有对象属性的描述对象（-s 某个） 为了解决assign无法正确拷贝（get set）
Object.setPrototypeOf(object,prototype)	写操作
Object.getPrototypeOf(obj)	读操作
Object.create()	生成操作
Object.keys()
Object.values()
Object.entries()
Object.fromEntries()	是entires逆操作，将键值对还原成对象，适合Map转对象 配合URLSearchParams,将查询字符串转换为对象

const shallowMerge = (target, source) => Object.defineProperties(
  target,
  Object.getOwnPropertyDescriptors(source)
);

const clone = Object.create(Object.getPrototypeOf(obj),
  Object.getOwnPropertyDescriptors(obj));
// 或者
const shallowClone = (obj) => Object.create(
  Object.getPrototypeOf(obj),
  Object.getOwnPropertyDescriptors(obj)
);


// es5 的写法
const obj = {
  method: function() { ... }
};
obj.__proto__ = someOtherObj;
// es6 的写法
var obj = Object.create(someOtherObj);
obj.method = function() { ... };


Object.fromEntries(new URLSearchParams('foo=bar&baz=qux'))
// { foo: "bar", baz: "qux" }