ES6 之 Object 的方法总结

阅读：Object

1、obj的"." 或 "[]"方法

读取对象的属性或方法

对象属性的读取：ES6中被Proxy的get(target, propKey, receiver)拦截

2、obj.key = value 或 obj[key] = value

设置对象的属性的方法

对象属性的设置：ES6中被Proxy的set(target, propKey, value, receiver)拦截，返回一个boolean值

call()、apply()、bind()

1// 用 apply 
2var array = ['a', 'b', 'c'];
3var elements = [0, 1, 2];
4array.push.apply(array, elements);
5console.info(array); // ["a", "b", "c", 0, 1, 2]
6
7let numbers = [1,2,4,5,7,4,2];
8let max = Math.max.apply(null, numbers);
9console.log(max); // 7
10let min = Math.min.apply(null, numbers);
11console.log(min); // 1
12
13// 用 call
14let animals = [
15    { name: 'Lion', age: 17},
16    { name: 'Whale', age: 18}
17];
18for (let i = 0; i < animals.length; i++) {
19    (function (i) {
20        this.print = function () {
21            console.log('#' + i + ' ' + this.name + ', ' + this.age);
22        }
23        this.print();
24    }).call(animals[i], i);
25}
26// 0 Lion, 17
27// 1 Whale, 18

3、obj.func()

对象的方法调用

对象的方法调用：ES6中被Proxy的apply(target, object, args)拦截，apply 方法拦截函数的调用、call 和 apply的操作。例如：proxy(...args)、proxy.call(object, ...args)、proxy.apply(...)。

4、key in obj

判断对象中是否包含某个属性或方法

判断对象存在与否：ES6中被Proxy的 has(target, propKey) 拦截，返回一个布尔值。

5、construct构造函数

构造函数的调用

ES6中被Proxy的 construct(target, args) 拦截 Proxy 实例作为构造函数调用的操作，比如 new proxy(...args)。

let obj = new Object({name: houfee})

6、delete obj.key

删除对象中的某个属性

删除对象中的某个属性：ES6中被Proxy的 deleteProperty(target, propKey) 拦截，返回一个布尔值。

7、Object.defineProperty(obj, prop, descriptor)

该方法会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性， 并返回这个对象。

1obj：要在其上定义属性的对象。
2
3prop：要定义或修改的属性的名称。
4
5descriptor：将被定义或修改的属性描述符。
6
7返回值：被传递给函数的对象

默认情况下，使用 Object.defineProperty() 添加的属性值是不可修改的。

MDN：Object.defineProperty

ES6中被Proxy的 defineProperty(target, propKey, propDesc) 拦截，返回一个布尔值。

注意：defineProperty(target, propKey, propDesc) 还拦截 Object.defineProperties(proxy, propDesc)，返回一个布尔值。

8、Object.getOwnPropertyDescriptor(target, propKey)

该方法返回指定对象上一个自有属性对应的属性描述符。（自有属性指的是直接赋予该对象的属性，不需要从原型链上进行查找的属性）

1// 获取自己的属性描述符
2target: 需要查找的目标对象
3propKey: 目标对象内属性名称
4返回值：如果指定的属性存在于对象上，则返回其属性描述符对象（property descriptor），否则返回 undefined。

返回对象指定的属性配置。

该方法允许对一个属性的描述进行检索。在 Javascript 中， 属性 由一个字符串类型的“名字”（name）和一个“属性描述符”（property descriptor）对象构成。

一个属性描述符是一个记录，由下面属性当中的某些组成的：

1value：该属性的值(仅针对数据属性描述符有效)
2
3writable：当且仅当属性的值可以被改变时为true。(仅针对数据属性描述有效)
4
5get：获取该属性的访问器函数（getter）。如果没有访问器， 该值为undefined。(仅针对包含访问器或设置器的属性描述有效)
6
7set：获取该属性的设置器函数（setter）。 如果没有设置器， 该值为undefined。(仅针对包含访问器或设置器的属性描述有效)
8
9configurable：当且仅当指定对象的属性描述可以被改变或者属性可被删除时，为true。
10
11enumerable：当且仅当指定对象的属性可以被枚举出时，为 true。

ES6中被 Proxy的getOwnPropertyDescriptor(target, propKey)拦截，返回属性的描述对象。

9、Object.getPrototypeOf(obj)

Object.getPrototypeOf() 方法返回指定对象的原型（内部[[Prototype]]属性的值）。

1obj:要返回其原型的对象
2返回值：给定对象的原型。如果没有继承属性，则返回 null
3
4const prototype1 = {};
5const object1 = Object.create(prototype1);
6
7console.log(Object.getPrototypeOf(object1) === prototype1); // true

ES6中被 Proxy的getPrototypeOf(target)拦截，返回一个对象。

10、Object.isExtensible(obj)

Object.isExtensible() 方法判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）。

1obj：需要检测的对象
2
3返回值：表示给定对象是否可扩展的一个Boolean

默认情况下，对象是可扩展的：即可以为他们添加新的属性。以及它们的 __proto__ 属性可以被更改。Object.preventExtensions，Object.seal 或 Object.freeze 方法都可以标记一个对象为不可扩展（non-extensible）。

1// 新对象默认是可扩展的.
2var empty = {};
3Object.isExtensible(empty); // === true
4
5// ...可以变的不可扩展.
6Object.preventExtensions(empty);
7Object.isExtensible(empty); // === false
8
9// 密封对象是不可扩展的.
10var sealed = Object.seal({});
11Object.isExtensible(sealed); // === false
12
13// 冻结对象也是不可扩展.
14var frozen = Object.freeze({});
15Object.isExtensible(frozen); // === false

注意：在 ES5 中，如果参数不是一个对象类型，将抛出一个 TypeError 异常。在 ES6 中， non-object 参数将被视为一个不可扩展的普通对象，因此会返回 false 。

ES6中被 Proxy的isExtensible(target)拦截，返回一个布尔值。

11、Object.getOwnPropertyNames(obj)、 Object.getOwnPropertySymbols(obj)、Object.keys(obj)

11.1、Object.getOwnPropertyNames(obj)

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

1obj：一个对象，其自身的可枚举和不可枚举属性的名称被返回。
2
3返回值：在给定对象上找到的自身属性对应的字符串数组。

描述

Object.getOwnPropertyNames() 返回一个数组，该数组对的元素是 obj自身拥有的枚举或不可枚举属性名称字符串。 数组中枚举属性的顺序与通过 for...in 循环（或 Object.keys）迭代该对象属性时一致。数组中不可枚举属性的顺序未定义。

11.2、Object.getOwnPropertySymbols(obj)

Object.getOwnPropertySymbols() 方法返回一个给定对象自身的所有 Symbol 属性的数组。

1obj：要返回 Symbol 属性的对象。
2
3返回值：在给定对象自身上找到的所有 Symbol 属性的数组

因为所有的对象在初始化的时候不会包含任何的 Symbol，除非你在对象上赋值了 Symbol 否则Object.getOwnPropertySymbols()只会返回一个空的数组。

11.3、Object.keys (obj)

Object.keys() 方法会返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和使用 for...in 循环遍历该对象时返回的顺序一致 。如果对象的键-值都不可枚举，那么将返回由键组成的数组。

1obj：要返回其枚举自身属性的对象。
2
3返回值：一个表示给定对象的所有可枚举属性的字符串数组。
4
5// simple array
6var arr = ['a', 'b', 'c'];
7console.log(Object.keys(arr)); // console: ['0', '1', '2']
8
9// array like object
10var obj = { 0: 'a', 1: 'b', 2: 'c' };
11console.log(Object.keys(obj)); // console: ['0', '1', '2']
12
13// array like object with random key ordering
14var anObj = { 100: 'a', 2: 'b', 7: 'c' };
15console.log(Object.keys(anObj)); // console: ['2', '7', '100']
16
17// getFoo is a property which isn't enumerable
18var myObj = Object.create({}, {
19  getFoo: {
20    value: function () { return this.foo; }
21  } 
22});
23myObj.foo = 1;
24console.log(Object.keys(myObj)); // console: ['foo']

ES6中，Proxy的ownKeys(target)方法拦截Object.getOwnPropertyNames(proxy)、 Object.getOwnPropertySymbols(proxy)、Object.keys(proty)，返回一个数组。

该方法返回目标对象所有自身属性的属性名，而 Object.keys() 的返回结果仅包括目标对象自身的可遍历属性。

12、Object.preventExtensions(obj)

**Object.preventExtensions()**方法让一个对象变的不可扩展，也就是永远不能再添加新的属性。

1obj：将要变得不可扩展的对象。
2
3返回值：已经不可扩展的对象。

Object.preventExtensions()仅阻止添加自身的属性。但属性仍然可以添加到对象原型。

一旦使其不可扩展，就无法再对象进行扩展。

例子

1// Object.preventExtensions将原对象变的不可扩展,并且返回原对象.
2var obj = {};
3var obj2 = Object.preventExtensions(obj);
4obj === obj2;  // true
5 
6// 字面量方式定义的对象默认是可扩展的.
7var empty = {};
8Object.isExtensible(empty) //=== true
9 
10// ...但可以改变.
11Object.preventExtensions(empty);
12Object.isExtensible(empty) //=== false
13 
14// 使用Object.defineProperty方法为一个不可扩展的对象添加新属性会抛出异常.
15var nonExtensible = { removable: true };
16Object.preventExtensions(nonExtensible);
17Object.defineProperty(nonExtensible, "new", { value: 8675309 }); // 抛出TypeError异常
18
19// 一个不可扩展对象的原型是不可更改的,__proto__是个非标准魔法属性,可以更改一个对象的原型.
20var fixed = Object.preventExtensions({});
21fixed.__proto__ = { oh: "hai" }; // 抛出TypeError异常

在 ES5 中，如果参数不是一个对象类型，将抛出一个TypeError异常。在 ES2015 中，非对象参数将被视为一个不可扩展的普通对象，因此会被直接返回。

ES6 Proxy中 preventExtensions(target)方法拦截Object.preventExtensions() 。该方法必须返回一个布尔值，否则会被自动转为布尔值。

只有目标对象不可扩展时（即 Object.isExtensible(proxy) 为 false ）， proxy.preventExtensions 才能返回 true ，否则会报错。

13、Object.setPrototypeOf(obj, prototype)

Object.setPrototypeOf() 方法设置一个指定的对象的原型 ( 即, 内部[[Prototype]]属性）到另一个对象或  null。

1obj：要设置其原型的对象。
2
3prototype：该对象的新原型(一个对象 或 null)

如果对象的[[Prototype]]被修改成不可扩展(通过 Object.isExtensible()查看)，就会抛出 TypeError异常。如果prototype参数不是一个对象或者null(例如，数字，字符串，boolean，或者 undefined)，则什么都不做。否则，该方法将obj的[[Prototype]]修改为新的值。

ES6中，setPrototypeOf(target, proto)拦截 Object.setPrototypeOf(target, proto)，返回一个布尔值。