object常用方法及对象拷贝

1.Object.assign(target,source1,source2,…)

该方法主要用于对象的合并，将源对象source的所有可枚举属性合并到目标对象target上,此方法只拷贝源对象的自身属性，不拷贝继承的属性。
Object.assign方法实行的是浅拷贝，而不是深拷贝。也就是说，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。同名属性会替换。
Object.assign只能进行值的复制，如果要复制的值是一个取值函数，那么将求值后再复制。
Object.assign可以用来处理数组，但是会把数组视为对象。

2.Object.create(prototype,[propertiesObject])

使用指定的原型对象及其属性去创建一个新的对象

3.Object.defineProperties(obj,props)
直接在一个对象上定义新的属性或修改现有属性，并返回该对象。

 var obj = {};
Object.defineProperties(obj, {
'property1': {
value: true,
writable: true
 },
'property2': {
value: 'Hello',
writable: false
}
});
console.log(obj)  

4.Object.defineProperty(obj,prop,descriptor)
在一个对象上定义一个新属性，或者修改一个对象的现有属性， 并返回这个对象。

Object.defineProperty(Object, 'is', {
  value: function(x, y) {
           if (x === y) {
          // 针对+0 不等于 -0的情况
              return x !== 0 || 1 / x === 1 / y;
          }
          // 针对NaN的情况
          return x !== x && y !== y;
  },
  configurable: true,
  enumerable: false,
  writable: true
});

// 注意不能同时设置(writable，value) 和 get，set方法，否则浏览器会报错 ： Invalid property descriptor. Cannot both specify accessors and a value or writable attribute

5.Object.keys(obj)
返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和使用 for…in 循环遍历该对象时返回的顺序一致 （两者的主要区别是 一个 for-in 循环还会枚举其原型链上的属性）。

var arr = ["a", "b", "c"];
console.log(Object.keys(arr));
// ['0', '1', '2']

/* Object 对象 */
var obj = { foo: "bar", baz: 42 },
keys = Object.keys(obj);
console.log(keys);
// ["foo","baz"]

6.Object.values()
方法返回一个给定对象自己的所有可枚举属性值的数组，值的顺序与使用for…in循环的顺序相同 ( 区别在于 for-in 循环枚举原型链中的属性 )。
Object.values会过滤属性名为 Symbol 值的属性。

var an_obj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.values(an_obj)); // ['b', 'c', 'a']

var obj = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.values(obj)); // ['a', 'b', 'c']

7.Object.entries()
返回一个给定对象自身可枚举属性的键值对数组，其排列与使用 for…in 循环遍历该对象时返回的顺序一致（区别在于 for-in 循环也枚举原型链中的属性）。

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

const simuArray = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.entries(simuArray)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]

8.hasOwnProperty()
判断对象自身属性中是否具有指定的属性。
obj.hasOwnProperty(‘name’)

9.Object.getOwnPropertyNames()
返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性但不包括Symbol值作为名称的属性）组成的数组。

var obj = { 0: "a", 1: "b", 2: "c"};
Object.getOwnPropertyNames(obj).forEach(function(val) {
  console.log(val);
});

var obj = {
  x : 1,
  y : 2
}
Object.defineProperty(obj,'z',{
  enumerable : false
})
console.log(Object.getOwnPropertyNames(obj))  // ["x", "y", "z"] 包含不可枚举属性 。
console.log(Object.keys(obj))                 // ["x", "y"]      只包含可枚举属性 。

10.isPrototypeOf()
判断一个对象是否存在于另一个对象的原型链上。

加粗样式11.Object.setPrototypeOf(obj,prototype)
设置对象的原型对象

12.Object.is()
判断两个值是否相同。
如果下列任何一项成立，则两个值相同：

两个值都是 undefined
两个值都是 null
两个值都是 true 或者都是 false
两个值是由相同个数的字符按照相同的顺序组成的字符串
两个值指向同一个对象
两个值都是数字并且
都是正零 +0
都是负零 -0
都是 NaN
都是除零和 NaN 外的其它同一个数字

Object.is('foo', 'foo');     // true
Object.is(window, window);   // true

Object.is('foo', 'bar');     // false
Object.is([], []);           // false

var test = { a: 1 };
Object.is(test, test);       // true

Object.is(null, null);       // true

// 特例
Object.is(0, -0);            // false
Object.is(-0, -0);           // true
Object.is(NaN, 0/0);         // true

13.Object.freeze()
冻结一个对象，冻结指的是不能向这个对象添加新的属性，不能修改其已有属性的值，不能删除已有属性，以及不能修改该对象已有属性的可枚举性、可配置性、可写性。也就是说，这个对象永远是不可变的。该方法返回被冻结的对象。

var obj = {
  prop: function() {},
  foo: 'bar'
};

// 新的属性会被添加, 已存在的属性可能
// 会被修改或移除
obj.foo = 'baz';
obj.lumpy = 'woof';
delete obj.prop;

// 作为参数传递的对象与返回的对象都被冻结
// 所以不必保存返回的对象（因为两个对象全等）
var o = Object.freeze(obj);

o === obj; // true
Object.isFrozen(obj); // === true

// 现在任何改变都会失效
obj.foo = 'quux'; // 静默地不做任何事
// 静默地不添加此属性
obj.quaxxor = 'the friendly duck';
console.log(obj)

14.Object.isFrozen()
判断一个对象是否被冻结 .

15.Object.preventExtensions()
对象不能再添加新的属性。可修改，删除现有属性，不能添加新属性。

var obj = {
  name :'lilei',
  age : 30 ,
  sex : 'male'
}

obj = Object.preventExtensions(obj);
console.log(obj);    // {name: "lilei", age: 30, sex: "male"}
obj.name = 'haha';
console.log(obj)     // {name: "haha", age: 30, sex: "male"}
delete obj.sex ;
console.log(obj);    // {name: "haha", age: 30}
obj.address  = 'china';
console.log(obj)     // {name: "haha", age: 30}

深浅拷贝

		/*var a = 10;
		var b = a;
		b = 1;*/
		/*var a = [10];
		var b = a;
		//b.push(20);
		//b = [20];
		console.log(a);*/
		//引用类型直接复制（赋值） 浅拷贝
		//引用类型内部的值的复制，与地址无关  深拷贝
		/*var obj1 = {a:[1],b:2};
		var obj2 = {a:3,d:4};
		var obj = {};
		Object.assign(obj,obj1,obj2);
		console.log(obj);*/
		//obj.a.push(2);
		//console.log(obj1,obj);
		
		//定义的一个对象的属性的,这些属性是可配置的
		/*var obj = {};
		var obj1 = {};
		Object.defineProperty(obj1,"a",{
			value:1,
			enumerable:true,
			writable:false,
			configurable:true
		});*/
		/*console.log(obj1);
		for(var i in obj1){
			console.log(i);
		}*/
		//将一个或者多个源对象的可枚举属性复制给目标对象
		/*Object.assign(obj,obj1);
		console.log(obj);*/
		//obj1.a = 2;
		//console.log(obj1);
		
		/*delete obj1.a;
		console.log(obj1);*/
		
		function deepCopy(obj){
			//Array.isArray()判断小括号里的参数是不是一个数组，是，返回true
			if(Array.isArray(obj)){
				var newObj = [];
			}else{
				var newObj = {};
			}
			for(var i in obj){
				if(typeof obj[i] == "object"){
					newObj[i] = deepCopy(obj[i]);
				}else{
					newObj[i] = obj[i];
				}
			}
			
			return newObj;
		}
		var arr = [[1],2,3]
		var arr1 = deepCopy(arr);
		arr1[0].push(2);
		
		console.log(arr,arr1);
		//实现深拷贝的第二种方式
		var obj = {a:[1,2,3]};
		var obj1 = JSON.parse(JSON.stringify(obj));
		obj1.a.push(4);
		
		console.log(obj,obj1);