ES6--对象

属性的简洁表示法

ES6允许直接写入变量和函数，作为对象的属性和方法function f( x, y ) {  return { x, y };}// 等同于function f( x, y ) {  return { x: x, y: y };}var Person = {            name: '张三',            birth:'1990-01-01',            // 等同于hello: function ()...            hello() {                 document.write('我的名字是', this.name);             }          };     Person.hello();＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ function getPoint() {  var x = 1;  var y = 10;  return {x, y}; //直接返回变量，变为对象的属性}getPoint()   // {x:1, y:10}    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

属性名表达式 
表达式作为属性名，这时要将表达式放在方括号之内。 
使用字面量方式定义对象（使用大括号）

let obj = {};// 方法一obj.foo = true;// 方法二obj['a'+'bc'] = 123;document.write(obj); //属性名表达式var obj = {  foo: true,  abc: 123};ES6允许字面量定义对象时，用方法二（表达式）作为对象的属性名，即把表达式放在方括号内。let propKey = 'foo';let obj = {   [propKey]: true,   ['a'+'bc']: 123};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

比较两个值是否严格相等 
Object.is()用来比较两个值是否严格相等。它与严格比较运算符（===）的行为基本一致，不同之处只有两 
个：一是+0不等于-0，二是NaN等于自身。

+0 === -0 //trueNaN === NaN // falseObject.is(+0, -0) // falseObject.is(NaN, NaN) // true
1
2
3
4
5
1
2
3
4
5

源对象的所有可枚举属性，复制到目标对象 
Object.assign方法用来将源对象（source）的所有可枚举属性，复制到目标对象（target）。它至少需要两 
个对象作为参数，第一个参数是目标对象，后面的参数都是源对象。只要有一个参数不是对象，就会抛出 
TypeError错误。

var target = { a: 1 };var source1 = { b: 2 };var source2 = { c: 3 };Object.assign(target, source1, source2);target // {a:1, b:2, c:3}如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。var target = { a: 1, b: 1 };var source1 = { b: 2, c: 2 };var source2 = { c: 3 };Object.assign(target, source1, source2);target // {a:1, b:2, c:3}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

proto属性 
proto属性，用来读取或设置当前对象的prototype对象

// es6的写法var obj = {  __proto__: someOtherObj,  method: function() { ... }}// es5的写法var obj = Object.create(someOtherObj);obj.method = function() { ... }
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11

Symbol类型 
ES6引入了一种新的原始数据类型Symbol，表示独一无二的ID。凡是属性名属于Symbol类型，就都是独一 
无二的，可以保证不会与其他属性名产生冲突。

let s = Symbol();typeof s// "symbol"Symbol函数前不能使用new命令，否则会报错。这是因为生成的Symbol是一个原始类型的值，不是对象。Symbol类型的值不能与其他类型的值进行运算，会报错。var sym = Symbol('My symbol');"your symbol is " + sym// TypeError: can't convert symbol to string`your symbol is ${sym}`// TypeError: can't convert symbol to string但是，Symbol类型的值可以转为字符串var sym = Symbol('My symbol');String(sym) // 'Symbol(My symbol)'sym.toString() // 'Symbol(My symbol)'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

内置代理

Proxy 内置的一个代理工具，使用他可以在对象处理上加一层屏障：S6原生提供Proxy构造函数，用来生成Proxy实例。var proxy = new Proxy(target, handler)new Proxy()表示生成一个Proxy实例，它的target参数表示所要拦截的目标对象，handler参数也是一个对象，用来定制拦截行为。var plain = {    name : "hubwiz"};var proxy = new Proxy(plain, {    get: function(target, property) {        return property in target ? target[property] : "汇智网";    }});//读取对象时，如果对象属性存在，则返回属性的值，//如果读取对象属性不存在，则返回指定的值 proxy.name // "hubwiz"proxy.title // "汇智网"get(target, propKey, receiver)：拦截对象属性的读取，比如proxy.foo和proxy['foo']，返回类型不限。最后一个参数receiver可选，当target对象设置了propKey属性的get函数时，receiver对象会绑定get函数的this对象。set(target, propKey, value, receiver)：拦截对象属性的设置，比如proxy.foo = v或proxy['foo'] = v，返回一个布尔值。has(target, propKey)：拦截propKey in proxy的操作，返回一个布尔值。deleteProperty(target, propKey) ：拦截delete proxy[propKey]的操作，返回一个布尔值。enumerate(target)：拦截for (var x in proxy)，返回一个遍历器。hasOwn(target, propKey)：拦截proxy.hasOwnProperty('foo')，返回一个布尔值。ownKeys(target)：拦截Object.getOwnPropertyNames(proxy)、Object.getOwnPropertySymbols(proxy)、Object.keys(proxy)，返回一个数组。该方法返回对象所有自身的属性，而Object.keys()仅返回对象可遍历的属性。getOwnPropertyDescriptor(target, propKey) ：拦截Object.getOwnPropertyDescriptor(proxy, propKey)，返回属性的描述对象。defineProperty(target, propKey, propDesc)：拦截Object.defineProperty(proxy, propKey, propDesc）、Object.defineProperties(proxy, propDescs)，返回一个布尔值。preventExtensions(target)：拦截Object.preventExtensions(proxy)，返回一个布尔值。getPrototypeOf(target) ：拦截Object.getPrototypeOf(proxy)，返回一个对象。isExtensible(target)：拦截Object.isExtensible(proxy)，返回一个布尔值。setPrototypeOf(target, proto)：拦截Object.setPrototypeOf(proxy, proto)，返回一个布尔值。如果目标对象是函数，那么还有两种额外操作可以拦截。apply(target, object, args)：拦截Proxy实例作为函数调用的操作，比如proxy(...args)、proxy.call(object, ...args)、proxy.apply(...)。construct(target, args, proxy)：拦截Proxy实例作为构造函数调用的操作，比如new proxy(...args)。