JavaScript之Object方法属性

参考：
https://juejin.cn/post/6844904094730027015 。
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object 。

对象方法

创建对象

Object.fromEntries();

Object.fromEntries()

Object.fromEntries() 方法用于把可迭代对象转换为一个对象，返回转换后新生成的对象。

接收一个参数：

• iterable（必需）：可迭代对象，其元素为键值对（如，两个元素的数组等）。

const map = new Map([
    ["foo", "bar"],
    ["baz", 42],
  ]),
  arr = [
    ["0", "a"],
    ["1", "b"],
    ["2", "c"],
  ];
Object.fromEntries(map); // { foo: "bar", baz: 42 }
Object.fromEntries(arr); // { 0: "a", 1: "b", 2: "c" }

检测对象

Object.is();
Object.isExtensible();
Object.isSealed();
Object.isFrozen();

Object.is()

Object.is() 方法用于判断两个值是否为同一个值，返回布尔值。

Object.is() 方法和===运算符几乎相等，除了：

• Object.is() 方法将数字 -0 和 +0 视为不相等 ，将 NaN 与 NaN 视为相等。
• ===运算符和==运算符都将数字 -0 和 +0 视为相等 ，将 NaN 与 NaN 视为不相等。

接收两个参数：

• value1（必需）：被比较的第一个值。
• value2（必需）：被比较的第二个值。

Object.isExtensible()

Object.isExtensible() 方法用于判断一个对象是否可扩展（是否可以在它上面添加新属性），返回布尔值。

默认情况下，对象是可扩展的：即可以为他们添加新的属性。以及它们的 proto 属性可以被更改。Object.preventExtensions()、Object.seal()、Object.freeze() 方法都可以标记一个对象为不可扩展。

接收一个参数：

• obj（必需）：被检测的对象。

Object.isSealed()

Object.isSealed() 方法用于判断一个对象是否被密封，返回布尔值。

一个对象是密封的是指它不可扩展，且所有自身属性都不可配置，故不可删除（但不一定不可写）的对象。

接收一个参数：

• obj（必需）：被检测的对象。

Object.isFrozen()

Object.isFrozen() 方法用于判断一个对象是否被冻结，返回布尔值。

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

接收一个参数：

• obj（必需）：被检测的对象。

操作对象

Object.assign();
Object.create();
Object.preventExtensions();
Object.seal();
Object.freeze();

Object.assign()

Object.assign() 方法用于把一个或多个源对象的所有 可枚举属性 从分配到目标对象，返回目标对象。
（浅拷贝一个或多个源对象分配到目标对象）

接收参数：

• target（必需）：目标对象。
• sources（至少一个）：源对象，可以有多个。

let aaa = { score: 1, name: "Jeff" };

Object.assign({}, aaa, { score: 2 }); // {score: 2, name: 'Jeff'}
console.log(aaa); // {score: 1, name: 'Jeff'}

let bbb = { ...aaa, score: 2 }; // 和上面使用 Object.assign() 效果一样。
console.log(aaa); // {score: 1, name: 'Jeff'}
console.log(bbb); // {score: 2, name: 'Jeff'}

Object.assign(aaa, { score: 2 }); // {score: 2, name: 'Jeff'}
console.log(aaa); // {score: 2, name: 'Jeff'}

Object.create()

Object.create() 方法用于使用指定的原型对象和属性创建一个新对象，返回创建的新对象。
（原型式继承，原型模式的封装）

接收两个参数：

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

Object.preventExtensions()

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

如果一个对象可以添加新的属性，则这个对象是可扩展的。Object.preventExtensions() 将对象标记为不再可扩展，这样它将永远不会具有它被标记为不可扩展时持有的属性之外的属性。注意一般来说，不可扩展对象的属性可能仍然可被删除。尝试将新属性添加到不可扩展对象将静默失败或抛出 TypeError（最常见的情况是 strict mode 中，但不排除其他情况）。

Object.preventExtensions() 方法仅阻止添加自身的属性。但是其对象类型的原型依然可以添加新的属性。该方法使得目标对象的 [[prototype]] 不可变；任何重新赋值 [[prototype]] 操作都会抛出 TypeError 。这种行为只针对内部的 [[prototype]] 属性， 目标对象的其它属性将保持可变。

一旦将对象变为不可扩展的对象，就再也不能使其可扩展。

接收一个参数：

• obj（必需）：被操作的对象。

Object.seal()

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

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

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

接收一个参数：

• obj（必需）：被操作的对象。

Object.freeze()

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

被冻结对象自身的所有属性都不可能以任何方式被修改。任何的修改尝试都会失败，无论是静默地还是通过抛出 TypeError 异常（最常见但不仅限于 strict mode）。

数据属性的值不可更改，访问器属性（有 getter 和 setter）也同样（但由于是函数调用，给人的错觉是还是可以修改这个属性）。如果一个属性的值是个对象，则这个对象中的属性是可以修改的，除非它也是个冻结对象。数组作为一种对象，被冻结，其元素不能被修改。没有数组元素可以被添加或移除。

接收一个参数：

• obj（必需）：被操作的对象。

查看对象

Object.setPrototypeOf();
Object.getPrototypeOf();
Object.defineProperty();
Object.defineProperties();
Object.hasOwn();
Object.getOwnPropertyDescriptor();
Object.getOwnPropertyDescriptors();
Object.getOwnPropertyNames();
Object.getOwnPropertySymbols();
Object.getPrototypeOf();
Object.keys();
Object.values();
Object.entries();

Object.setPrototypeOf()

Object.setPrototypeOf() 方法用于为指定对象设置原型对象，返回指定对象。

Object.getPrototypeOf()

Object.getPrototypeOf() 方法用于得到指定对象的原型对象，返回指定对象的原型对象。

Object.defineProperty()

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

接收三个参数：

• obj（必需）：要定义或修改属性的对象。
• prop（必需）：要定义或修改的属性的名称或 Symbol 类型。
• descriptor（必需）：要定义或修改的属性描述符。

const obj = {};
Object.defineProperty(obj, "property1", { value: 42, writable: false });
// {property1: 42}

Object.defineProperties()

Object.defineProperties() 方法用于直接在指定对象上定义多个新属性，或者修改多个指定对象的现有属性，并返回此对象。

接收两个参数：

• obj（必需）：要在其上定义或修改属性的对象。
• props（必需）：要定义其可枚举属性或修改的属性描述符的对象。对象中存在的属性描述符共有两种：数据描述符和访问器描述符。

const obj = {};
Object.defineProperties(obj, {
  property1: { value: true, writable: true },
  property2: { value: "Hello", writable: false },
});
// {property1: true, property2: 'Hello'}

Object.hasOwn()

实验中，类似于 Object.prototype.hasOwnProperty() 方法。
Object.hasOwn() 方法用于判断 指定对象自身上 是否具有指定的属性，返回布尔值。
（可枚举属性 和 不可枚举属性 都可以判断）
（in 操作符会在可以通过对象访问指定属性时返回 true，而无论这个属性是在实例上还是在原型上）

接收两个参数：

• obj（必需）：用于判断的指定对象。
• props（必需）：用于判断的指定属性。

const o = {};
Object.defineProperty(o, "oa", { value: 111, writable: false });
Object.defineProperty(o, "ob", { value: 222, writable: true });
o.oc = 333;
const obj = Object.create(o);
Object.defineProperty(obj, "a", { value: 444, writable: false });
Object.defineProperty(obj, "b", { value: 555, writable: true });
obj.c = 666;

obj; // {c: 666, a: 444, b: 555}
Object.hasOwn(obj, "oa"); // false
Object.hasOwn(obj, "ob"); // false
Object.hasOwn(obj, "oc"); // false
Object.hasOwn(obj, "a"); // true
Object.hasOwn(obj, "b"); // true
Object.hasOwn(obj, "c"); // true

obj.oa = 777;
obj.ob = 888;
obj.oc = 999;

obj; // {c: 666, ob: 888, oc: 999, a: 444, b: 555}
Object.hasOwn(obj, "oa"); // false
Object.hasOwn(obj, "ob"); // true
Object.hasOwn(obj, "oc"); // true
Object.hasOwn(obj, "a"); // true
Object.hasOwn(obj, "b"); // true
Object.hasOwn(obj, "c"); // true

Object.getOwnPropertyNames()

Object.getOwnPropertyNames() 方法用于返回一个数组，其包含 指定对象自身上的 所有的属性名。
（可枚举属性 和 不可枚举属性 都会返回）

const o = {};
Object.defineProperty(o, "oa", { value: 111, writable: false });
Object.defineProperty(o, "ob", { value: 222, writable: true });
o.oc = 333;
const obj = Object.create(o);
Object.defineProperty(obj, "a", { value: 444, writable: false });
Object.defineProperty(obj, "b", { value: 555, writable: true });
obj.c = 666;

obj; // {c: 666, a: 444, b: 555}
Object.getOwnPropertyNames(obj); // ['a', 'b', 'c']

obj.oa = 777;
obj.ob = 888;
obj.oc = 999;

obj; // {c: 666, ob: 888, oc: 999, a: 444, b: 555}
Object.getOwnPropertyNames(obj); // ['a', 'b', 'c', 'ob', 'oc']

Object.getOwnPropertySymbols()

Object.getOwnPropertySymbols() 方法用于返回一个数组，其包含 指定对象自身上的 所有的符号属性名。

const o = {};
Object.defineProperty(o, "oa", { value: 111, writable: false });
Object.defineProperty(o, "ob", { value: 222, writable: true });
o.oc = 333;
const obj = Object.create(o);
Object.defineProperty(obj, "a", { value: 444, writable: false });
Object.defineProperty(obj, "b", { value: 555, writable: true });
obj.c = 666;

obj; // {c: 666, a: 444, b: 555}
Object.getOwnPropertySymbols(obj); // []

obj.oa = 777;
obj.ob = 888;
obj.oc = 999;

obj; // {c: 666, ob: 888, oc: 999, a: 444, b: 555}
Object.getOwnPropertyNames(obj); // []

Object.getOwnPropertyDescriptor()

Object.getOwnPropertyDescriptor() 方法用于返回 指定对象自身上的 指定的属性配置。
（可枚举属性 和 不可枚举属性 都可以返回）

Object.getOwnPropertyDescriptors()

Object.getOwnPropertyDescriptors() 方法用于返回 指定对象自身上的 所有的属性配置。
（可枚举属性 和 不可枚举属性 都会返回）

Object.keys()

Object.keys() 方法返回一个数组，其包含了 指定对象自身上的 可枚举属性的 属性名。数组中值的排列顺序和使用 for-in 循环遍历该对象时返回的顺序一致（区别是 for-in 循环还会枚举原型链中的属性）。

const o = {};
Object.defineProperty(o, "oa", { value: 111, writable: false });
Object.defineProperty(o, "ob", { value: 222, writable: true });
o.oc = 333;
const obj = Object.create(o);
Object.defineProperty(obj, "a", { value: 444, writable: false });
Object.defineProperty(obj, "b", { value: 555, writable: true });
obj.c = 666;

obj; // {c: 666, a: 444, b: 555}
Object.keys(obj); // ['c']
for (const aaa of Object.keys(obj)) {
  console.log(aaa);
}
// c
for (const bbb in obj) {
  console.log(bbb);
}
// c
// oc

obj.oa = 777;
obj.ob = 888;
obj.oc = 999;

obj; // {c: 666, ob: 888, oc: 999, a: 444, b: 555}
Object.keys(obj); // ['c', 'ob', 'oc']
for (const aaa of Object.keys(obj)) {
  console.log(aaa);
}
// c
// ob
// oc
for (const bbb in obj) {
  console.log(bbb);
}
// c
// ob
// oc

Object.values()

Object.values() 方法返回一个数组，其包含了 指定对象自身上的 可枚举属性的 属性值。数组中值的排列顺序和使用 for-in 循环遍历该对象时返回的顺序一致（区别是 for-in 循环还会枚举原型链中的属性）。

const o = {};
Object.defineProperty(o, "oa", { value: 111, writable: false });
Object.defineProperty(o, "ob", { value: 222, writable: true });
o.oc = 333;
const obj = Object.create(o);
Object.defineProperty(obj, "a", { value: 444, writable: false });
Object.defineProperty(obj, "b", { value: 555, writable: true });
obj.c = 666;

obj; // {c: 666, a: 444, b: 555}
Object.values(obj); // [666]
for (const aaa of Object.values(obj)) {
  console.log(aaa);
}
// 666

obj.oa = 777;
obj.ob = 888;
obj.oc = 999;

obj; // {c: 666, ob: 888, oc: 999, a: 444, b: 555}
Object.values(obj); // [666, 888, 999]
for (const aaa of Object.values(obj)) {
  console.log(aaa);
}
// 666
// 888
// 999

Object.entries()

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

const o = {};
Object.defineProperty(o, "oa", { value: 111, writable: false });
Object.defineProperty(o, "ob", { value: 222, writable: true });
o.oc = 333;
const obj = Object.create(o);
Object.defineProperty(obj, "a", { value: 444, writable: false });
Object.defineProperty(obj, "b", { value: 555, writable: true });
obj.c = 666;

obj; // {c: 666, a: 444, b: 555}
Object.entries(obj); // [['c', 666]]
for (const aaa of Object.entries(obj)) {
  console.log(aaa);
}
// ['c', 666]

obj.oa = 777;
obj.ob = 888;
obj.oc = 999;

obj; // {c: 666, ob: 888, oc: 999, a: 444, b: 555}
Object.entries(obj); // [['c', 666], ['ob', 888], ['oc', 999]]
for (const aaa of Object.entries(obj)) {
  console.log(aaa);
}
// ['c', 666]
// ['ob', 888]
// ['oc', 999]

对象实例属性

Object.prototype.constructor;
Object.prototype.__proto__;

constructor

constructor 属性用于返回或设置原型对象对应的构造函数。

__proto__

__proto__ 属性用于返回或设置创建该对象的构造函数的原型对象。
（建议用 Object.getPrototypeOf() 方法替换该属性）

对象实例方法

Object.prototype.isPrototypeOf();
Object.prototype.hasOwnProperty();
Object.prototype.propertyIsEnumerable();
Object.prototype.valueOf();
Object.prototype.toString();
Object.prototype.toLocaleString();

isPrototypeOf()

isPrototypeOf() 方法用于判断 指定对象 是否在给定对象的原型链上，返回布尔值。

const o = {};
Object.defineProperty(o, "oa", { value: 111, writable: false });
Object.defineProperty(o, "ob", { value: 222, writable: true });
o.oc = 333;
const obj = Object.create(o);
Object.defineProperty(obj, "a", { value: 444, writable: false });
Object.defineProperty(obj, "b", { value: 555, writable: true });
obj.c = 666;

o.isPrototypeOf(obj); // true
obj.isPrototypeOf(o); // false

hasOwnProperty()

hasOwnProperty() 方法用于判断 指定对象自身上 是否具有指定的属性，返回布尔值。
（可枚举属性 和 不可枚举属性 都可以判断）
（in 操作符会在可以通过对象访问指定属性时返回 true，而无论这个属性是在实例上还是在原型上）

const o = {};
Object.defineProperty(o, "oa", { value: 111, writable: false });
Object.defineProperty(o, "ob", { value: 222, writable: true });
o.oc = 333;
const obj = Object.create(o);
Object.defineProperty(obj, "a", { value: 444, writable: false });
Object.defineProperty(obj, "b", { value: 555, writable: true });
obj.c = 666;

obj; // {c: 666, a: 444, b: 555}
obj.hasOwnProperty("oa"); // false
obj.hasOwnProperty("ob"); // false
obj.hasOwnProperty("oc"); // false
obj.hasOwnProperty("a"); // true
obj.hasOwnProperty("b"); // true
obj.hasOwnProperty("c"); // true

obj.oa = 777;
obj.ob = 888;
obj.oc = 999;

obj; // {c: 666, ob: 888, oc: 999, a: 444, b: 555}
obj.hasOwnProperty("oa"); // false
obj.hasOwnProperty("ob"); // true
obj.hasOwnProperty("oc"); // true
obj.hasOwnProperty("a"); // true
obj.hasOwnProperty("b"); // true
obj.hasOwnProperty("c"); // true

propertyIsEnumerable()

propertyIsEnumerable() 方法用于判断 指定对象自身上 指定的属性是否可被枚举，返回布尔值。

valueOf()

valueOf() 方法返回指定对象的原始值。

toString()

toString() 方法返回指定对象的字符串形式。

可以通过 toString() 来获取每个对象的类型。为了每个对象都能通过 Object.prototype.toString() 来检测，需要以 Function.prototype.call() 或者 Function.prototype.apply() 的形式来调用，传递要检查的对象作为第一个参数，称为 thisArg。

toLocaleString()

toLocaleString() 方法用于反映对象所在的本地化执行环境，返回一个表示该对象的字符串。