JS Object

Object.assign()

Object.assign() 静态方法将一个或者多个源对象中所有可枚举的自有属性复制到目标对象，并返回修改后的目标对象。

Object.assign() 方法是一种浅拷贝方法。也就是说，它只会复制对象的第一层属性，而不会复制对象内部的所有嵌套属性。

语法：

Object.assign(target, ...sources)

target：需要应用源对象属性的目标对象，修改后将作为返回值。
sources：一个或多个包含要应用的属性的源对象。
返回值
修改后的目标对象。

备注： Object.assign() 不会在源对象值为 null 或 undefined 时抛出错误。

示例：

复制对象

const obj = { a: 1 };
const copy = Object.assign({}, obj);
console.log(copy); // { a: 1 }

合并对象

const o1 = { a: 1 };
const o2 = { b: 2 };
const o3 = { c: 3 };

const obj = Object.assign(o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }
console.log(o1);  // { a: 1, b: 2, c: 3 }，目标对象本身发生了变化

合并具有相同属性的对象

const o1 = { a: 1, b: 1, c: 1 };
const o2 = { b: 2, c: 2 };
const o3 = { c: 3 };

const obj = Object.assign({}, o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }

注：属性会被后续参数中具有相同属性的其他对象覆盖。

Object.create()

Object.create() 静态方法以一个现有对象作为原型，创建一个新对象。

语法：

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

proto：新创建对象的原型对象。
propertiesObject：可选；如果该参数被指定且不为 undefined，
则该传入对象可枚举的自有属性将为新创建的对象添加具有对应属性名称的属性描述符。
这些属性对应于 Object.defineProperties() 的第二个参数。
返回值
根据指定的原型对象和属性创建的新对象。

示例：

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

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

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

o2 = Object.create(
  {},
  {
    p: {
      value: 42,
      writable: true,
      enumerable: true,
      configurable: true,
    },
  },
);
// 这与以下语句不等价：
// o2 = Object.create({ p: 42 })
// 后者将创建一个原型为 { p: 42 } 的对象。

o.p = 24; // 在严格模式下会报错
o.p; // 42
o.q = 12;
for (const prop in o) {
  console.log(prop);
}
// 'q'
delete o.p;
// false；在严格模式下会报错

Object.defineProperties()

Object.defineProperties() 静态方法直接在一个对象上定义新的属性或修改现有属性，并返回该对象。

语法：

Object.defineProperties(obj, props)

obj 在其上定义或修改属性的对象。
props 要定义属性的对象
返回值
传递给函数的对象。

示例：

<script>
  const obj = {};
  Object.defineProperties(obj, {
    name: {
      value: 'lisa',
      writable: true,
    },
    age: {
      value: 24,
      writable: false,
    },
  });
console.log(obj);
//{name: 'lisa', age: 24}

Object.defineProperty()

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

语法：

Object.defineProperty(obj, prop, descriptor)

obj 要定义属性的对象。
prop 一个字符串或 Symbol，指定了要定义或修改的属性键。
descriptor 要定义或修改的属性的描述符。

创建属性

const o = {}; // 创建一个新对象

// 通过 defineProperty 使用数据描述符添加对象属性的示例
Object.defineProperty(o, "a", {
  value: 37,
  writable: true,
  enumerable: true,
  configurable: true,
});
// 'a' 属性存在于对象 o 中，其值为 37

// 通过 defineProperty 使用访问器属性描述符添加对象属性的示例
let bValue = 38;
Object.defineProperty(o, "b", {
  get() {
    return bValue;
  },
  set(newValue) {
    bValue = newValue;
  },
  enumerable: true,
  configurable: true,
});
o.b; // 38
// 'b' 属性存在于对象 o 中，其值为 38。
// o.b 的值现在始终与 bValue 相同，除非重新定义了 o.b。

// 数据描述符和访问器描述符不能混合使用
Object.defineProperty(o, "conflict", {
  value: 0x9f91102,
  get() {
    return 0xdeadbeef;
  },
});
// 抛出错误 TypeError: value appears only in data descriptors, get appears only in accessor descriptors

拓展 props

一个对象，其中每个键表示要定义或修改的属性的名称，每个值是描述该属性的对象。在 props 中的每个值必须是且只能是数据描述符或访问器描述符之一；不能同时为两者

数据描述符和访问器描述符可以包含以下可选键：

configurable 如果此属性描述符的类型可以更改并且属性可以从相应的对象中删除，则为 true。默认为 false。

enumerable 如果此属性在枚举相应对象的属性时应显示出来，则为 true。默认为 false。

value 与属性关联的值。可以是任何有效的 JavaScript 值（数字、对象、函数等）。默认为 >undefined。

writable 如果与属性关联的值可以使用赋值运算符更改，则为 true。默认为 false。

访问器描述符还具有以下可选键：

get 作为该属性的 getter 函数，如果没有 getter 则为 undefined。函数返回值将被用作属性的值。默认为 undefined。

set 作为该属性的 setter 函数，如果没有 setter 则为 undefined。该函数将只接收一个参数，即被分配给属性的新值。默认为 undefined。

如果一个属性描述符没有 value、writable、get、set 键中的任何一个，那么它被视为一个数据描述符。如果一个属性描述符同时具有 value 或 writable 和 get 或 set 键中的任意一个组合，就会抛出异常。

Object.entries()

Object.entries() 静态方法返回一个数组，包含给定对象自有的可枚举字符串键属性的键值对。

语法：

Object.entries(obj)

一个由给定对象自有的可枚举字符串键属性的键值对组成的数组。
每个键值对都是一个包含两个元素的数组：第一个元素是属性的键（始终是字符串），第二个元素是属性值。
返回值》
一个由给定对象自有的可枚举字符串键属性的键值对组成的数组。
每个键值对都是一个包含两个元素的数组：第一个元素是属性的键（始终是字符串），第二个元素是属性值。

示例

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

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

// 具有随机键排序的类数组对象
const anObj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.entries(anObj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ]

// getFoo 是一个不可枚举的属性
const myObj = Object.create(
  {},
  {
    getFoo: {
      value() {
        return this.foo;
      },
    },
  },
);
myObj.foo = "bar";
console.log(Object.entries(myObj)); // [ ['foo', 'bar'] ]

将 Object 转换成 Map

const obj = { foo: "bar", baz: 42 };
const map = new Map(Object.entries(obj));
console.log(map); // Map(2) {"foo" => "bar", "baz" => 42}

遍历

// 使用 for...of 循环
const obj1 = {a: 5, b: 7, c: 9};
for (const [key, value] of Object.entries(obj)) {
    console.log(`${key} ${value}`); // "a 5", "b 7", "c 9"
}
// 使用数组方法
Object.entries(obj1).forEach(([key, value]) => {
   console.log(`${key} ${value}`); // "a 5", "b 7", "c 9"
});

Object.freeze()

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

Object.freeze(obj)

obj 要冻结的对象。
返回值
传递给函数的对象。

示例

const obj = {
  prop: 42
};
Object.freeze(obj);
obj.prop = 33;
console.log(obj.prop);// 42

冻结对象

const obj = {
  prop() {},
  foo: "bar",
};

// 冻结前：可以添加新属性，也可以更改或删除现有属性
obj.foo = "baz";
obj.lumpy = "woof";
delete obj.prop;

// 冻结。
const o = Object.freeze(obj);

// 返回值和我们传入的对象相同。
o === obj; // true

// 对象已冻结。
Object.isFrozen(obj); // === true

// 现在任何更改都会失败。
obj.foo = "quux"; // 静默但什么都没做
// 静默且没有添加属性
obj.quaxxor = "the friendly duck";

// 严格模式下，这样的尝试会抛出 TypeError
function fail() {
  "use strict";
  obj.foo = "sparky"; // 抛出 TypeError
  delete obj.foo; // 抛出 TypeError
  delete obj.quaxxor; // 返回 true，因为属性‘quaxxor’从未被添加过。
  obj.sparky = "arf"; // 抛出 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 };

冻结数组

const a = [0];
Object.freeze(a); // 数组现在开始无法被修改
a[0] = 1; // 静默失败
// 严格模式下，这样的尝试将抛出 TypeError
function fail() {
  "use strict";
  a[0] = 1;
}
fail();
// 尝试在数组末尾追加元素
a.push(2); // 抛出 TypeError

被冻结的对象是不可变的。

Object.isFrozen()

Object.isFrozen() 静态方法判断一个对象是否被冻结语法

Object.isFrozen(obj)

返回值
指示给定对象是否被冻结的布尔值

示例

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

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

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

// 即使令对象不可扩展，它也不会被冻结，因为属性仍然是可配置的（而且可写的）。
Object.preventExtensions(oneProp);
Object.isFrozen(oneProp); // false

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

// 一个不可扩展的对象，拥有一个不可写但可配置的属性，则它仍然是非冻结的。
const 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

// 一个不可扩展的对象，拥有一个不可配置但可写的属性，则它也是非冻结的。
const 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

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

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

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

// 根据定义，一个冻结对象是不可拓展的。
Object.isExtensible(frozen); // false

// 同样，根据定义，一个冻结对象也是密封对象。
Object.isSealed(frozen); // true

Object.fromEntries()

Object.fromEntries() 静态方法将键值对列表转换为一个对象。语法

Object.fromEntries(iterable)

iterable 一个包含对象列表的可迭代对象。
例如 Array 或者 Map。每个对象都要有两个属性：
0 表示属性键的字符串或者 Symbol。
1 属性值。
通常，该对象被实现为二元数组，第一个元素是属性键，第二个元素是属性值。

返回值
一个新对象，其属性由可迭代对象的条目给定。

示例

将 Map 转换成对象

const map = new Map([
  ["foo", "bar"],
  ["baz", 42],
]);
const obj = Object.fromEntries(map);
console.log(obj); // { foo: "bar", baz: 42 }

将 Array 转换成对象

const arr = [
  ["0", "a"],
  ["1", "b"],
  ["2", "c"],
];
const obj = Object.fromEntries(arr);
console.log(obj); // { 0: "a", 1: "b", 2: "c" }

对象转换

const object1 = { a: 1, b: 2, c: 3 };
const object2 = Object.fromEntries(
  Object.entries(object1).map(([key, val]) => [key, val * 2]),
);
console.log(object2);
// { a: 2, b: 4, c: 6 }

Object.getOwnPropertyNames()

Object.getOwnPropertyNames() 静态方法返回一个数组，其包含给定对象中所有自有属性（包括不可枚举属性，但不包括使用 symbol 值作为名称的属性）。语法

Object.getOwnPropertyNames(obj)

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

示例

const object1 = {
  a: 1,
  b: 2,
  c: 3
};

console.log(Object.getOwnPropertyNames(object1));
// Expected output: Array ["a", "b", "c"]

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

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

Object.getOwnPropertyNames(obj).forEach((val, idx, array) => {
  console.log(`${val} -> ${obj[val]}`);
});
// 0 -> a
// 1 -> b
// 2 -> c

// 不可枚举属性
const myObj = Object.create(
  {},
  {
    getFoo: {
      value() {
        return this.foo;
      },
      enumerable: false,
    },
  },
);
myObj.foo = 1;
console.log(Object.getOwnPropertyNames(myObj).sort()); // ["foo", "getFoo"]

Object.hasOwn()

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

语法

Object.hasOwn(obj, prop)

obj
要测试的 JavaScript 实例对象。
prop
要测试属性的 String 类型的名称或者 Symbol。
返回值
如果指定的对象中直接定义了指定的属性，则返回 `true`；否则返回 `false`。

示例

const example = {};
Object.hasOwn(example, 'prop');   // false——目标对象的属性 'prop' 未被定义

example.prop = 'exists';
Object.hasOwn(example, 'prop');   // true——目标对象的属性 'prop' 已被定义

example.prop = null;
Object.hasOwn(example, 'prop');   // true——目标对象本身的属性存在，值为 null

example.prop = undefined;
Object.hasOwn(example, 'prop');   // true——目标对象本身的属性存在，值为 undefined

检查数组索引是否存在

Array 中的元素被定义为直接属性，所以你可以使用 hasOwn() 方法去检查一个指定的索引是否存在：

const fruits = ['Apple', 'Banana','Watermelon', 'Orange'];
Object.hasOwn(fruits, 3);   // true ('Orange')
Object.hasOwn(fruits, 4);   // false——没有定义的

Object.is()

Object.is() 静态方法确定两个值是否为相同值。

语法

Object.is(value1, value2)

返回值
一个布尔值，指示两个参数是否为相同的值。

示例

// 案例 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.preventExtensions()

Object.preventExtensions() 静态方法可以防止新属性被添加到对象中（即防止该对象被扩展）。它还可以防止对象的原型被重新指定。

语法

Object.preventExtensions(obj)

obj 将要变为不可拓展的对象
返回值
已经不可扩展的对象。

示例

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

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

// 可以将其改变为不可扩展的。
Object.preventExtensions(empty);
Object.isExtensible(empty); // false

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

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

Object.isExtensible()

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

语法

Object.isExtensible(obj)

obj 检查的对象
返回值
指示给定对象是否可扩展的一个布尔值

示例

// 新对象是可拓展的。
const empty = {};
Object.isExtensible(empty); // true

// 它们可以变为不可拓展的
Object.preventExtensions(empty);
Object.isExtensible(empty); // false

// 根据定义，密封对象是不可拓展的。
const sealed = Object.seal({});
Object.isExtensible(sealed); // false

// 根据定义，冻结对象同样也是不可拓展的。
const frozen = Object.freeze({});
Object.isExtensible(frozen); // false

Object.seal()

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

语法

Object.seal(obj)
obj 要密封的对象
返回值
被密封的对象。

示例

const obj = {
  prop() {},
  foo: "bar",
};

// 可以添加新属性，可以更改或删除现有属性。
obj.foo = "baz";
obj.lumpy = "woof";
delete obj.prop;

const o = Object.seal(obj);

o === obj; // true
Object.isSealed(obj); // true

// 更改密封对象的属性值仍然有效。
obj.foo = "quux";

// 但不能将数据属性转换成访问者属性，反之亦然。
Object.defineProperty(obj, "foo", {
  get() {
    return "g";
  },
}); // 抛出 TypeError

// 现在，除了属性值之外的任何更改都将失败。
obj.quaxxor = "the friendly duck";
// 静默不添加属性
delete obj.foo;
// 静默不添删除属性

// ...且严格模式下，这种尝试将会抛出 TypeError。
function fail() {
  "use strict";
  delete obj.foo; // 抛出一个 TypeError
  obj.sparky = "arf"; // 抛出一个 TypeError
}
fail();

// 尝试通过 Object.defineProperty 添加属性也会抛出错误。
Object.defineProperty(obj, "ohai", {
  value: 17,
}); // 抛出 TypeError
Object.defineProperty(obj, "foo", {
  value: "eit",
}); // 更改现有属性值

Object.isSealed()

Object.isSealed() 静态方法判断一个对象是否被密封。

语法

Object.isSealed(obj)

示例

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

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

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

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

// 密封一个对象最简单的方法当然是 Object.seal。
const sealed = {};
Object.seal(sealed);
Object.isSealed(sealed); // true

// 根据定义，密封对象是不可扩展的。
Object.isExtensible(sealed); // false

// 一个密封对象可能被冻结，但不一定。
Object.isFrozen(sealed); // true
//（所有属性也是不可写的）

const s2 = Object.seal({ p: 3 });
Object.isFrozen(s2); // false
//（'p' 仍然可写）

const s3 = Object.seal({
  get p() {
    return 0;
  },
});
Object.isFrozen(s3); // true
//（对于访问器属性，只有可配置性才有影响）

Object.keys()

Object.keys() 静态方法返回一个由给定对象自身的可枚举的字符串键属性名组成的数组。

Object.keys(obj)

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

示例

const object1 = {
  a: 'somestring',
  b: 42,
  c: false
};
console.log(Object.keys(object1));
// Expected output: Array ["a", "b", "c"]

// 简单数组
const arr = ["a", "b", "c"];
console.log(Object.keys(arr)); // ['0', '1', '2']

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

// 键的顺序随机的类数组对象
const anObj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.keys(anObj)); // ['2', '7', '100']

// getFoo 是一个不可枚举的属性
const myObj = Object.create(
  {},
  {
    getFoo: {
      value() {
        return this.foo;
      },
    },
  },
);
myObj.foo = 1;
console.log(Object.keys(myObj)); // ['foo']

Object.values()

Object.values() 静态方法返回一个给定对象的自有可枚举字符串键属性值组成的数组。

语法

Object.values(obj)

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

示例

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

// 类数组对象
const arrayLikeObj1 = { 0: "a", 1: "b", 2: "c" };
console.log(Object.values(arrayLikeObj1)); // ['a', 'b', 'c']

// 具有随机键排序的类数组对象
// 使用数字键时，将按键的数字顺序返回值
const arrayLikeObj2 = { 100: "a", 2: "b", 7: "c" };
console.log(Object.values(arrayLikeObj2)); // ['b', 'c', 'a']

// getFoo 是一个不可枚举的属性
const myObj = Object.create(
  {},
  {
    getFoo: {
      value() {
        return this.foo;
      },
    },
  },
);
myObj.foo = "bar";
console.log(Object.values(myObj)); // ['bar']

Object.prototype.toLocaleString()

toLocaleString() 方法返回一个表示对象的字符串。该方法旨在由派生对象重写，以达到其特定于语言环境的目的。

语法

toLocaleString()

示例

const obj = {
  toString() {
    return "My Object";
  },
};
console.log(obj.toLocaleString()); // "My Object"

参考Object - JavaScript | MDN (mozilla.org)

JS内置对象--- Object对象的相关方法 ！！

JS Object

Object.assign()

Object.create()

Object.defineProperties()

Object.defineProperty()

拓展 props

Object.entries()

Object.freeze()

Object.isFrozen()

Object.fromEntries()

Object.getOwnPropertyNames()

Object.hasOwn()

Object.is()

Object.preventExtensions()

Object.isExtensible()

Object.seal()

Object.isSealed()

Object.keys()

Object.values()

Object.prototype.toLocaleString()

JS内置对象--- Object对象的相关方法！！