查看对象的方法，console.dir()控制台输出，如图：
hasOwnProperty()：返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）。
let object1 = new Object();
object1.property1 = 42;
object1.hasOwnProperty('property1'); // true
object1.hasOwnProperty('toString'); // false
isPrototypeOf()：用于测试一个对象是否存在于另一个对象的原型链上。
function Foo() {}
function Bar() {}
function Baz() {}
Bar.prototype = Object.create(Foo.prototype);
Baz.prototype = Object.create(Bar.prototype);
let baz = new Baz();
Baz.prototype.isPrototypeOf(baz); // true
Bar.prototype.isPrototypeOf(baz); // true
Foo.prototype.isPrototypeOf(baz); // true
Object.prototype.isPrototypeOf(baz); // true
toString()：返回一个表示该对象的字符串。
let o = new Object();
o.toString(); // '[object Object]'
valueOf()：返回指定对象的原始值。
let o = new Object();
o.valueOf(); // {}
通过console.dir()方法继续输出
Object.assign()：用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。
let target = { a: 1, b: 2 };
let source = { b: 4, c: 5 };
let returnedTarget = Object.assign(target, source);
target; // { a: 1, b: 4, c: 5 }
returnedTarget; // { a: 1, b: 4, c: 5 }
Object.create()：创建一个新对象，使用现有的对象来提供新创建的对象的__proto__。即创建一个以指定的对象为原型的子对象。
Object.setPrototypeOf()：设置一个指定的对象的原型 ( 即, 内部[[Prototype]]属性）到另一个对象或null。
Object.getPrototypeOf()：返回指定对象的原型（内部[[Prototype]]属性的值)。
let person = {name: 'people'};
let me = Object.create(person);
me.name; // 'people'
let proto = {};
let obj = { x: 10 };
Object.setPrototypeOf(obj, proto);
proto.y = 20;
proto.z = 40;
obj.x // 10
obj.y // 20
obj.z // 40
let p = Object.getPrototypeOf(obj);
proto === p; // true
Object.defineProperties()：直接在一个对象上定义新的属性或修改现有属性，并返回该对象。
let obj = {};
Object.defineProperties(obj, {
'property1': {
value: true,
writable: true
},
'property2': {
value: 'Hello',
writable: false
}
});
obj.property1; // true
obj.property2; // 'Hello'
Object.defineProperty()：会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性， 并返回这个对象。
let o = {};
let bValue = 1;
Object.defineProperty(o, "b", {
get : function(){
return bValue;
},
set : function(newValue){
bValue = newValue;
console.log('bValue变了');
},
enumerable : true,
configurable : true
});
console.log(o.b); //1
o.b = 2; //'bValue变了'
Object.keys()：会返回一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和使用for...in循环遍历该对象时返回的顺序一致 。
Object.values()：返回一个给定对象自身的所有可枚举属性值的数组，值的顺序与使用for...in循环的顺序相同 ( 区别在于 for-in 循环枚举原型链中的属性 )。
Object.entries()：返回一个给定对象自身可枚举属性的键值对数组，其排列与使用for...in循环遍历该对象时返回的顺序一致（区别在于 for-in 循环还会枚举原型链中的属性）。
Object.fromEntries()：把键值对列表转换为一个对象，是Object.entries()的逆操作。
let obj = { a: 1, b: 2, c: 3 };
let keys = Object.keys(obj);
let values = Object.values(obj);
let entries = Object.entries(obj);
keys; // ['a','b','c']
values; // [1,2,3]
entries; // [['a',1],['b',2],['c',3]]
let fromEntries = Object.fromEntries(entries);
fromEntries; // {a: 1, b: 2, c: 3}
Object.is()：判断两个值是否是相同的值。
Object.is('foo', 'foo'); // true
Object.is(window, window); // true
Object.is('foo', 'bar'); // false
Object.is([], []); // false
var foo = { a: 1 };
var bar = { a: 1 };
Object.is(foo, foo); // true
Object.is(foo, bar); // false
Object.is(null, null); // true
// 特例
Object.is(0, -0); // false
Object.is(0, +0); // true
Object.is(-0, -0); // true
Object.is(NaN, 0/0); // true
Object.freeze()：用于冻结一个对象，使其属性不可修改。当一个对象被冻结后，无法添加、删除或修改它的属性和方法，也无法修改它的原型链。这样可以确保对象的值不会被无意间更改。
注意，该方法只能冻结对象的第一层属性，如果对象的某个属性是一个引用类型的值，那么该值仍然可以被修改。如果需要深度冻结一个对象及其所有属性，可以使用第三方库或自己实现递归冻结。
Object.isFrozen()：方法检查一个对象是否被冻结。
const obj = {a: 1, b: 2};
Object.freeze(obj); // 冻结对象
obj.a = 3; // 无效操作，对象不可修改
console.log(obj); // 输出 {a: 1, b: 2}
console.log(Object.isFrozen(obj)); // 输出 true
Object.isExtensible()：用于检查一个对象是否可扩展。如果一个对象可扩展，那么可以添加新属性和方法到对象上；如果一个对象不可扩展，那么无法添加新属性和方法到对象上。
注意，该方法只能检查一个对象当前是否可扩展，不能检查对象的原型链是否可扩展。此外，一旦一个对象不可扩展，就无法再将其设为可扩展。如果需要为一个不可扩展的对象添加新属性和方法，可以通过将该对象复制一份并添加新属性和方法来实现。
Object.preventExtensions()：防止对象添加新属性。
const obj1 = {a: 1, b: 2};
console.log(Object.isExtensible(obj1)); // 输出 true
Object.preventExtensions(obj1); // 防止对象扩展
console.log(Object.isExtensible(obj1)); // 输出 false
Object.seal()：用于密封一个对象，使其属性不可删除且不可添加。当一个对象被密封后，可以修改已有属性的值，但无法删除属性，也无法添加新属性。
注意，Object.seal()只能密封对象的第一层属性，如果对象的某个属性是一个引用类型的值，那么该值仍然可以被修改。如果需要深度密封一个对象及其所有属性，可以使用第三方库或自己实现递归密封。同时需要注意，一旦一个对象被密封后，也无法再将其设为可删除或可添加属性，因此Object.seal()是一个比Object.freeze()更严格的方法。
Object.isSealed(obj)：判断对象是否被密封。
const obj = {a: 1, b: 2};
Object.seal(obj); // 密封对象
delete obj.a; // 无效操作，属性不可删除
obj.b = 3; // 有效操作，属性可修改
obj.c = 4; // 无效操作，属性不可添加
console.log(obj); // 输出 {a: 1, b: 3}
console.log(Object.isSealed(obj)); // 输出 true
