Object方法

js中object是一个很常用的类型，但是今天研究才发现，这个类型使用起来有很多细节，这里挑一些常用的方法进行分享

文献参考：Mdn Object

构造函数行为

我们在使用

const obj = new Object()
// {}

创建对象时，会返回一个空对象，但是，如果是以下值呢？

const obj1 = new Object(1)
const obj2 = new Object('a')

规则如下：

new Object(value)

如果 value 是对象，则直接返回这个对象。

如果 value 是基本类型（string、number、boolean、bigint、symbol），则会装箱（Boxing），返回对应的包装对象。

// Number {1}
// String {"a"}

请注意，这个值和原先value不严格相等，因为被包装了一层。

如果 value 是 null 或 undefined，则返回一个空对象 {}。

静态方法

Object.assign

将一个或者多个源对象中所有可枚举的自有属性复制到目标对象，并返回修改后的目标对象。

Object.assign(target, ...sources)

注意复制是浅拷贝，仅会复制引用值，且会基于target对象修改值而不是返回一个新的对象

非对象的合并

首先，target参数不能是null或undefined，否则会直接报错，另外基本类型会被包装。

对于source，遵循以下规则：

null、undefined → 直接忽略（不会报错！不会报错！不会报错！和target参数有区别）

其它基本类型 → 先装箱

然后只复制自身可枚举属性（这个规则意味着只有String类型会被保留下来，且非常特殊：

console.log(Object.assign({}, "abc"));

// {
//   0: "a",
//   1: "b",
//   2: "c"
// }

因为：

new String("abc")

// {
//   "0": "a",
//   "1": "b",
//   "2": "c",
//  length: 3
// }

其中除了length不可枚举其他属性都是可枚举的）

举个例子：

const v1 = "abc";
const v2 = true;
const v3 = 10;
const v4 = Symbol("foo");

const obj = Object.assign({}, v1, null, v2, undefined, v3, v4);
// 基本类型将被封装，null 和 undefined 将被忽略。
// 注意，只有字符串封装对象才拥有可枚举的自有属性。
console.log(obj); // { "0": "a", "1": "b", "2": "c" }

异常会中断后续的复制

异常会让本方法直接抛出错误，但是target已被修改的属性值不会被还原，参见：

const target = Object.defineProperty({}, "foo", {
  value: 1,
  writable: false,
}); // target.foo 是一个只读属性

Object.assign(target, { bar: 2 }, { foo2: 3, foo: 3, foo3: 3 }, { baz: 4 });
// TypeError: "foo" is read-only
// 这个异常会在给 target.foo 赋值的时候抛出

console.log(target.bar); // 2，第一个源对象成功复制。
console.log(target.foo2); // 3，第二个源对象的第一个属性也成功复制。
console.log(target.foo); // 1，异常在这里被抛出
console.log(target.foo3); // undefined，属性赋值已经结束，foo3 不会被复制
console.log(target.baz); // undefined，第三个源对象也不会被复制

Object.create

以一个现有对象作为原型，创建一个新对象。

o = {};
// 等价于：
o = Object.create(Object.prototype);

o = Object.create(Object.prototype, {
  // foo 是一个常规数据属性
  foo: {
    writable: true,
    configurable: true,
    value: "hello",
  },
  // bar 是一个访问器属性
  bar: {
    configurable: false,
    get() {
      return 10;
    },
    set(value) {
      console.log("Setting `o.bar` to", value);
    },
  },
});

// 创建一个新对象，它的原型是一个新的空对象，并添加一个名为 'p'，值为 42 的属性。
o = Object.create({}, { p: { value: 42 } });

实际运用时，可以用来复刻new功能：

function Constructor() {}
o = new Constructor();
// 等价于：
o = Object.create(Constructor.prototype);

Object.defineProperties

Object.defineProperties(obj, props)

首先需要说明：对象中每个属性都会在访问器属性或数据属性中选择一个，而不能同时属于两者

对每个属性支持修改的描述符：

value: 数据属性、非访问器属性，修改属性对应的值

writable: 数据属性、非访问器属性，是否允许修改 value

get: 非数据属性，访问器属性，读取属性时执行的函数

set: 非数据属性，访问器属性，给属性赋值时执行的函数

enumerable: 数据属性、访问器属性，是否会出现在 Object.keys、for...in、Object.assign、对象展开等需要可枚举的遍历操作中

configurable: 数据属性、访问器属性，是否允许删除属性、重新定义属性描述符，以及在数据属性和访问器属性之间转换

一个特殊的例子（以defineProperty举例，其实两者是一样的）：

Object.defineProperty(obj, "a", {
  value: 1,
  writable: true,
  configurable: false
});

则：

可以通过赋值修改 value（因为 writable: true）

可以把 writable 从 true 改成 false。

不能再把 writable 从 false 改回 true。

不能修改 enumerable。

不能删除该属性。

不能把它改成访问器属性（或反过来）。

Object.defineProperty

defineProperties的单属性设置版本，除传参不同外其余基本一致

Object.defineProperty(obj, prop, descriptor)

Object.entries

返回一个数组，包含给定对象自有的可枚举字符串键属性的键值对

Object.entries(obj)

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

console.log(Object.entries(object1))

// Logs
// Array [Array ["a", "somestring"], Array ["b", 42]]

Object.freeze

可以使一个对象被冻结。冻结对象可以防止扩展，并使现有的属性不可写入和不可配置。被冻结的对象不能再被更改：不能添加新的属性，不能移除现有的属性，不能更改它们的可枚举性、可配置性、可写性或值，对象的原型也不能被重新指定。freeze() 返回与传入的对象相同的对象

Object.freeze(obj)

但是注意：这种冻结机制是一种浅冻结，类似浅拷贝。

执行之后：

不能修改属性

不能新增属性

不能删除属性

不能重新配置属性

Object.fromEntries

将键值对列表转换为一个对象

Object.getOwnPropertyDescriptor

返回一个对象，该对象描述给定对象上特定属性（即直接存在于对象上而不在对象的原型链中的属性）的配置。返回的对象是可变的，但对其进行更改不会影响原始属性的配置。

Object.getOwnPropertyDescriptors

Object.getOwnPropertyDescriptor的多属性版，返回所有属性的描述符，以对象的形式返回

Object.getOwnPropertyNames

返回一个数组，其包含给定对象中所有自有属性（包括不可枚举属性，但不包括使用 symbol 值作为名称的属性）注意和Object.keys()作出区别（keys只返回可枚举键数组）

Object.getOwnPropertySymbols

返回一个包含给定对象所有自有 Symbol 属性的数组

Object.getPrototypeOf

静态方法返回指定对象的原型（即内部 [[Prototype]] 属性的值）

Object.hasOwn

如果指定的对象自身有指定的属性，则静态方法 Object.hasOwn() 返回 true。如果属性是继承的或者不存在，该方法返回 false

Object.is

判断两个值是否相等，区别于==，也区别于===，在大部分非特殊值的表现上一致但是其他值略有差异

Object.is(target1, target2)

// 案例 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
const foo = { a: 1 };
const bar = { a: 1 };
const sameFoo = foo;
Object.is(foo, foo); // true
Object.is(foo, bar); // false
Object.is(foo, sameFoo); // true

// 案例 2: 带符号的 0
Object.is(0, -0); // false
Object.is(+0, -0); // false
Object.is(-0, -0); // true

// 案例 3: NaN
Object.is(NaN, 0 / 0); // true
Object.is(NaN, Number.NaN); // true

Object.isExtensible

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

Object.isFrozen

判断一个对象是否被冻结。

Object.isSealed

判断一个对象是否被密封。

Object.keys

返回一个由给定对象自身的可枚举的字符串键属性名组成的数组。

Object.preventExtensions

可以防止新属性被添加到对象中（即防止该对象被扩展）。它还可以防止对象的原型被重新指定。

Object.seal

密封一个对象。密封一个对象会阻止其扩展并且使得现有属性不可配置。密封对象有一组固定的属性：不能添加新属性、不能删除现有属性或更改其可枚举性和可配置性、不能重新分配其原型。只要现有属性的值是可写的，它们仍然可以更改。seal() 返回传入的同一对象。

对比freeze，seal没有另者那么严格，seal的限制：

可以修改已有属性的值（前提是属性本身是 writable: true）

不能新增属性

不能删除属性

不能重新配置属性（因为所有属性都会变成 configurable: false）

Object.setPrototypeOf

Object.setPrototypeOf() 静态方法可以将一个指定对象的原型（即内部的 [[Prototype]] 属性）设置为另一个对象或者 null。

在mdn介绍中不推荐使用这个方法指定原型因为性能问题，更推荐使用Object.create()

Object.values

返回一个给定对象的自有可枚举字符串键属性值组成的数组

实例方法

Object.prototype.hasOwnProperty

返回一个布尔值，表示对象自有属性（而不是继承来的属性）中是否具有指定的属性。

在支持 Object.hasOwn 的浏览器中，建议使用 Object.hasOwn()，而非 hasOwnProperty()。

Object.prototype.isPrototypeOf

用于检查一个对象是否存在于另一个对象的原型链中。

const a = {}
const b = Object.create(a)

console.log(a.isPrototypeOf(b))

// Logs
// true

Object.prototype.propertyIsEnumerable

返回一个布尔值，表示指定的属性是否是对象的可枚举自有属性

Object.prototype.toLocaleString

Object.prototype.toString

Object.prototype.valueOf