免费web服务器网站澳门青岛seo软件
tip：
本文仅作为查找和基本使用的展示，需要深入了解这些方法的使用请参考：Object - JavaScript | MDN (mozilla.org)
可以通过目录快速锁定需要查找的方法和查看它的使用
目录
tip：
新建一个对象
实例属性
实例方法
hasOwnProperty(key)
isPrototypeOf(obj)
propertyIsEnumerable(prop)
toLocaleString()
toString()
valueOf()
静态方法
Object.assign(target, ...sources)
Object.create(proto)
Object.defineProperties(obj, props)
Object.defineProperty(obj, prop, descriptor)
Object.entries(obj)
Object.fromEntries(iterable)
Object.getOwnPropertyDescriptor(obj, prop)
Object.getOwnPropertyDescriptors(obj)
Object.getOwnPropertyNames(obj)
Object.getOwnPropertySymbols(obj)
Object.getPrototypeOf(obj)
Object.groupBy(item, callback)---2024新增
Object.hasOwn(obj, prop)
Object.is(value1, value2)
Object.preventExtensions(obj),Object.isExtensible(obj)
Object.freeze(obj)
Object.isFrozen(obj)
Object.seal(obj)，Object.isSealed(obj)
Object.keys(obj)
Object.values(obj)
Object.setPrototypeOf(obj, prototype)
方法总览
新建一个对象
// 新建一个对象const obj = {//通过{}name:'Tom',age:18
}
const obj1 = new Object({//通过构造函数name:'Tom',age:18
})
const obj2 = Object.create({ //通过静态方法name:'Tom',age:18
})//注意这里的参数不是生成对象的结果，参数会作为obj2的原型，obj2本身是一个新的空对象console.log(obj,obj1,obj2);console.log("\n----------分割线----------\n");实例属性
// 实例属性// constructor 对象的实例属性
// 除了 null 原型对象之外，任何对象都会在其 [[Prototype]] 上有一个 constructor 属性。
// Object 实例的 constructor 数据属性返回一个引用，指向创建该实例对象的构造函数（函数本身而不是字符串）
// 可以用来判断对象类型
const arr = [];
const number = 1;
console.log(obj.constructor === Object);//true
console.log(arr.constructor === Array);//true
console.log(number.constructor === Number);//trueconsole.log("\n----------分割线----------\n");实例方法
hasOwnProperty(key)
方法会返回一个布尔值，如果自身有这个key属性（不包括原型中继承的属性），则返回 true，否则返回 false。
// hasOwnProperty(key) 方法会返回一个布尔值，如果自身有这个key属性（不包括原型中继承的属性），则返回 true，否则返回 false。
console.log({name:'Tom'}.hasOwnProperty('name'));//true
console.log({name:undefined}.hasOwnProperty('name'));//true,这里的name值虽然是undefined，但是属性存在
console.log(['Tom'].hasOwnProperty('0'));//true，数组也是对象，可以将索引看成key
console.log([].hasOwnProperty('length'));//true，数组固有的属性lengthconsole.log("\n----------分割线----------\n");isPrototypeOf(obj)
返回布尔值 判断当前对象是否在obj的原型链中，（对象---原型链）和object instanceof AFunction不同，这是比较两个对象的原型链 ，（原型链---原型链）
// isPrototypeOf(obj) 返回布尔值 判断当前对象是否在obj的原型链中，（对象---原型链）
// 和object instanceof AFunction不同，这是比较两个对象的原型链 ，（原型链---原型链）
console.log(Object.prototype.isPrototypeOf({}));//true,Object出现在{}的原型链中
console.log(Array.prototype.isPrototypeOf([]));//true，Array出现在[]的原型链中console.log("\n----------分割线----------\n");propertyIsEnumerable(prop)
方法返回一个布尔值，表示prop是否是对象的可枚举自有属性（遍历时是否会被访问，能否出现在for in循环中）
大多数内置属性默认情况下是不可枚举的，而用户创建的对象属性通常是可枚举的，除非明确指定为不可枚举。
// propertyIsEnumerable(prop) 方法返回一个布尔值，表示prop是否是对象的可枚举自有属性（遍历时是否会被访问，能否出现在for in循环中）
// 大多数内置属性默认情况下是不可枚举的，而用户创建的对象属性通常是可枚举的，除非明确指定为不可枚举。
console.log({name:'Tom'}.propertyIsEnumerable('name'));//true，name属性可以遍历
console.log(['0'].propertyIsEnumerable('0'));//true，索引属性可以遍历
console.log(['0'].propertyIsEnumerable('length'));//false，length属性不可遍历console.log("\n----------分割线----------\n");toLocaleString()
返回一个字符串，返回调用toString（）的结果（return this.toString()）
// toLocaleString() 返回一个字符串，返回调用toString（）的结果（return this.toString()）
console.log({name:'Tom'}.toLocaleString());//"[object Object]"console.log("\n----------分割线----------\n");
toString()
返回一个表示该对象的字符串。打印实例时默认调用该方法
// toString() 返回一个表示该对象的字符串。打印实例时默认调用该方法
console.log({name:'Tom'}.toString());//"[object Object]"console.log("\n----------分割线----------\n");valueOf()
返回指定对象的原始值。值传递时可以使用valueOf将值提取出来
// valueOf() 返回指定对象的原始值。值传递时可以使用valueOf将值提取出来
const obj3 = {name:'Tom'}
let newObj = obj3.valueOf();// 值传递，此时newObj和obj3并不是指向同一个内存
console.log(obj3.valueOf());// {name:'Tom'},返回对象本身的值
console.log(obj3.valueOf() === obj3);//trueconsole.log("\n----------分割线----------\n");静态方法
Object.assign(target, ...sources)
将source中所有可以遍历的键值对，放入target中，返回target；target和source中相同的key，source中的值会覆盖target中的值，target 待修改的对象 ，source 多个对象
// Object.assign(target, ...sources) 将source中所有可以遍历的键值对，放入target中，返回target
// target和source中相同的key，source中的值会覆盖target中的值
// target 待修改的对象 ，source 多个对象
console.log(Object.assign({},{name:'tom'},{age:'10'}));// {name:'tom',age:'10'}
console.log(Object.assign({},[1,2,3,4]));// {0:1,1:2,2:3,3:4}
console.log(Object.assign({},[1,2,3,4],'sss'));// { '0': 's', '1': 's', '2': 's', '3': 4 },字符串会被拆分成单个字符作为对象，后面的属性值会覆盖前面的console.log("\n----------分割线----------\n");Object.create(proto)
静态方法以proto作为原型，创建一个新对象。
// Object.create(proto) 静态方法以proto作为原型，创建一个新对象。
const obj4 = Object.create([]);//以[]作为原型，创建一个新对象,数组对象
console.log(obj4);//Array {}console.log("\n----------分割线----------\n");Object.defineProperties(obj, props)
静态方法直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，并返回这个对象。
obj:在其上定义或修改属性的对象; props: 一个对象，其中每个键表示要定义或修改的属性的名称，每个值是描述该属性的对象(是否只读，是否可枚举遍历，)
// Object.defineProperties(obj, props) 静态方法直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，并返回这个对象。
// obj:在其上定义或修改属性的对象; props: 一个对象，其中每个键表示要定义或修改的属性的名称，每个值是描述该属性的对象(是否只读，是否可枚举遍历，)
console.log(Object.defineProperties({name:'Tom'
},
{//属性描述对象name:{value:'Jerry',writable:true //可读写}
}));//{name:'Jerry'}console.log("\n----------分割线----------\n");Object.defineProperty(obj, prop, descriptor)
静态方法会直接在obj上定义一个新属性prop，或修改其现有属性prop，并返回此对象。
obj：待修改的对象 prop：obj对象待修改的属性名 descriptor：属性描述对象
// Object.defineProperty(obj, prop, descriptor) 静态方法会直接在obj上定义一个新属性prop，或修改其现有属性prop，并返回此对象。
// obj：待修改的对象 prop：obj对象待修改的属性名 descriptor：属性描述对象
console.log(Object.defineProperty({name:'Tom'},'name',{value:'Jerry'}));//{name:'Jerry'}console.log("\n----------分割线----------\n");Object.entries(obj)
返回一个obj自身可枚举（可遍历）属性的键值对数组(元组)，
其排列与使用 for...in 循环遍历该对象时返回的顺序一致（区别在于 for...in 循环还会枚举其原型链中的属性）。
// Object.entries(obj) 返回一个obj自身可枚举（可遍历）属性的键值对数组(元组)，
// 其排列与使用 for...in 循环遍历该对象时返回的顺序一致（区别在于 for...in 循环还会枚举其原型链中的属性）。
console.log(Object.entries({name:'Tom',age:18}));//[["name","Tom"],["age",18]]console.log("\n----------分割线----------\n");Object.fromEntries(iterable)
将键值对列表(iterable)转换为一个对象。
iterable：一个包含对象列表的可迭代对象，例如 Array 或者 Map。
每个对象都要有两个属性，0：表示属性键的字符串或者 Symbol。1：属性值。通常，该对象被实现为二元数组，第一个元素是属性键，第二个元素是属性值。
// Object.fromEntries(iterable) 将键值对列表(iterable)转换为一个对象。
// iterable：一个包含对象列表的可迭代对象，例如 Array 或者 Map。
// 每个对象都要有两个属性，0：表示属性键的字符串或者 Symbol。1：属性值。通常，该对象被实现为二元数组，第一个元素是属性键，第二个元素是属性值。console.log(Object.fromEntries([['name','Tom'],['age',18]]));//{name:'Tom',age:18}console.log("\n----------分割线----------\n");Object.getOwnPropertyDescriptor(obj, prop)
返回obj上一个自有属性prop对应的属性描述对象，如果obj上没有prop属性返回undefined。
obj:待查询的对象 prop：string或者symbol 待查询的属性名
// Object.getOwnPropertyDescriptor(obj, prop) 返回obj上一个自有属性prop对应的属性描述对象，如果obj上没有prop属性返回undefined。
// obj:待查询的对象 prop：string或者symbol 待查询的属性名console.log(Object.getOwnPropertyDescriptor({name:'Tom'},'name'));
//{value:'Tom',writable:true,enumerable:true,configurable:true}console.log("\n----------分割线----------\n");
Object.getOwnPropertyDescriptors(obj)
返回obj的所有自有属性属性描述对象。obj：待查询的对象，类似于Object.getOwnPropertyDescriptor
// Object.getOwnPropertyDescriptors(obj) 返回obj的所有自有属性属性描述对象。obj：待查询的对象，类似于Object.getOwnPropertyDescriptorconsole.log(Object.getOwnPropertyDescriptors({name:'Tom',age:18}));//{name:{...},age:{...}}console.log("\n----------分割线----------\n");Object.getOwnPropertyNames(obj)
返回obj对象的所有自身属性的属性名（包括不可枚举属性但不包括Symbol属性）组成的数组。
// Object.getOwnPropertyNames(obj) 返回obj对象的所有自身属性的属性名（包括不可枚举属性但不包括Symbol属性）组成的数组。console.log(Object.getOwnPropertyNames({name:'Tom',age:18}));//['name','age']console.log("\n----------分割线----------\n");Object.getOwnPropertySymbols(obj)
返回obj对象自身的所有 Symbol 属性的数组。
// Object.getOwnPropertySymbols(obj) 返回obj对象自身的所有 Symbol 属性的数组。console.log(Object.getOwnPropertySymbols({[Symbol('name')]:1,[Symbol('age')]:2, name:'Tom',age:18}));//[Symbol(name),Symbol(age)]console.log("\n----------分割线----------\n");Object.getPrototypeOf(obj)
返回obj对象的原型对象。即内部 [[Prototype]] 属性的值
// Object.getPrototypeOf(obj) 返回obj对象的原型对象。即内部 [[Prototype]] 属性的值console.log(Object.getPrototypeOf({}));//Object
console.log(Object.getPrototypeOf([]));//Arrayconsole.log("\n----------分割线----------\n");Object.groupBy(item, callback)---2024新增
返回一个对象，对象内根据callback的返回值，将item进行分类。 item：待分类的可迭代对象 callback：回调函数，返回值作为分类的依据
const items = [{ name: "芦笋", type: "蔬菜", quantity: 5 },{ name: "香蕉", type: "水果", quantity: 0 },{ name: "山羊", type: "肉", quantity: 23 },{ name: "樱桃", type: "水果", quantity: 5 },{ name: "鱼", type: "肉", quantity: 22 },
];
const result = Object.groupBy(items, ({type}) => type);//此方法目前只在浏览器支持
console.log(result);//{蔬菜:{...},水果:{...},肉:{...}}Object.hasOwn(obj, prop)
返回布尔值，检查obj对象自身是否具有指定的属性prop。Object.hasOwn() 旨在取代 Object.prototype.hasOwnProperty()。
// Object.hasOwn(obj, prop) 返回布尔值，检查obj对象自身是否具有指定的属性prop。Object.hasOwn() 旨在取代 Object.prototype.hasOwnProperty()。console.log(Object.hasOwn({name:'Tom'},'name'));//trueconsole.log("\n----------分割线----------\n");Object.is(value1, value2)
返回布尔值,判断两个值是否为同一个值。
Object.is() 与 == 运算符并不等价, 也不等价于 === 运算符,相比于 == Object.is()转换类型比较，相比于 === Object.is()不会忽略 +0 和 -0，也不会把 NaN 等于 NaN。
// Object.is(value1, value2) 返回布尔值,判断两个值是否为同一个值。
// Object.is() 与 == 运算符并不等价, 也不等价于 === 运算符,相比于 == Object.is()转换类型比较，相比于 === Object.is()不会忽略 +0 和 -0，也不会把 NaN 等于 NaN。
console.log(Object.is(1,1));//true
console.log(Object.is(NaN,NaN));//true , == 和 === 返回false
console.log(Object.is(0,-0));//false , == 和 === 返回trueconsole.log("\n----------分割线----------\n");Object.preventExtensions(obj),Object.isExtensible(obj)
Object.preventExtensions(obj)可以防止新属性被添加到obj中（即防止该对象被扩展）。它还可以防止对象的原型被重新指定。
Object.isExtensible(obj)返回布尔值，判断对象是否可扩展（是否可以添加新的属性）。
在ES5中传入的值不是对象会直接报错，在ES6中传入的值不是对象会返回false
// Object.preventExtensions(obj) 静态方法可以防止新属性被添加到obj中（即防止该对象被扩展）。它还可以防止对象的原型被重新指定。
// 在ES5中传入的值不是对象会直接报错，在ES6中传入的值不是对象会返回false
// Object.isExtensible(obj) 返回布尔值，判断对象是否可扩展（是否可以添加新的属性）。
// 在ES5中传入的值不是对象会直接报错，在ES6中传入的值不是对象会返回false
const extensibleObj = Object.preventExtensions({name:'Tom'});console.log(Object.isExtensible(extensibleObj));//false,不可扩展
console.log(Object.isExtensible({name:'Tom'}));//true
console.log(Object.isExtensible(1));//falseconsole.log("\n----------分割线----------\n");
Object.freeze(obj)
冻结obj对象并将其返回，
冻结指的是不能向这个对象添加新的属性，不能修改其已有属性的值，不能删除已有属性，以及不能修改该对象已有属性的可枚举性、可配置性、可写性，
即这个对象本身以及属性都不能在修改（新增、删除、添加、修改），但是，当属性是引用类型时可以修改引用类型内的属性和值（浅冻结，只影响一层）
// Object.freeze(obj) 冻结obj对象并将其返回，
// 冻结指的是不能向这个对象添加新的属性，不能修改其已有属性的值，不能删除已有属性，以及不能修改该对象已有属性的可枚举性、可配置性、可写性，
// 即这个对象本身以及属性都不能在修改（新增、删除、添加、修改），但是，当属性是引用类型时可以修改引用类型内的属性和值（浅冻结，只影响一层）const obj5 = {//注意区分常量和冻结，常量表示的是obj5不能被复制，内部任然可以修改，（浅）冻结是内部的（一层）属性不能被修改name:'Tom',age:18,info:{//此处内部不受浅冻结影响，若要深冻结则需要遍历引用类型属性冻结address:'beijing'}
}console.log(Object.freeze(obj5) === obj5);//{name:'Tom',age:18}，返回冻结后的对象，和原对象一致Object.isFrozen(obj)
返回布尔值，判断对象是否被冻结。
在ES5中传入的值不是对象会直接报错，在ES6中传入的值不是对象会返回false
// Object.isFrozen(obj) 返回布尔值，判断对象是否被冻结。
// 在ES5中传入的值不是对象会直接报错，在ES6中传入的值不是对象会返回false
const freezeObj = Object.freeze({name:'Tom'});
console.log(Object.isFrozen(freezeObj));//true
console.log(Object.isFrozen({name:'Tom'}));//false
console.log(Object.isFrozen(1));//falseconsole.log("\n----------分割线----------\n");
Object.seal(obj)，Object.isSealed(obj)
Object.seal(obj) 返回传递的对象，使obj密封。
Object.isSealed(obj) 返回布尔值，判断对象是否被密封(不能添加，删除，修改)。
在ES5中传入的值不是对象会直接报错，在ES6中传入的值不是对象会返回false
// Object.seal(obj) 返回传递的对象，使obj密封。
// Object.isSealed(obj) 返回布尔值，判断对象是否被密封(不能添加，删除，修改)。
// 在ES5中传入的值不是对象会直接报错，在ES6中传入的值不是对象会返回false
const sealObj = Object.seal({name:'Tom'});
console.log(Object.isSealed(sealObj));//true
console.log(Object.isSealed({name:'Tom'}));//falseconsole.log("\n----------分割线----------\n");Object.keys(obj)
返回一个包含所有自有可枚举(可遍历)属性名称的数组。obj：待查询的对象,传入基本类型返回空数组[]
// Object.keys(obj) 返回一个包含所有自有可枚举(可遍历)属性名称的数组。obj：待查询的对象,传入基本类型返回空数组[]console.log(Object.keys({name:'Tom',age:18}));//['name','age']console.log("\n----------分割线----------\n");Object.values(obj)
返回一个包含所有自有可枚举(可遍历)属性值的数组。obj：待查询的对象,传入基本类型返回空数组[]
// Object.values(obj) 返回一个包含所有自有可枚举(可遍历)属性值的数组。obj：待查询的对象,传入基本类型返回空数组[]console.log(Object.values({name:'Tom',age:18}));//['Tom',18]console.log("\n----------分割线----------\n");Object.setPrototypeOf(obj, prototype)
设置对象obj的原型为prototype，并返回该对象。
通常，作为正确的方式，应该使用 Object.setPrototypeOf() 方法来设置对象的原型。因为 Object.prototype.__proto__ 访问器已被弃用。
如果传入基本类型，则直接返回该基本类型，不进行任何其他操作
更改对象的 [[Prototype]] 在各个浏览器和 JavaScript 引擎上都是一个很慢的操作，要顾及性能应避免修改原型属性
// Object.setPrototypeOf(obj, prototype)，设置对象obj的原型为prototype，并返回该对象。
// 通常，作为正确的方式，应该使用 Object.setPrototypeOf() 方法来设置对象的原型。因为 Object.prototype.__proto__ 访问器已被弃用。
// 如果传入基本类型，则直接返回该基本类型，不进行任何其他操作
// 更改对象的 [[Prototype]] 在各个浏览器和 JavaScript 引擎上都是一个很慢的操作，要顾及性能应避免修改原型属性const ob = {"0":0,"1":1}
Object.setPrototypeOf(ob,Array.prototype);
console.log(ob);//Array { '0': 0, '1': 1 }方法总览
// 新建一个对象const obj = {//通过{}name:'Tom',age:18
}
const obj1 = new Object({//通过构造函数name:'Tom',age:18
})
const obj2 = Object.create({ //通过静态方法name:'Tom',age:18
})//注意这里的参数不是生成对象的结果，参数会作为obj2的原型，obj2本身是一个新的空对象console.log(obj,obj1,obj2);console.log("\n----------分割线----------\n");// 实例属性// constructor 对象的实例属性
// 除了 null 原型对象之外，任何对象都会在其 [[Prototype]] 上有一个 constructor 属性。
// Object 实例的 constructor 数据属性返回一个引用，指向创建该实例对象的构造函数（函数本身而不是字符串）
// 可以用来判断对象类型
const arr = [];
const number = 1;
console.log(obj.constructor === Object);//true
console.log(arr.constructor === Array);//true
console.log(number.constructor === Number);//trueconsole.log("\n----------分割线----------\n");// 实例方法// hasOwnProperty(key) 方法会返回一个布尔值，如果自身有这个key属性（不包括原型中继承的属性），则返回 true，否则返回 false。
console.log({name:'Tom'}.hasOwnProperty('name'));//true
console.log({name:undefined}.hasOwnProperty('name'));//true,这里的name值虽然是undefined，但是属性存在
console.log(['Tom'].hasOwnProperty('0'));//true，数组也是对象，可以将索引看成key
console.log([].hasOwnProperty('length'));//true，数组固有的属性lengthconsole.log("\n----------分割线----------\n");// isPrototypeOf(obj) 返回布尔值 判断当前对象是否在obj的原型链中，（对象---原型链）
// 和object instanceof AFunction不同，这是比较两个对象的原型链 ，（原型链---原型链）
console.log(Object.prototype.isPrototypeOf({}));//true,Object出现在{}的原型链中
console.log(Array.prototype.isPrototypeOf([]));//true，Array出现在[]的原型链中console.log("\n----------分割线----------\n");// propertyIsEnumerable(prop) 方法返回一个布尔值，表示prop是否是对象的可枚举自有属性（遍历时是否会被访问，能否出现在for in循环中）
// 大多数内置属性默认情况下是不可枚举的，而用户创建的对象属性通常是可枚举的，除非明确指定为不可枚举。
console.log({name:'Tom'}.propertyIsEnumerable('name'));//true，name属性可以遍历
console.log(['0'].propertyIsEnumerable('0'));//true，索引属性可以遍历
console.log(['0'].propertyIsEnumerable('length'));//false，length属性不可遍历console.log("\n----------分割线----------\n");// toLocaleString() 返回一个字符串，返回调用toString（）的结果（return this.toString()）
console.log({name:'Tom'}.toLocaleString());//"[object Object]"console.log("\n----------分割线----------\n");// toString() 返回一个表示该对象的字符串。打印实例时默认调用该方法
console.log({name:'Tom'}.toString());//"[object Object]"console.log("\n----------分割线----------\n");// valueOf() 返回指定对象的原始值。值传递时可以使用valueOf将值提取出来
const obj3 = {name:'Tom'}
let newObj = obj3.valueOf();// 值传递，此时newObj和obj3并不是指向同一个内存
console.log(obj3.valueOf());// {name:'Tom'},返回对象本身的值
console.log(obj3.valueOf() === obj3);//trueconsole.log("\n----------分割线----------\n");// 静态方法// Object.assign(target, ...sources) 将source中所有可以遍历的键值对，放入target中，返回target
// target和source中相同的key，source中的值会覆盖target中的值
// target 待修改的对象 ，source 多个对象
console.log(Object.assign({},{name:'tom'},{age:'10'}));// {name:'tom',age:'10'}
console.log(Object.assign({},[1,2,3,4]));// {0:1,1:2,2:3,3:4}
console.log(Object.assign({},[1,2,3,4],'sss'));// { '0': 's', '1': 's', '2': 's', '3': 4 },字符串会被拆分成单个字符作为对象，后面的属性值会覆盖前面的console.log("\n----------分割线----------\n");// Object.create(proto) 静态方法以proto作为原型，创建一个新对象。
const obj4 = Object.create([]);//以[]作为原型，创建一个新对象,数组对象
console.log(obj4);//Array {}console.log("\n----------分割线----------\n");// Object.defineProperties(obj, props) 静态方法直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，并返回这个对象。
// obj:在其上定义或修改属性的对象; props: 一个对象，其中每个键表示要定义或修改的属性的名称，每个值是描述该属性的对象(是否只读，是否可枚举遍历，)
console.log(Object.defineProperties({name:'Tom'
},
{//属性描述对象name:{value:'Jerry',writable:true //可读写}
}));//{name:'Jerry'}console.log("\n----------分割线----------\n");// Object.defineProperty(obj, prop, descriptor) 静态方法会直接在obj上定义一个新属性prop，或修改其现有属性prop，并返回此对象。
// obj：待修改的对象 prop：obj对象待修改的属性名 descriptor：属性描述对象
console.log(Object.defineProperty({name:'Tom'},'name',{value:'Jerry'}));//{name:'Jerry'}console.log("\n----------分割线----------\n");// Object.entries(obj) 返回一个obj自身可枚举（可遍历）属性的键值对数组(元组)，
// 其排列与使用 for...in 循环遍历该对象时返回的顺序一致（区别在于 for...in 循环还会枚举其原型链中的属性）。
console.log(Object.entries({name:'Tom',age:18}));//[["name","Tom"],["age",18]]console.log("\n----------分割线----------\n");// Object.fromEntries(iterable) 将键值对列表(iterable)转换为一个对象。
// iterable：一个包含对象列表的可迭代对象，例如 Array 或者 Map。
// 每个对象都要有两个属性，0：表示属性键的字符串或者 Symbol。1：属性值。通常，该对象被实现为二元数组，第一个元素是属性键，第二个元素是属性值。console.log(Object.fromEntries([['name','Tom'],['age',18]]));//{name:'Tom',age:18}console.log("\n----------分割线----------\n");// Object.getOwnPropertyDescriptor(obj, prop) 返回obj上一个自有属性prop对应的属性描述对象，如果obj上没有prop属性返回undefined。
// obj:待查询的对象 prop：string或者symbol 待查询的属性名console.log(Object.getOwnPropertyDescriptor({name:'Tom'},'name'));
//{value:'Tom',writable:true,enumerable:true,configurable:true}console.log("\n----------分割线----------\n");// Object.getOwnPropertyDescriptors(obj) 返回obj的所有自有属性属性描述对象。obj：待查询的对象，类似于Object.getOwnPropertyDescriptorconsole.log(Object.getOwnPropertyDescriptors({name:'Tom',age:18}));//{name:{...},age:{...}}console.log("\n----------分割线----------\n");// Object.getOwnPropertyNames(obj) 返回obj对象的所有自身属性的属性名（包括不可枚举属性但不包括Symbol属性）组成的数组。console.log(Object.getOwnPropertyNames({name:'Tom',age:18}));//['name','age']console.log("\n----------分割线----------\n");// Object.getOwnPropertySymbols(obj) 返回obj对象自身的所有 Symbol 属性的数组。console.log(Object.getOwnPropertySymbols({[Symbol('name')]:1,[Symbol('age')]:2, name:'Tom',age:18}));//[Symbol(name),Symbol(age)]console.log("\n----------分割线----------\n");// Object.getPrototypeOf(obj) 返回obj对象的原型对象。即内部 [[Prototype]] 属性的值console.log(Object.getPrototypeOf({}));//Object
console.log(Object.getPrototypeOf([]));//Arrayconsole.log("\n----------分割线----------\n");// Object.groupBy(item, callback) 返回一个对象，对象内根据callback的返回值，将item进行分类。2024新增
// item：待分类的可迭代对象 callback：回调函数，返回值作为分类的依据// const items = [
// { name: "芦笋", type: "蔬菜", quantity: 5 },
// { name: "香蕉", type: "水果", quantity: 0 },
// { name: "山羊", type: "肉", quantity: 23 },
// { name: "樱桃", type: "水果", quantity: 5 },
// { name: "鱼", type: "肉", quantity: 22 },
// ];
// const result = Object.groupBy(items, ({type}) => type);//此方法目前只在浏览器支持
// console.log(result);//{蔬菜:{...},水果:{...},肉:{...}}// Object.hasOwn(obj, prop) 返回布尔值，检查obj对象自身是否具有指定的属性prop。Object.hasOwn() 旨在取代 Object.prototype.hasOwnProperty()。console.log(Object.hasOwn({name:'Tom'},'name'));//trueconsole.log("\n----------分割线----------\n");// Object.is(value1, value2) 返回布尔值,判断两个值是否为同一个值。
// Object.is() 与 == 运算符并不等价, 也不等价于 === 运算符,相比于 == Object.is()转换类型比较，相比于 === Object.is()不会忽略 +0 和 -0，也不会把 NaN 等于 NaN。
console.log(Object.is(1,1));//true
console.log(Object.is(NaN,NaN));//true , == 和 === 返回false
console.log(Object.is(0,-0));//false , == 和 === 返回trueconsole.log("\n----------分割线----------\n");// Object.preventExtensions(obj) 静态方法可以防止新属性被添加到obj中（即防止该对象被扩展）。它还可以防止对象的原型被重新指定。
// 在ES5中传入的值不是对象会直接报错，在ES6中传入的值不是对象会返回false
// Object.isExtensible(obj) 返回布尔值，判断对象是否可扩展（是否可以添加新的属性）。
// 在ES5中传入的值不是对象会直接报错，在ES6中传入的值不是对象会返回false
const extensibleObj = Object.preventExtensions({name:'Tom'});console.log(Object.isExtensible(extensibleObj));//false,不可扩展
console.log(Object.isExtensible({name:'Tom'}));//true
console.log(Object.isExtensible(1));//falseconsole.log("\n----------分割线----------\n");// Object.freeze(obj) 冻结obj对象并将其返回，
// 冻结指的是不能向这个对象添加新的属性，不能修改其已有属性的值，不能删除已有属性，以及不能修改该对象已有属性的可枚举性、可配置性、可写性，
// 即这个对象本身以及属性都不能在修改（新增、删除、添加、修改），但是，当属性是引用类型时可以修改引用类型内的属性和值（浅冻结，只影响一层）const obj5 = {//注意区分常量和冻结，常量表示的是obj5不能被复制，内部任然可以修改，（浅）冻结是内部的（一层）属性不能被修改name:'Tom',age:18,info:{//此处内部不受浅冻结影响，若要深冻结则需要遍历引用类型属性冻结address:'beijing'}
}console.log(Object.freeze(obj5) === obj5);//{name:'Tom',age:18}，返回冻结后的对象，和原对象一致// Object.isFrozen(obj) 返回布尔值，判断对象是否被冻结。
// 在ES5中传入的值不是对象会直接报错，在ES6中传入的值不是对象会返回false
const freezeObj = Object.freeze({name:'Tom'});
console.log(Object.isFrozen(freezeObj));//true
console.log(Object.isFrozen({name:'Tom'}));//false
console.log(Object.isFrozen(1));//falseconsole.log("\n----------分割线----------\n");// Object.seal(obj) 返回传递的对象，使obj密封。
// Object.isSealed(obj) 返回布尔值，判断对象是否被密封(不能添加，删除，修改)。
// 在ES5中传入的值不是对象会直接报错，在ES6中传入的值不是对象会返回false
const sealObj = Object.seal({name:'Tom'});
console.log(Object.isSealed(sealObj));//true
console.log(Object.isSealed({name:'Tom'}));//falseconsole.log("\n----------分割线----------\n");// Object.keys(obj) 返回一个包含所有自有可枚举(可遍历)属性名称的数组。obj：待查询的对象,传入基本类型返回空数组[]console.log(Object.keys({name:'Tom',age:18}));//['name','age']console.log("\n----------分割线----------\n");// Object.values(obj) 返回一个包含所有自有可枚举(可遍历)属性值的数组。obj：待查询的对象,传入基本类型返回空数组[]console.log(Object.values({name:'Tom',age:18}));//['Tom',18]console.log("\n----------分割线----------\n");// Object.setPrototypeOf(obj, prototype)，设置对象obj的原型为prototype，并返回该对象。
// 通常，作为正确的方式，应该使用 Object.setPrototypeOf() 方法来设置对象的原型。因为 Object.prototype.__proto__ 访问器已被弃用。
// 如果传入基本类型，则直接返回该基本类型，不进行任何其他操作
// 更改对象的 [[Prototype]] 在各个浏览器和 JavaScript 引擎上都是一个很慢的操作，要顾及性能应避免修改原型属性const ob = {"0":0,"1":1}
Object.setPrototypeOf(ob,Array.prototype);
console.log(ob);//Array { '0': 0, '1': 1 }