总览 - vvll.net

总览

在 TypeScript 中，Object 是 JavaScript 中的基本对象类型，包含多种方法来操作和处理对象。

以下是 Object 的常用方法及其描述：

`Object` 类的静态方法

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

用于将一个或多个源对象的所有可枚举属性复制到目标对象中，返回目标对象。

const target = { a: 1 };
const source = { b: 2, c: 3 };
const result = Object.assign(target, source);
console.log(result); // 输出: { a: 1, b: 2, c: 3 }

Object.create(proto, [propertiesObject])：

使用指定的原型对象和可选的属性描述符创建一个新对象。

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

Object.defineProperty(obj, prop, descriptor)：
- 直接在对象上定义一个新属性，或者修改对象的现有属性，并返回该对象。
- ```
const obj = {};
Object.defineProperty(obj, 'a', {
  value: 42,
  writable: true,
});
console.log(obj.a); // 输出: 42
```

Object.defineProperties(obj, props)：

直接在对象上定义一个或多个新的属性或修改现有属性，返回该对象。

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

Object.entries(obj)：
- 返回一个给定对象自身可枚举属性的键值对数组，其排列顺序与使用 for...in 循环遍历该对象时返回的顺序一致。
- ```
const obj = { a: 1, b: 2, c: 3 };
console.log(Object.entries(obj)); // 输出: [['a', 1], ['b', 2], ['c', 3]]
```
Object.freeze(obj)：
- 冻结一个对象，冻结后不能向该对象添加新属性，不能删除已有属性，不能修改已有属性的可枚举性、可配置性、可写性以及属性值。
- ```
const obj = { a: 1 };
Object.freeze(obj);
obj.a = 2; // 无效
console.log(obj.a); // 输出: 1
```

Object.getOwnPropertyDescriptor(obj, prop)：

返回对象上一个自有属性对应的属性描述符（如果存在），否则返回 undefined。

const obj = { a: 1 };
const descriptor = Object.getOwnPropertyDescriptor(obj, 'a');
console.log(descriptor); // 输出: { value: 1, writable: true, enumerable: true, configurable: true }

Object.getOwnPropertyDescriptors(obj)：

返回一个对象的所有自身属性的描述符。

const obj = { a: 1 };
const descriptors = Object.getOwnPropertyDescriptors(obj);
console.log(descriptors); // 输出: { a: { value: 1, writable: true, enumerable: true, configurable: true } }

Object.getOwnPropertyNames(obj)：
- 返回一个包含对象自身所有属性（包括不可枚举属性但不包括 Symbol 属性）的数组。
- ```
const obj = { a: 1, b: 2 };
console.log(Object.getOwnPropertyNames(obj)); // 输出: ['a', 'b']
```

Object.getOwnPropertySymbols(obj)：

返回一个数组，包含对象自身所有的 Symbol 属性键。

const sym = Symbol('foo');
const obj = { [sym]: 1 };
console.log(Object.getOwnPropertySymbols(obj)); // 输出: [Symbol(foo)]

Object.getPrototypeOf(obj)：
- 返回指定对象的原型（即，内部 [[Prototype]] 属性的值）。
- ```
const obj = {};
const proto = Object.getPrototypeOf(obj);
console.log(proto); // 输出: {}
```

Object.is(value1, value2)：

判断两个值是否是相同的值。所有 NaN 值都相同（即 Object.is(NaN, NaN) 返回 true），但正零和负零不相同。

console.log(Object.is('foo', 'foo')); // 输出: true
console.log(Object.is(NaN, NaN)); // 输出: true
console.log(Object.is(0, -0)); // 输出: false

Object.isExtensible(obj)：

判断对象是否是可扩展的（即，可以添加新的属性）。

const obj = {};
console.log(Object.isExtensible(obj)); // 输出: true
Object.preventExtensions(obj);
console.log(Object.isExtensible(obj)); // 输出: false

Object.isFrozen(obj)：

判断对象是否被冻结。

const obj = Object.freeze({});
console.log(Object.isFrozen(obj)); // 输出: true

Object.isSealed(obj)：

判断对象是否被密封。

const obj = Object.seal({});
console.log(Object.isSealed(obj)); // 输出: true

Object.keys(obj)：

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

const obj = { a: 1, b: 2, c: 3 };
console.log(Object.keys(obj)); // 输出: ['a', 'b', 'c']

Object.preventExtensions(obj)：
- 防止对象的扩展。将对象设置为不可扩展（即，不能添加新的属性）。
- ```
const obj = {};
Object.preventExtensions(obj);
obj.a = 1; // 无效
console.log(obj.a); // 输出: undefined
```
Object.seal(obj)：
- 密封一个对象，防止添加新属性并将所有现有属性标记为不可配置。现有属性的值仍然可以改变。
- ```
const obj = { a: 1 };
Object.seal(obj);
delete obj.a; // 无效
console.log(obj.a); // 输出: 1
```

Object.setPrototypeOf(obj, prototype)：

设置对象的原型（即，内部 [[Prototype]] 属性的值），返回指定对象。

const proto = {};
const obj = Object.setPrototypeOf({}, proto);
console.log(Object.getPrototypeOf(obj) === proto); // 输出: true

Object.values(obj)：

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

const obj = { a: 1, b: 2, c: 3 };
console.log(Object.values(obj)); // 输出: [1, 2, 3]

这些方法可以帮助你在 TypeScript 中有效地处理和操作对象。通过理解和利用这些方法，你可以编写更健壮和灵活的代码。