对象新增方法

Object.is()

的缺点：会自动转换类型，而=的NaN不等于自身，+0等于-0,可以使用Object.is()来严格判断

Object.assign()

用于对象合并

const target={a:1};
const source={b:2};
Object.assign(target,source);
//不是对象会转成对象后返回
typeof Object.assign(2) // "object"
Object.assign(obj, null) === obj // true
//除了字符串类型会转为数组，其它类型(数值，字符串，bool)不会产生效果,因为只有可枚举类才可放入
const v1 = 'abc';
const v2 = true;
const v3 = 10;
const obj = Object.assign({}, v1, v2, v3);
console.log(obj); // { "0": "a", "1": "b", "2": "c" }
//数组也可以使用这种拷贝：
Object.assign([1, 2, 3], [4, 5])
// [4, 5, 3]
//对于取值函数会求值后复制
const source = {
  get foo() { return 1 }
};
const target = {};
Object.assign(target, source)
// { foo: 1 }

Object.assign的多种用处：

• 为对象添加属性

class Point{
  constructor(x,y){
    Object.assign(this,{x,y});
  }
}

• 为对象添加方法：

Object.assign(SomeClass.prototype,{
  someMethod(arg1,arg2){

  }
})
//等同于：
SomeClass.prototype.someMethod = function (arg1, arg2) {
  ···
};

• 克隆对象,不过无法拷贝继承链

function clone(origin){
  return Object.assign({},origin);
}
//多个对象合并到一个
const merge=(target,...sources)=>Object.assign(target,...sources);

为属性指定默认值,如：

const DEFAULTS = {
  logLevel: 0,
  outputFormat: 'html'
};
function processContent(options) {
  options = Object.assign({}, DEFAULTS, options);
  console.log(options);
  // ...
}

原型

一个对象本身具有__proto__属性，指向对象原型，而使用Object.setProtypeOf()则设置对象的原型对象Object.setPrototypeOf(object,protype)。
获取所有的键值：

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

entries可以将对象转为Map结构：

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

Object.fromEntries()将键值对数组转为对象.

//将查询参数转为对象
Object.fromEntries(new URLSearchParams('foo=bar&baz=qux'))
// { foo: "bar", baz: "qux" }

Symbol可以用来生成独一无二的一个属性，从而防止命名问题

let s1 = Symbol('foo');
let s2 = Symbol('bar');

Symbol可以转为bool，不能转为数值。

let mySymbol = Symbol();
// 第一种写法
let a = {};
a[mySymbol] = 'Hello!';
// 第二种写法
let a = {
  [mySymbol]: 'Hello!'
};
// 第三种写法
let a = {};
Object.defineProperty(a, mySymbol, { value: 'Hello!' });
// 以上写法都得到同样结果
a[mySymbol] // "Hello!"

可以使用这个来定义常量，保证不相等：

const log = {};
log.levels = {
  DEBUG: Symbol('debug'),
  INFO: Symbol('info'),
  WARN: Symbol('warn')
};
console.log(log.levels.DEBUG, 'debug message');
console.log(log.levels.INFO, 'info message');

使用for...in和Object.getOwnPropertyNames()得不到Symbol键名，需要用到Object.getOwnPropertySymbols()
或Reflect.ownKeys()

• 把Symbol注册到全局,可以在根据描述复用。

// 单例实现:
const FOO_KEY = Symbol.for('foo');
function A() {
  this.foo = 'hello';
}
if (!global[FOO_KEY]) {
  global[FOO_KEY] = new A();
}
module.exports = global[FOO_KEY];