Object对象中的常用方法

本文旨在简单总结Object对象中的常用方法，详细总结可参考官方文档

Object详细讲解

1.Object.keys(obj)

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

参数：一个对象。

const data = { age:"18",height:"180"};
const keys = Object.keys(data); 
console.log(keys)// ['age',"height"]

2.Object.values(obj)

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

参数：一个对象。

const data ={ age:"18",height:"180"};
const values = Object.values(data); 
console.log(values) //['18','180']

3.Object.entries(obj)

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

参数：一个对象。

const data = { age:"18",height:"180"};
const entries = Object.entries(data);
console.log(entries); // [['age', '180'], ['height', '180']]

4.Object.assign(obj1,obj2)

作用： 将一个或多个源对象(sources)的所有自身可枚举属性复制到目标对象(target)。返回修改后的目标

参数：一个或多个包含要应用的属性的源对象

const data = { age:"18",height:"180"};
const data2 = { weight: 'search', name: 'john' };
const data3 = Object.assign({}, data, data2);
console.log(data3)//  {age: "18", height: "180", weight: "search", name: "john"}

5.Object.create(proto, propertiesObject)

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

参数：

1. proto ` 新创建对象的原型对象。

2. propertiesObject（可选） 如果该参数被指定且不为 undefined，则该传入对象可枚举的自有属性将为新创建的对象添加具有对应属性名称的属性描述符

返回值：返回一个新对象，其原型为 proto，自身属性由 propertiesObject 定义（若提供）。

const Person = { sport: function() { console.log("打篮球")} };
const person = Object.create(Person);
person.name = 'John';
console.log(person.sport == Person.sport); 
// true，方法来自原型

6.Object.defineProperty(obj, prop, descriptor)/ Object.defineProperties(obj, props)

作用：在一个对象上定义一个/多个新属性，或修改其现有属性，并返回此对象。

参数：

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

//定义多单个属性
const object1 = {};Object.defineProperty(object1, "property1", {value: 42,writable: false,
});
object1.property1 = 77;
console.log(object1.property1);//42

//定义多个属性
const object1 = {};Object.defineProperties(object1, {property1: {value: 42,writable: true,},property2: {value: 41,writable: true, },
});console.log(object1.property1);//42

7.Object.getOwnPropertyDescriptor(obj, prop)

作用： 获取对象自身某个属性（不含原型链上的）的属性描述符对象。

参数：

1. obj 在其上定义或修改属性的对象。
2. props 对象，其中每个键表示要定义或修改的属性的名称，每个值是描述该属性的对象。

返回值：

• 若对象 obj 存在自身属性 prop，则返回该属性的属性描述符对象（Object）。
• 若 obj 不存在该自身属性（或属性是继承的），则返回 undefined。

const object1 = {property1: 42,property2: 43
};const descriptor = Object.getOwnPropertyDescriptor(object1, "property1");
const descriptors = Object.getOwnPropertyDescriptors(object1, "property1");
console.log(descriptor);//{ value: 42, writable: true, enumerable: true, configurable: true }console.log(descriptor1.value);
// Expected output: 42

8.Object.getOwnPropertyDescriptors(obj)

作用：获取对象所有自身属性的描述符

参数：要查询的目标对象

返回值：返回一个包含所有描述符的集合对象。

const obj = {name: "Alice",age: 30,get fullInfo() { return `${this.name}, ${this.age}`; }
};// 获取所有自身属性的描述符
const descriptors = Object.getOwnPropertyDescriptors(obj);console.log(descriptors);
// 输出（简化）：
// {
//   name: { value: "Alice", writable: true, enumerable: true, configurable: true },
//   age: { value: 30, writable: true, enumerable: true, configurable: true },
//   fullInfo: { 
//     get: [Function: get fullInfo], 
//     set: undefined, 
//     enumerable: true, 
//     configurable: true 
//   }
// }

9.Object.freeze(obj)

作用：让对象变得不可修改，从而保护其数据不被意外篡改。

• 不能修改现有属性的值：无论属性原本是否可写（writable: true），冻结后都无法修改。
• 不能添加新属性：冻结后无法为对象新增属性。
• 不能删除现有属性：冻结后无法删除对象已有的属性。
• 不能修改属性的特性：比如无法修改属性的 configurable（可配置性）、enumerable（可枚举性）等特性。

参数：要冻结的对象。

返回值：被冻结的对象本身（不是新对象）。

// 定义一个普通对象
const person = {name: "Alice",age: 30
};// 冻结对象
Object.freeze(person);// 尝试修改现有属性 —— 无效（严格模式下会报错）
person.age = 31;
console.log(person.age); // 输出：30（未被修改）// 尝试添加新属性 —— 无效
person.gender = "female";
console.log(person.gender); // 输出：undefined// 尝试删除属性 —— 无效
delete person.name;
console.log(person.name); // 输出："Alice"（未被删除）

10.Object.isFrozen(obj)

作用：检测一个对象是否被冻结的内置方法，用于验证对象的冻结状态。

参数：要检测的对象

返回：布尔值（true 表示对象已冻结，false 表示未冻结）

// 1. 普通对象（未冻结）
const obj1 = { a: 1 };
console.log(Object.isFrozen(obj1)); // 输出：false// 2. 被冻结的对象
const obj2 = { b: 2 };
Object.freeze(obj2); // 冻结对象
console.log(Object.isFrozen(obj2)); // 输出：true// 3. 被冻结后尝试修改，不影响其冻结状态
obj2.b = 3; // 无效（非严格模式下静默失败）
console.log(Object.isFrozen(obj2)); // 输出：true（仍处于冻结状态）

11.Object.seal(obj)

作用：用于 “密封” 对象，限制对象的修改范围

• 不能添加新属性：无法为对象新增属性。

• 不能删除现有属性：已有的属性无法被删除。

• 不能修改属性的特性：属性的 configurable（可配置性）、enumerable（可枚举性）等特性无法修改（一旦密封，属性的 configurable 会被设为 false）。

参数：要密封的对象。

返回值：返回被密封的对象本身（不是新对象）

// 定义一个普通对象
const car = {brand: "Tesla",price: 50000
};// 密封对象
Object.seal(car);// 尝试修改现有属性的值 —— 有效
car.price = 55000;
console.log(car.price); // 输出：55000（成功修改）// 尝试添加新属性 —— 无效
car.color = "red";
console.log(car.color); // 输出：undefined// 尝试删除现有属性 —— 无效
delete car.brand;
console.log(car.brand); // 输出："Tesla"（未被删除）// 尝试修改属性特性 —— 无效（严格模式下会报错）
Object.defineProperty(car, "brand", { enumerable: false });
// 检查是否可枚举：仍为 true
console.log(Object.keys(car).includes("brand")); // 输出：true

12.Object.isSealed(obj)

作用：检测一个对象是否被 “密封”

参数：要检测的对象

返回值：布尔值（true 表示对象已密封，false 表示未密封）。

// 1. 普通对象（未密封）
const obj1 = { a: 1 };
console.log(Object.isSealed(obj1)); // 输出：false// 2. 被密封的对象
const obj2 = { b: 2 };
Object.seal(obj2); // 密封对象
console.log(Object.isSealed(obj2)); // 输出：true// 3. 密封后修改属性值，不影响密封状态
obj2.b = 3; // 有效（密封允许修改值）
console.log(Object.isSealed(obj2)); // 输出：true（仍处于密封状态）

13.Object.preventExtensions(obj)

作用：用于 “阻止对象扩展” ，控制对象是否能添加新属性

• 可以修改现有属性的值；
• 可以删除现有属性；
• 可以修改现有属性的特性（如 configurable、enumerable、writable 等）。

参数：需要被限制拓展的的对象

返回值：被限制拓展的对象本身（不是新对象）

// 定义一个普通对象
const book = {title: "JavaScript Guide",price: 50
};// 阻止对象扩展
Object.preventExtensions(book);// 尝试添加新属性 —— 无效
book.author = "John";
console.log(book.author); // 输出：undefined// 允许修改现有属性的值
book.price = 60;
console.log(book.price); // 输出：60（成功修改）// 允许删除现有属性
delete book.title;
console.log(book.title); // 输出：undefined（成功删除）// 允许修改属性特性（如将 price 设为不可写）
Object.defineProperty(book, "price", { writable: false });
book.price = 70; // 此时修改无效
console.log(book.price); // 输出：60

13.Object.isExtensible(obj)

作用：检测一个对象是否 “可扩展”

参数：要检测的对象

返回值：布尔值（true 表示对象可扩展，false 表示不可扩展）。

// 1. 普通对象（默认可扩展）
const obj1 = { a: 1 };
console.log(Object.isExtensible(obj1)); // 输出：true（可以添加新属性）// 2. 被阻止扩展的对象
const obj2 = { b: 2 };
Object.preventExtensions(obj2); // 阻止扩展
console.log(Object.isExtensible(obj2)); // 输出：false（不能添加新属性）// 3. 尝试添加属性不影响可扩展性状态
obj2.c = 3; // 无效（不可扩展）
console.log(Object.isExtensible(obj2)); // 输出：false（状态不变）

14.Object.getPrototypeOf(obj)

• 作用：用于获取对象原型（即对象内部 [[Prototype]] 属性值）
• 参数：要获取原型的对象
• 返回值：obj 的原型对象；如果 obj 没有原型（如 Object.prototype），则返回 null。

// 创建一个普通对象
const obj = { name: "test" };// 获取 obj 的原型（默认是 Object.prototype）
const proto = Object.getPrototypeOf(obj);console.log(proto === Object.prototype); // 输出：true
// Object.prototype 是最基础的原型，提供了 toString()、hasOwnProperty() 等方法
console.log(proto.toString); // 输出：[Function: toString]

15.Object.is(value1, value2)

• 作用： 用于比较两个值是否 “本质上相同”，返回一个布尔值：
• 参数：两个 任意 JavaScript 类型的值（原始值或引用类型）
• 返回值：布尔值（true表示相同，false表示不同），

// 数值相等
console.log(Object.is(123, 123)); // true// 类型不同
console.log(Object.is("123", 123)); // false// 布尔值
console.log(Object.is(true, false)); // false// 对象（比较引用）
const obj = { a: 1 };
console.log(Object.is(obj, obj)); // true（同一引用）
console.log(Object.is(obj, { a: 1 })); // false（不同引用）

16.Object.prototype.toString()

• 作用： 用于检测值的类型
• 参数：无
• 返回值：返回固定格式为 [object 类型标识]的字符串

console.log(Object.prototype.toString.call([])); // "[object Array]"
console.log(Object.prototype.toString.call(new Date())); // "[object Date]"
console.log(Object.prototype.toString.call(null)); // "[object Null]"
console.log(Object.prototype.toString.call(document)); // "[object HTMLDocument]" (在浏览器环境)

17.Object.prototype.valueOf()

作用：用于对象在需要转换为原始值的场景

参数：无

返回值：

• 通常为原始值（如 number、string、boolean 等），但具体取决于对象的类型（不同内置对象会重写该方法以返回对应的原始值）。
• 对于未重写 valueOf() 的普通对象，默认返回对象本身（而非原始值）。

普通对象未重写 valueOf() 时，默认返回对象自身（不是原始值）：

const obj = { name: "test" };
console.log(obj.valueOf()); //  { name: "test" }

大多数内置对象会重写 valueOf() 以返回对应的原始值

//Number 包装对象：返回对应的数字原始值
const numObj = new Number(123);
console.log(numObj.valueOf()); // 123（返回数字原始值）
console.log(typeof numObj.valueOf()); // "number"//String 包装对象：返回对应的字符串原始值
const strObj = new String("hello");
console.log(strObj.valueOf()); // "hello"（返回字符串原始值）
console.log(typeof strObj.valueOf()); // "string"//Boolean 包装对象：返回对应的布尔原始值
const boolObj = new Boolean(true);
console.log(boolObj.valueOf()); // true（返回布尔原始值）
console.log(typeof boolObj.valueOf()); // "boolean"//Date 对象：返回距离 UTC 时间 1970 年 1 月 1 日 00:00:00 的毫秒数（时间戳，数字类型）
const date = new Date(2023, 0, 1); // 2023年1月1日
console.log(date.valueOf()); // 1672531200000（时间戳，数字类型）