js中Object常用方法和属性

Object的常用方法和属性也是很常用的。
一、属性
Object自带一个prototype的属性，即Object.prototype, Object.prototype本身也只是一个对象，也会有一些属性和方法。
1.属性

Object.prototype.writable：默认为false   
Object.prototype.enumerable：默认为false  
Object.prototype.configurable：默认为false   
Object.prototype.constructor：用于创建一个对象的原型。 

2、常用方法

Object.prototype.hasOwnProperty():返回一个布尔值，表示某个对象是否含有指定的属性，而且此属性非原型链继承。  
Object.prototype.isPrototypeOf():返回一个布尔值，表示指定的对象是否在本对象的原型链中。  
Object.prototype.propertyIsEnumerable():判断指定属性是否可枚举。  

Object.prototype.toString():返回对象的字符串表示。  

Object.prototype.watch():给对象的某个属性增加监听。  

Object.prototype.unwatch():移除对象某个属性的监听。  

Object.prototype.valueOf():返回指定对象的原始值。

二、方法

Object.assign(target,...sources):把任意多的源对象自身的可枚举属性拷贝给目标对象，然后返回目标对象。  
Object.create(proto，[propertiesobject]):创建一个拥有指定原型和若干个指定属性的对象。  
Object.defineProperty(obj,prop,descriptor):直接在一个对象上定义一个新属性，或者修改一个已经存在的属性，并返回这个对象。obj：需要定义属性的对象。prop：需定义或修改的属性的名字。descriptor：将被定义或修改的属性的描述符。  
Object.entries(obj):返回一个包含由给定对象所有可枚举属性的属性名和属性值组成的 [属性名，属性值] 键值对的数组，数组中键值对的排列顺序和使用for…in循环遍历该对象时返回的顺序一致。   
举例：   
var obj = { foo: “bar”, baz: 42 };   
console.log(Object.entries(obj)); // [ [‘foo’, ‘bar’], [‘baz’, 42] ]  
Object.freeze(obj):冻结一个对象，冻结指的是不能向这个对象添加新的属性，不能修改其已有属性的值，不能删除已有属性，以及不能修改该对象已有属性的可枚举性、可配置性、可写性。也就是说，这个对象永远是不可变的。该方法返回被冻结的对象。  
Object.getOwnPropertyDescriptor(obj, prop)：返回指定对象上一个自有属性对应的属性描述符。  
Object.getOwnPropertyNames(obj)：返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性）组成的数组。 

举例：
// 类数组对象

var obj = { 0: “a”, 1: “b”, 2: “c”};   
console.log(Object.getOwnPropertyNames(obj).sort()); // [“0”, “1”, “2”]  
Object.getPrototypeOf(object)：返回该对象的原型。  
Object.is(value1, value2)：判断两个值是否是同一个值。  
Object.isExtensible(obj)：判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）。  
Object.isFrozen(obj)：判断一个对象是否被冻结（frozen）。  
Object.isSealed(obj)：判断一个对象是否是密封的（sealed）。密封对象是指那些不可 扩展 的，且所有自身属性都不可配置的（non-configurable）且属性不可删除的对象（其可以是可写的）。  
Object.keys(obj)：返回一个由给定对象的所有可枚举自身属性的属性名组成的数组，数组中属性名的排列顺序和使用for-in循环遍历该对象时返回的顺序一致 

举例：

var arr = [“a”, “b”, “c”];   
alert(Object.keys(arr)); // 弹出”0,1,2”  
// 类数组对象   
var obj = { 0 : “a”, 1 : “b”, 2 : “c”};   
alert(Object.keys(obj)); // 弹出”0,1,2”  
Object.preventExtensions(obj)：让一个对象变的不可扩展，也就是永远不能再添加新的属性。  
Object.setPrototypeOf(obj, prototype)：将一个指定的对象的原型设置为另一个对象或者null  
Object.values(obj)：返回一个包含指定对象所有的可枚举属性值的数组，数组中的值顺序和使用for…in循环遍历的顺序一样。   

举例：   
var obj = { foo: “bar”, baz: 42 };   
console.log(Object.values(obj)); // [‘bar’, 42]  

Object.assign()与深拷贝
深拷贝与浅拷贝
所谓深拷贝与浅拷贝，是围绕引用类型变量的拷贝进行的讨论。
在ecmascript中，变量分为基本类型和引用类型两种。其本质区别是不可变性，基本类型是不可变的，而引用类型是可变的。
所谓基本类型的不可变性，我们可以举个例子

let a = 1;  
let b = 1;  
a++;  
a===2;//true  
b===1;//true

声明一个变量a，并为其赋值1，这时内存中开辟出一片区域用来储存1。此时声明了一个变量b，也为b赋值1。当执行a++时，
基本类型的不可变性就体现出来，a++的值应该为2，但是这个值并不会将原来储存1的那片内存覆盖掉，而是再开辟一片内
存来存储2。所以对于这个1来讲，他是永远不可变的。
而对于引用变量则不同，因为其存储的是只想某个内存区域的地址，所以其修改时直接操作在内存上的，
这就导致了深拷贝和浅拷贝问题的出现。

浅拷贝  

let foo = {  
   x: 1,  
   y: -1  
}  
let bar = foo;  
foo.x++;  
foo.x ===2 //true  
bar.x ===2 //true

这就是最简单的浅拷贝，其效果十分明显，对拷贝源的操作，会直接体现在拷贝目标上，因为这个赋值行为的本质是内存地址的赋值，
所以他们指向了同一片内存区域。
浅拷贝十分容易，也十分常见，但却无法满足需求，加入我们需要获得拷贝源完全相同，却又不会互相影响的对象，应该怎么办呢
Object.assign()
ES6为我们提供了一种十分好用的方法，Object.assign(target, ...source)方法
assign方法接受多个参数，第一个参数target为拷贝目标，剩余参数...source是拷贝源。此方法可以将...source中的属性复制到target中，
同名属性会进行覆盖，并且在复制过程中实现了'伪'深拷贝

let foo = {  
   a: 1,  
  b: 2,  
 c: {  
   d: 1   
   }  
}  
let bar =  { };  
Object.assign(bar, foo);  
foo.a++;  
foo.a === 2 //true  
bar.a === 1 //true  
乍一看，好像已经实现了深拷贝的效果，对foo.a进行的操作并没有体现在bar.a中，但是再往后看  
foo.c.d++;  
foo.c.d === 2 //true  
bar.c.d === 1 //false  
bar.c.d === 2 //true

Object.assign()的拷贝类型十分明显了,这是一种可以对非嵌套对象进行深拷贝的方法,如果对象中出现嵌套情况,那么其对被嵌套对象的行为就成了普通的浅拷贝.

如果真的想进行深拷贝，最简单粗暴地方式就是JSON操作。
JSON对象中包含两个方法，stringify( )和parse( ),前者可以将对象JSON化，而后者可以将JSON格式转换为对象，这是一种可以实现深拷贝的方法。
但这种方法的缺陷是会破坏原型链，并且无法拷贝属性值为function的属性
所以如果只是想单纯复制一个嵌套对象，可以使用此方法

let foo =  {  
     a：1，  
     b: {  
          c: 1  
   }  
}  
let bar = JSON.parse(JSON.stringify(foo));

来源：https://segmentfault.com/a/1190000010661297

es6入门
Object.assign方法用于对象的合并
Object.assign方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）。
const target = { a: 1 };

const source1 = { b: 2 };
const source2 = { c: 3 };

Object.assign(target, source1, source2);

target // {a:1, b:2, c:3}
如果只有一个参数，Object.assign会直接返回该参数。
const obj = {a:1};
Object.assign(obj) === obj //true
如果该参数不是对象，则会先转成对象，然后返回。
typeof Object.assign(2) // "object"
由于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 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拷贝的属性是有限制的，只拷贝源对象的自身属性（不拷贝继承属性），也不拷贝不可枚举属性。
Object.assign({b: 'c'},
Object.defineProperty({},'invisible',{
enumerable: false,
value: 'hello'
})
}
//{b: 'c'}
注意点
（1）浅拷贝
Object.assign方法实行的是浅拷贝，而不是深拷贝。也就是说，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。
const obj1 = {a: {b: 1}};
const obj2 = Object.assign({},obj1);
obj1.a.b = 2;
obj2.a.b //2
上面代码中，源对象obj1的a属性的值是一个对象，Object.assign拷贝得到的是这个对象的引用。这个对象的任何变化，都会反映到目标对象上面。

const target = { a: 1 };  

const source1 = { b: 2 };  
const source2 = { c: 3 };  

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

target ={a: 1, b:{m:6}, c: 3}  
target.b.m = 8; //修改m的值  
source1.b.m //8 说明是浅拷贝  
原因分析：string、boolean、number是按值传递的，array、obj是按引用传递。

（2）同名属性的替换
对于这种嵌套的对象，一旦遇到同名属性，Object.assign的处理方法是替换，而不是添加。

const target = { a: { b: 'c', d: 'e' } }  
const source = { a: { b: 'hello' } }  
Object.assign(target, source)  
// { a: { b: 'hello' } }

上面代码中，target对象的a属性被source对象的a属性整个替换掉了，而不会得到{ a: { b: 'hello', d: 'e' } }的结果。
这通常不是开发者想要的，需要特别小心。
一些函数库提供Object.assign的定制版本（比如 Lodash 的_.defaultsDeep方法），可以得到深拷贝的合并。
jquery的$.extend(true,{})可以进行深层合并

常见用途
Object.assign方法有很多用处
（1）为对象添加属性

class Point {  
   constructor (x,y) {  
       Object.assign(this,{x,y});  
   }  
}  
const source1 = {b:2};  
const source2 = {c:3};  

(2)为对象添加方法

Object.assign(SomeClass.prototype,{  
   someMethod(arg1,arg2) {  
  },  
  anotherMethod( ) {  
  }  
})  
//等同于  
SomeClass.prototype.someMethod = function (arg1,arg2) {  

};  
SomeClass.prototype.anotherMethod = function ( ) {   

};

上面代码使用了对象属性的简洁表示法，直接将两个函数放在大括号中，
再使用assign方法添加到SomeClass.prototype之中。

(3)克隆对象

function clone(origin) {  
    return Object.assign({},origin);  
}  
上面代码将原始对象拷贝到一个空对象，就得到了原始对象的克隆。  
不过，用这种方法克隆，只能克隆原始对象自身的值（也就是浅拷贝），不能克隆它继承的值。如果想要保持继承链，可以采用下面的代码。  
function clone(origin) {  
    let originProto = Object.getPrototypeOf(origin);  
    return Object.assign(Object.create(originProto),origin);  
}

(4)合并多个对象
将多个对象合并到某个对象。
const merge = （target，...sources） => Object.assign(target,...sources);
如果希望合并后返回一个新对象，可以改写上面函数，对一个空对象合并。
const merge = (...sources) => Object.assign({},...sources);
（5）为属性指定默认值

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

上面代码中，DEFAULTS对象是默认值，options对象是用户提供的参数。Object.assign方法将DEFAULTS和options合并成一个新对象，如果两者有同名属性，则option的属性值会覆盖DEFAULTS的属性值。
注意，由于存在浅拷贝的问题，DEFAULTS对象和options对象的所有属性的值，最好都是简单类型，不要指向另一个对象。否则，DEFAULTS对象的该属性很可能不起作用。
声明对象的时候，为了防止，声明的对象被覆盖，一般用const声明。

const DEFAULTS = {  
    url: {  
        host: 'example.com',  
        port: 7070  
    }  
}  
processContent({url:{port: 8080}})  
//{ url: {port: 8000}}

上面代码的愿意是将url.port改成8000，url.host不变。实际结果却是options.url覆盖掉DEFAULTS.url,所以url.host就不存在了。
我的理解是，非嵌套类型，假如你这里说的是值类型。
值类型放在堆栈中，是只会存在一份的，谁用归谁。
引用类型，放在堆中，这时候，浅拷贝是拷贝了一份引用放在堆栈，深拷贝是拷贝了对象本身放在堆。

如何实现一个对象的深拷贝？

http://www.jb51.net/article/99013.htm