ES6中对象的新增方法（一）

Object.is()

ES5中要比较两个值是否相等，只有两种运算符（== 或 ===）
前者会自动转换数据类型，后者的NaN不等自身，以及+0 和 -0相等

ES6提出同值相等算法， 用来解决这两个问题。
Object.is就是部署这个算法的新方法，它用来比较两个值否严格相等，与严格运算符（===）的行为基本一致

	Object.is('foo', 'foo')
	// true
	Object.is(NaN, NaN)
	// true

不同之处有两个，一个是 +0 不等于 -0 NaN等于自身

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

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

模拟Object.is 处理上面两个问题

	Object.definedProperty(Object, 'is', {
		value: function (x, y) {
			if (x === y) {
				// 针对+0 -0
				return x !== 0 || 1 / x === 1 / y
			} 
				/* 
					首先（x !== 0）不管正0还是负0都会返回false				
					1 / x 如果是正零会返回infinity，负零返回-infinity
					1 / y 同上
				*/
			
			// 针对NaN的比较
			return x !== x && y !== y
			/*
				首先（x !== x）NaN !== NaN 会返回true
				返回true的结果会继续执行
				下一步（y !== y）NaN !== NaN ,所有都会返回true。
				最后true这个boolean会把返回出去
			*/
			
		}
	})

Object.assign()

改方法用于对象的合并，将源对象（origin）的所有可枚举的属性，拷贝到目标对象（target）

	let target = { a : 1 }
	let origin = { b : 2 }
	let origin1 = { c : 3 }
	
	Object.assign(target, origin, origin1)
	target 
	// { a : 1, b : 2, c : 3 }

assign方法的第一个参数是目标对象，后面的参数全部都是数据源

注意，如果目标对象与源对象有同名属性，又或者多个源对象有同名属性，后面的会覆盖前面的属性

	let target = { a : 1, b : 1 }

	let origin = { b : 2, c : 2 }
	let origin1 = { c : 3 }
	Object.assign(target, origin, origin1)
	target 
	// { a : 1, b : 2, c : 3 }

上面代码中，
目标对象有两个属性 a 和 b
源对象1 有 b 和 c
源对象2 有 一个 c

在进行拷贝时，源对象1会替换目标对象的b， 源对象2又会替换源对象1的c

如果assign只有一个参数，那么该方法会直接返回该参数

	let obj = { a : 1 }
	Object.assign(obj) === obj // true

如果参数不是对象，会先转为对象。再返回

	typeof Object.assign(2) // object

由于undefined和null无法转为对象，所以它们作为参数就会报错

	Object.assign(undefined); // error
	Object.assign(null);      // error

如果对象参数出现在源对象位置（非首参），处理规则就会不同，首先它们会转为对象，如果遇到undefined， null转换不成对象的类型，会跳过，也就是说不会报错

	let target = { foo : 'foo' }

	let origin = { bar : 'bar' }
	Object.assign(target, undefined, null, origin)
	target 
	// { foo : 'foo', bar : 'bar' }
	

其他值（字符串，布尔，数值）不再首参位，也不会报错
但是字符串的处理方式不同，它会以数组形式拷贝到目标对象，其他值都不会

	let origin1 = 'hi';
	let origin2 = false;
	let origin3 = 20;

	Object.assign({}, origin1, origin2, origin3)
	// { 0 : 'h', 1 : 'i' }

Object.assign 属性只能拷贝，源对象自身属性（不拷贝继承属性）， 不拷贝不可枚举属性（enumable ： false）

	Object.assign({ foo : 'foo' }, 
		Object.defineProperty({}, 'bar', {
			enumable: false,
			value: 'bar'
		})
	)
	// { foo : 'foo' }

上面代码只返回了foo， 因为bar属性是一个不可枚举的

但是这个assign能拷贝Symbol

	Object.assign({ foo : 'foo' }, { [Symbol('bar')] : 'bar'})
	// { foo : 'foo', Symbol('bar') : 'bar' }

注意点

（1）浅拷贝

Object.assign拷贝的只是引用。也就是说你改我也跟着改

	let obj1 = { a : { b : 1 } };
	let obj2 = Object.assign({}, obj1);

	obj1.a.b = 2;
	obj2
	// { a : { b : 2 } }

（2）同名属性的替换

对于这种嵌套的写法，如果出现同名属性，assign采用替换，而不是添加

	let target = { hello : { world : 'es5' } };
	let origin = { hello : 'es6' };

	Object.assign(target, origin);
	// { hello : 'es6' }

上面方法origin会把target对象内容全部替换，这通常不是我们想要的

一些函数库提供Object.assign的定制版本（比如 Lodash 的_.defaultsDeep方法），可以得到深拷贝的合并。

（3）数组的处理

会把数组视为对象

	Object.assign([1, 2, 3], [4, 5])
	// [4, 5, 3]

上面的结果会返回不如意的，因为改方法会把它认为是0 1 2的索引数组，导致0 的位置是4， 1 的位置是 5 2 的位置不变，会导致覆盖情况

（4）取值函数的处理

Object.assign只能进行值的拷贝，如果要复制的值是一个取值函数，那么将求值后再复制

	let source = {
		get foo () {
			return 1;
		}
	}
	let target = {}
	Object.assign(target, source);
	// { foo : 1 }

assign不会复制这个取值函数，只会取到值，把值拷贝过去

用途

（1）为对象添加属性

	Object.assign({}, {foo : 'foo'})
	

（2）为对象添加方法

	Object.assign(obj.prototype, {
		foo () {},
		bar () {}
	})

	// 等同于
	obj.prototype.foo = function () {}
	obj.prototype.bar = function () {}
	

（3）克隆对象

	function clone (origin) {
		return Object.assign({}, origin)
	}

这种属于浅克隆

还可以保留继承

	function clone (origin) {
		// 拿到原型
		let originProto = Object.getPrototypeOf(origin)	
		// 再把实例的值放到原型上，并返回。
		return Object.assign(Object.create(originProto), origin)
	}

（4）合并多个对象

	let source = (target, ...objects) => Object.assign(target, ...objects)

如果希望合并后返回一个新对象，可这样改写

	let source = (...objects) => Object.assign({}, ...objects)

（5）为属性指定默认值

	let DEFAULT = {
		wife: 'fanfan',
		sex: 'girl'
	}

	function defaultFn (options) {
		options = Object.assign({}, DEFAULT, options)
	}
	

options是用户提供的数据，如果用户没有传递使用默认值，如果传递了，那么同名属性会被覆盖

由于浅拷贝的问题，DEFAULT和options属性最好不要有引用值