关于JavaScript的Object所有方法

1. Object.assign()–复制修改对象

Object.assign() 方法将所有可枚举（Object.propertyIsEnumerable() 返回 true）和自有（Object.hasOwnProperty() 返回 true）属性从一个或多个源对象复制到目标对象，返回修改后的对象

尝试一下

const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };

const returnedTarget = Object.assign(target, source);

console.log(target);
// { a: 1, b: 4, c: 5 }

console.log(returnedTarget);
//  { a: 1, b: 4, c: 5 }
1
2
3
4
5
6
7
8
9
10

语法

Object.assign(target, ...sources)
1

参数

• target 目标对象，接收源对象属性的对象，也是修改后的返回值。
• sources 源对象，包含将被合并的属性。

返回值
目标对象

2. Object.create()–创建新对象

Object.create() 方法用于创建一个新对象，使用现有的对象来作为新创建对象的原型（prototype）

示例

const person = {
  isHuman: false,
  printIntroduction: function() {
    console.log(`My name is ${this.name}. Am I human? ${this.isHuman}`);
  }
};
const me = Object.create(person);
me.name = 'Matthew';
me.isHuman = true; 
me.printIntroduction();
// "My name is Matthew. Am I human? true"

1
2
3
4
5
6
7
8
9
10
11
12

语法

Object.create(proto)
Object.create(proto, propertiesObject)
1
2

参数

• proto 新创建对象的原型对象。
• propertiesObject （可选）如果该参数被指定且不为 undefined，则该传入对象的自有可枚举属性（即其自身定义的属性，而不是其原型链上的枚举属性）将为新创建的对象添加指定的属性值和对应的属性描述符。这些属性对应于 Object.defineProperties() 的第二个参数。

返回值
一个新对象，带着指定的原型对象及其属性。

3. Object.defineProperty()–vue数据响应式原理

Object.defineProperty() 方法会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，并返回此对象。

const object1 = {};

Object.defineProperty(object1, 'property1', {
  value: 42,
  writable: false // 不可编辑
});

object1.property1 = 77;
// error

console.log(object1.property1);
//  42
1
2
3
4
5
6
7
8
9
10
11
12

语法

Object.defineProperty(obj, prop, descriptor)
1

参数

• obj 要定义属性的对象。
• prop 要定义或修改的属性的名称或 Symbol 。
• descriptor 要定义或修改的属性描述符。

返回值
被传递给函数的对象。

更多>>

4. Object.defineProperties()–类似defineProperty

更多>>

5. Object.entries()–对象转map

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

const object1 = {
  a: 'somestring',
  b: 42
};

for (const [key, value] of Object.entries(object1)) {
  console.log(`${key}: ${value}`);
}

// "a: somestring"
// "b: 42"
1
2
3
4
5
6
7
8
9
10
11

语法

Object.entries(obj)
1

参数

• obj 可以返回其可枚举属性的键值对的对象。

返回值
给定对象自身可枚举属性的键值对数组。

描述
Object.entries()返回一个数组，其元素是与直接在object上找到的可枚举属性键值对相对应的数组。属性的顺序与通过手动循环对象的属性值所给出的顺序相同。

6. Object.freeze()–冻结对象

Object.freeze() 方法可以冻结一个对象。一个被冻结的对象再也不能被修改；冻结了一个对象则不能向这个对象添加新的属性，不能删除已有属性，不能修改该对象已有属性的可枚举性、可配置性、可写性，以及不能修改已有属性的值。此外，冻结一个对象后该对象的原型也不能被修改。freeze() 返回和传入的参数相同的对象。

const obj = {
  prop: 42
};

Object.freeze(obj);

obj.prop = 33;
// error

console.log(obj.prop);
//  42
1
2
3
4
5
6
7
8
9
10
11

语法

Object.freeze(obj)
1

返回值
被冻结的对象。
描述

• 被冻结对象自身的所有属性都不可能以任何方式被修改。任何修改尝试都会失败，无论是静默地还是通过抛出TypeError异常（最常见但不仅限于strict mode）。
• 数据属性的值不可更改，访问器属性（有 getter 和 setter）也同样（但由于是函数调用，给人的错觉是还是可以修改这个属性）。如果一个属性的值是个对象，则这个对象中的属性是可以修改的，除非它也是个冻结对象。数组作为一种对象，被冻结，其元素不能被修改。没有数组元素可以被添加或移除。
• 这个方法返回传递的对象，而不是创建一个被冻结的副本。

示例

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';

// 在严格模式，如此行为将抛出 TypeErrors
function fail(){
  'use strict';
  obj.foo = 'sparky'; // throws a TypeError
  delete obj.quaxxor; // 返回 true，因为 quaxxor 属性从来未被添加
  obj.sparky = 'arf'; // throws a TypeError
}

fail();

// 试图通过 Object.defineProperty 更改属性
// 下面两个语句都会抛出 TypeError.
Object.defineProperty(obj, 'ohai', { value: 17 });
Object.defineProperty(obj, 'foo', { value: 'eit' });

// 也不能更改原型
// 下面两个语句都会抛出 TypeError.
Object.setPrototypeOf(obj, { x: 20 })
obj.__proto__ = { x: 20 }
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42

7. Object.fromEntries()-- 键值对列表（如map）转对象

Object.fromEntries() 方法把键值对列表转换为一个对象。

const entries = new Map([
  ['foo', 'bar'],
  ['baz', 42]
]);

const obj = Object.fromEntries(entries);

console.log(obj);
// { foo: "bar", baz: 42 }
1
2
3
4
5
6
7
8
9

语法

Object.fromEntries(iterable);
1

参数

• iterable 类似 Array 、 Map 或者其它实现了可迭代协议的可迭代对象。

描述
Object.fromEntries() 方法接收一个键值对的列表参数，并返回一个带有这些键值对的新对象。这个迭代参数应该是一个能够实现@@iterator方法的的对象，返回一个迭代器对象。它生成一个具有两个元素的类数组的对象，第一个元素是将用作属性键的值，第二个元素是与该属性键关联的值。

Object.fromEntries() 执行与 Object.entries 互逆的操作。

8. Object.getOwnPropertyDescriptor()–返回指定属性的属性描述符

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

const object1 = {
  property1: 42
};

const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');

console.log(descriptor1.configurable);
//  true

console.log(descriptor1.value);
//  42
1
2
3
4
5
6
7
8
9
10
11

语法

Object.getOwnPropertyDescriptor(obj, prop)
1

参数

• obj 需要查找的目标对象
• prop 目标对象内属性名称

返回值
如果指定的属性存在于对象上，则返回其属性描述符对象（property descriptor），否则返回 undefined。

9. Object.getOwnPropertyDescriptors()–返回对象所有属性描述符

Object.getOwnPropertyDescriptors() 方法用来获取一个对象的所有自身属性的描述符。
语法

Object.getOwnPropertyDescriptors(obj)
1

参数

• obj 任意对象

返回值
所指定对象的所有自身属性的描述符，如果没有任何自身属性，则返回空对象。

10. Object.getOwnPropertyNames()–返回所有属性名

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

示例

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

// 类数组对象
var obj = { 0: "a", 1: "b", 2: "c"};
console.log(Object.getOwnPropertyNames(obj).sort()); // ["0", "1", "2"]

// 使用 Array.forEach 输出属性名和属性值
Object.getOwnPropertyNames(obj).forEach(function(val, idx, array) {
  console.log(val + " -> " + obj[val]);
});
// 输出
// 0 -> a
// 1 -> b
// 2 -> c

//不可枚举属性
var my_obj = Object.create({}, {
  getFoo: {
    value: function() { return this.foo; },
    enumerable: false
  }
});
my_obj.foo = 1;

console.log(Object.getOwnPropertyNames(my_obj).sort()); // ["foo", "getFoo"]
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

11. Object.getOwnPropertySymbols()–返回对象所有Symbol 属性

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

Object.getOwnPropertySymbols(obj)
1

参数

• obj 要返回 Symbol 属性的对象。

返回值
在给定对象自身上找到的所有 Symbol 属性的数组。
示例

var obj = {};
var a = Symbol("a");
var b = Symbol.for("b");

obj[a] = "localSymbol";
obj[b] = "globalSymbol";

var objectSymbols = Object.getOwnPropertySymbols(obj);

console.log(objectSymbols.length); // 2
console.log(objectSymbols)         // [Symbol(a), Symbol(b)]
console.log(objectSymbols[0])      // Symbol(a)
1
2
3
4
5
6
7
8
9
10
11
12

12. Object.getPrototypeOf()–返回对象的原型

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

Object.getPrototypeOf(object)
1

参数

• object 要返回其原型的对象。

返回值
给定对象的原型。如果没有继承属性，则返回 null 。

const prototype1 = {};
const object1 = Object.create(prototype1);

console.log(Object.getPrototypeOf(object1) === prototype1);
//  true
1
2
3
4
5

示例

var proto = {};
var obj = Object.create(proto);
Object.getPrototypeOf(obj) === proto; // true

var reg = /a/;
Object.getPrototypeOf(reg) === RegExp.prototype; // true
1
2
3
4
5
6

13. Object.hasOwn()–检查对象中是否含有指定属性

如果指定的对象具有指定的属性，则 Object.hasOwn() 方法返回 true。如果属性被继承或不存在，则该方法返回 false。

const object1 = {
  prop: 'exists'
};

console.log(Object.hasOwn(object1, 'prop'));
// true

console.log(Object.hasOwn(object1, 'toString'));
// false

console.log(Object.hasOwn(object1, 'undeclaredPropertyValue'));
//  false
1
2
3
4
5
6
7
8
9
10
11
12

语法

• instance 指定对象
• prop 指定的属性值

返回值
如果指定对象直接定义了指定属性，则为 true。否则为false

14. Object.prototype.hasOwnProperty()–同Object.hasOwn()

更多

15. Object.is()–判断两个值是否为同一个值

语法

Object.is(value1, value2);
1

参数

• value1 被比较的第一个值。
• value2 被比较的第二个值。

返回值
一个布尔值，表示两个参数是否是同一个值。
描述

• Object.is() 方法判断两个值是否为同一个值，如果满足以下任意条件则两个值相等：
  1 都是 undefined
  2 都是 null
  3 都是 true 或都是 false
  4 都是相同长度、相同字符、按相同顺序排列的字符串
  5 都是相同对象（意味着都是同一个对象的值引用）
  6 都是数字且：
  6.1 都是 +0
  6.2 都是 -0
  6.3 都是 NaN
  6.4 都是同一个值，非零且都不是 NaN
• Object.is() 与 == 不同。== 运算符在判断相等前对两边的变量（如果它们不是同一类型）进行强制转换（这种行为将 “” ==
  false 判断为 true），而 Object.is 不会强制转换两边的值。
• Object.is() 与 === 也不相同。差别是它们对待有符号的零和 NaN 不同，例如，=== 运算符（也包括 == 运算符）将数字
  -0 和 +0 视为相等，而将 Number.NaN 与 NaN 视为不相等。

示例

//  1
Object.is(25, 25);                // true
Object.is('foo', 'foo');          // true
Object.is('foo', 'bar');          // false
Object.is(null, null);            // true
Object.is(undefined, undefined);  // true
Object.is(window, window);        // true
Object.is([], []);                // false
var foo = { a: 1 };
var bar = { a: 1 };
Object.is(foo, foo);              // true
Object.is(foo, bar);              // false

//  2
Object.is(0, -0);                 // false
Object.is(+0, -0);                // false
Object.is(-0, -0);                // true
Object.is(0n, -0n);               // true

// 3
Object.is(NaN, 0/0);              // true
Object.is(NaN, Number.NaN)        // true
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

16. Object.isExtensible()–判断对象是否可扩展

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

语法

Object.isExtensible(obj)
1

参数

• obj 需要检测的对象

返回值
表示给定对象是否可扩展的一个Boolean 。
描述
默认情况下，对象是可扩展的：即可以为他们添加新的属性。以及它们的 __proto__Deprecated 属性可以被更改。Object.preventExtensions，Object.seal 或 Object.freeze 方法都可以标记一个对象为不可扩展（non-extensible）。
示例

// 新对象默认是可扩展的。
var empty = {};
Object.isExtensible(empty); // === true

// ...可以变的不可扩展。
Object.preventExtensions(empty);
Object.isExtensible(empty); // === false

// 密封对象是不可扩展的。
var sealed = Object.seal({});
Object.isExtensible(sealed); // === false

// 冻结对象也是不可扩展。
var frozen = Object.freeze({});
Object.isExtensible(frozen); // === false
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

17. Object.isFrozen()–判断对象是否被冻结

语法

Object.isFrozen(obj)
1

参数

• obj 被检测的对象。

返回值
表示给定对象是否被冻结的Boolean。

描述
一个对象是冻结的是指它不可扩展，所有属性都是不可配置的，且所有数据属性（即没有 getter 或 setter 组件的访问器的属性）都是不可写的。

示例

// 一个对象默认是可扩展的，所以它也是非冻结的。
Object.isFrozen({}); // === false

// 一个不可扩展的空对象同时也是一个冻结对象。
var vacuouslyFrozen = Object.preventExtensions({});
Object.isFrozen(vacuouslyFrozen) //=== true;

// 一个非空对象默认也是非冻结的。
var oneProp = { p: 42 };
Object.isFrozen(oneProp) //=== false

// 让这个对象变的不可扩展，并不意味着这个对象变成了冻结对象，
// 因为 p 属性仍然是可以配置的 (而且可写的).
Object.preventExtensions(oneProp);
Object.isFrozen(oneProp) //=== false

// 此时，如果删除了这个属性，则它会成为一个冻结对象。
delete oneProp.p;
Object.isFrozen(oneProp) //=== true

// 一个不可扩展的对象，拥有一个不可写但可配置的属性，则它仍然是非冻结的。
var nonWritable = { e: "plep" };
Object.preventExtensions(nonWritable);
Object.defineProperty(nonWritable, "e", { writable: false }); // 变得不可写
Object.isFrozen(nonWritable) //=== false

// 把这个属性改为不可配置，会让这个对象成为冻结对象。
Object.defineProperty(nonWritable, "e", { configurable: false }); // 变得不可配置
Object.isFrozen(nonWritable) //=== true

// 一个不可扩展的对象，拥有一个不可配置但可写的属性，则它仍然是非冻结的。
var nonConfigurable = { release: "the kraken!" };
Object.preventExtensions(nonConfigurable);
Object.defineProperty(nonConfigurable, "release", { configurable: false });
Object.isFrozen(nonConfigurable) //=== false

// 把这个属性改为不可写，会让这个对象成为冻结对象。
Object.defineProperty(nonConfigurable, "release", { writable: false });
Object.isFrozen(nonConfigurable) //=== true

// 一个不可扩展的对象，值拥有一个访问器属性，则它仍然是非冻结的。
var accessor = { get food() { return "yum"; } };
Object.preventExtensions(accessor);
Object.isFrozen(accessor) //=== false

// ...但把这个属性改为不可配置，会让这个对象成为冻结对象。
Object.defineProperty(accessor, "food", { configurable: false });
Object.isFrozen(accessor) //=== true

// 使用 Object.freeze 是冻结一个对象最方便的方法。
var frozen = { 1: 81 };
Object.isFrozen(frozen) //=== false
Object.freeze(frozen);
Object.isFrozen(frozen) //=== true

// 一个冻结对象也是一个密封对象。
Object.isSealed(frozen) //=== true

// 当然，更是一个不可扩展的对象。
Object.isExtensible(frozen) //=== false
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

18. Object.prototype.isPrototypeOf()–测试对象是否存在于另一个原型链上

isPrototypeOf() 方法用于测试一个对象是否存在于另一个对象的原型链上。

语法

prototypeObj.isPrototypeOf(object)
1

参数

object 在该对象的原型链上搜寻

返回值
Boolean，表示调用对象是否在另一个对象的原型链上。

描述
isPrototypeOf() 方法允许你检查一个对象是否存在于另一个对象的原型链上。

示例

function Foo() {}
function Bar() {}
function Baz() {}

Bar.prototype = Object.create(Foo.prototype);
Baz.prototype = Object.create(Bar.prototype);

var baz = new Baz();

console.log(Baz.prototype.isPrototypeOf(baz)); // true
console.log(Bar.prototype.isPrototypeOf(baz)); // true
console.log(Foo.prototype.isPrototypeOf(baz)); // true
console.log(Object.prototype.isPrototypeOf(baz)); // true
1
2
3
4
5
6
7
8
9
10
11
12
13

19. Object.isSealed()–判断对象是否被密封

语法

Object.isSealed(obj)
1

参数

• obj 要被检查的对象。

返回值
表示给定对象是否被密封的一个Boolean 。

描述
如果这个对象是密封的，则返回 true，否则返回 false。密封对象是指那些不可 扩展 的，且所有自身属性都不可配置且因此不可删除（但不一定是不可写）的对象。

示例

// 新建的对象默认不是密封的。
var empty = {};
Object.isSealed(empty); // === false

// 如果你把一个空对象变的不可扩展，则它同时也会变成个密封对象。
Object.preventExtensions(empty);
Object.isSealed(empty); // === true

// 但如果这个对象不是空对象，则它不会变成密封对象，因为密封对象的所有自身属性必须是不可配置的。
var hasProp = { fee: "fie foe fum" };
Object.preventExtensions(hasProp);
Object.isSealed(hasProp); // === false

// 如果把这个属性变的不可配置，则这个属性也就成了密封对象。
Object.defineProperty(hasProp, 'fee', {
  configurable: false
});
Object.isSealed(hasProp); // === true

// 最简单的方法来生成一个密封对象，当然是使用 Object.seal.
var sealed = {};
Object.seal(sealed);
Object.isSealed(sealed); // === true

// 一个密封对象同时也是不可扩展的。
Object.isExtensible(sealed); // === false

// 一个密封对象也可以是一个冻结对象，但不是必须的。
Object.isFrozen(sealed); // === true ，所有的属性都是不可写的
var s2 = Object.seal({ p: 3 });
Object.isFrozen(s2); // === false， 属性"p"可写

var s3 = Object.seal({ get p() { return 0; } });
Object.isFrozen(s3); // === true ，访问器属性不考虑可写不可写，只考虑是否可配置
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
29
30
31
32
33
34

20. Object.keys()–返回对象所有属性名

Object.keys() 方法会返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和正常循环遍历该对象时返回的顺序一致。

语法

Object.keys(obj)
1

参数

• obj 要返回其枚举自身属性的对象。

返回值
一个表示给定对象的所有可枚举属性的字符串数组。

描述
Object.keys 返回一个所有元素为字符串的数组，其元素来自于从给定的 object 上面可直接枚举的属性。这些属性的顺序与手动遍历该对象属性时的一致。

示例

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

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

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

var myObj = Object.create({}, {
  getFoo: {
    value: function () { return this.foo; }
  }
});
myObj.foo = 1;
console.log(Object.keys(myObj)); // console: ['foo']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

21. Object.preventExtensions()–使对象不可扩展

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

const object1 = {};

Object.preventExtensions(object1);

try {
  Object.defineProperty(object1, 'property1', {
    value: 42
  });
} catch (e) {
  console.log(e);
  // expected output: TypeError: Cannot define property property1, object is not extensible
}
1
2
3
4
5
6
7
8
9
10
11
12

语法

Object.preventExtensions(obj)
1

参数

• obj 将要变得不可扩展的对象。

返回值
已经不可扩展的对象。

示例

// Object.preventExtensions 将原对象变的不可扩展，并且返回原对象。
var obj = {};
var obj2 = Object.preventExtensions(obj);
obj === obj2;  // true

// 字面量方式定义的对象默认是可扩展的。
var empty = {};
Object.isExtensible(empty) //=== true

// ...但可以改变。
Object.preventExtensions(empty);
Object.isExtensible(empty) //=== false

// 使用 Object.defineProperty 方法为一个不可扩展的对象添加新属性会抛出异常。
var nonExtensible = { removable: true };
Object.preventExtensions(nonExtensible);
Object.defineProperty(nonExtensible, "new", { value: 8675309 }); // 抛出 TypeError 异常

// 在严格模式中，为一个不可扩展对象的新属性赋值会抛出 TypeError 异常。
function fail()
{
  "use strict";
  nonExtensible.newProperty = "FAIL"; // throws a TypeError
}
fail();
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

22. Object.prototype.propertyIsEnumerable()–判断属性是否可枚举

propertyIsEnumerable() 方法返回一个布尔值，表示指定的属性是否可枚举。

const object1 = {};
const array1 = [];
object1.property1 = 42;
array1[0] = 42;

console.log(object1.propertyIsEnumerable('property1'));
//  true

console.log(array1.propertyIsEnumerable(0));
//  true

console.log(array1.propertyIsEnumerable('length'));
//  false
1
2
3
4
5
6
7
8
9
10
11
12
13

语法

obj.propertyIsEnumerable(prop)
1

参数

• prop 需要测试的属性名。

返回值
用来表示指定的属性名是否可枚举的布尔值。

描述
每个对象都有一个 propertyIsEnumerable 方法。此方法可以确定对象中指定的属性是否可以被 for…in 循环枚举，但是通过原型链继承的属性除外。如果对象没有指定的属性，则此方法返回 false。

示例

var o = {};
var a = [];
o.prop = 'is enumerable';
a[0] = 'is enumerable';

o.propertyIsEnumerable('prop'); // 返回 true
a.propertyIsEnumerable(0);      // 返回 true
1
2
3
4
5
6
7

23. Object.seal()–封闭对象

Object.seal()方法封闭一个对象，阻止添加新属性并将所有现有属性标记为不可配置。当前属性的值只要原来是可写的就可以改变。

const object1 = {
  property1: 42
};

Object.seal(object1);
object1.property1 = 33;
console.log(object1.property1);
//33

delete object1.property1; // cannot delete when sealed
console.log(object1.property1);
//  33
1
2
3
4
5
6
7
8
9
10
11
12

语法

Object.seal(obj)
1

参数

• obj 将要被密封的对象。

返回值
被密封的对象。

描述
通常，一个对象是可扩展的（可以添加新的属性）。密封一个对象会让这个对象变的不能添加新属性，且所有已有属性会变的不可配置。属性不可配置的效果就是属性变的不可删除，以及一个数据属性不能被重新定义成为访问器属性，或者反之。但属性的值仍然可以修改。尝试删除一个密封对象的属性或者将某个密封对象的属性从数据属性转换成访问器属性，结果会静默失败或抛出TypeError（在严格模式 中最常见的，但不唯一）。

不会影响从原型链上继承的属性。但 proto ( Deprecated ) 属性的值也会不能修改。

返回被密封对象的引用。

24. Object.setPrototypeOf()–指定对象的原型

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

语法

Object.setPrototypeOf(obj, prototype)
1

参数

• obj 要设置其原型的对象。
• prototype 该对象的新原型 (一个对象 或 null).

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

Object.setPrototypeOf() 是 ECMAScript 6 最新草案中的方法，相对于 Object.prototype.proto (en-US)，它被认为是修改对象原型更合适的方法

25. Object.prototype.toLocaleString()–返回该对象的字符串表示

toLocaleString() 方法返回一个该对象的字符串表示。此方法被用于派生对象为了特定语言环境的目的（locale-specific purposes）而重载使用。

语法

obj.toLocaleString();
1

返回值
表示对象的字符串。

描述
Object toLocaleString 返回调用 toString() 的结果。

该函数提供给对象一个通用的toLocaleString 方法，即使不是全部都可以使用它。

26. Object.prototype.toString()–返回值表示该对象的字符串

function Dog(name) {
  this.name = name;
}

const dog1 = new Dog('Gabby');

Dog.prototype.toString = function dogToString() {
  return `${this.name}`;
};

console.log(dog1.toString());
// "Gabby"
1
2
3
4
5
6
7
8
9
10
11
12

描述
每个对象都有一个 toString() 方法，当该对象被表示为一个文本值时，或者一个对象以预期的字符串方式引用时自动调用。默认情况下，toString() 方法被每个 Object 对象继承。如果此方法在自定义对象中未被覆盖，toString() 返回 “[object type]”，其中 type 是对象的类型。以下代码说明了这一点：

var o = new Object();
o.toString(); // 返回 [object Object]
1
2

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

语法

object.valueOf()
1

描述

JavaScript 调用 valueOf 方法将对象转换为原始值。你很少需要自己调用 valueOf 方法；当遇到要预期的原始值的对象时，JavaScript 会自动调用它。

默认情况下，valueOf 方法由 Object 后面的每个对象继承。 每个内置的核心对象都会覆盖此方法以返回适当的值。如果对象没有原始值，则 valueOf 将返回对象本身。

JavaScript 的许多内置对象都重写了该函数，以实现更适合自身的功能需要。因此，不同类型对象的 valueOf() 方法的返回值和返回值类型均可能不同。

你可以在自己的代码中使用 valueOf 将内置对象转换为原始值。创建自定义对象时，可以覆盖 Object.prototype.valueOf() 来调用自定义方法，而不是默认 Object 方法。

28. Object.values()–返回对象所有属性值

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

语法

Object.values(obj)
1

参数

• obj 被返回可枚举属性值的对象。

返回值
一个包含对象自身的所有可枚举属性值的数组。

描述
Object.values()返回一个数组，其元素是在对象上找到的可枚举属性值。属性的顺序与通过手动循环对象的属性值所给出的顺序相同。

示例

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

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

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

var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } });
my_obj.foo = 'bar';
console.log(Object.values(my_obj)); // ['bar']

console.log(Object.values('foo')); // ['f', 'o', 'o']
1
2
3
4
5
6
7
8
9
10
11
12
13
14

参考MDN