常用的对象方法帮助快速理解

Object.assign()方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。

const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };
const returnedTarget = Object.assign(target, source);
console.log(target);// { a: 1, b: 4, c: 5 }
console.log(returnedTarget); // { a: 1, b: 4, c: 5 }
console.log(target === returnedTarget) //true

Object.create()方法创建一个新对象,使用现有的对象来提供新创建对象的proto。

const person={
    isHuman:false,
    printIntroduction:function(){
        console.log(this.isHuman)
    }
}
const me = Object.create(person);
me.name = "Mattew" // name被设置到me上person没有变
me.isHuman = true // 属性可以被重写

me.printIntroduction() //true
person.perintIntroduction() //false

Object.defineProperties()方法直接在一个对象上定义新的属性或修改现有属性,并返回该对象。
语法 Object.defineProperties(obj, props) obj在其上定义或修改属性的对象。props要定义其可枚举属性或修改的属性描述符的对象。对象中存在的属性描述符主要有两种：数据描述符和访问器描述符（可参照Object.defineProperty()）。描述符具有以下键:configurabletrue 当且仅当该属性描述符的类型可以被改变并且该属性可以从对应独享中删除。默认为false；emumerabletrue当且仅当在枚举对象上的属性时该属性显现。默认为false；value与属性关联的值。可以是任何有效的JavaScript值(数字，对象，函数等)。默认为undefained；writeabletrue当且仅当与该属性相关联的值可以用assignment operator改变时。默认为false。get作为该属性的getter函数，如果没有getter则为undefined。函数返回值被用作属性的值。默认为undefined；set作为属性的setter函数，如果没有setter则为undefined。函数将仅接受参数赋值给该属性的新值。默认为undefined；返回值节 传递给函数的对象。

var obj={}
ObjectdefineProperties(obj,{
    'property1':{
        value:true,
        writeable:true,
        set:function(value){
            console.log(1)
            this.value=value
        }
    },
    'property2':{
        value:'Hello',
        writeable:false
    }
})

Object.defineProperty()方法会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，并返回这个对象。
语法Object.defineProperty(obj,prop,descriptor) obj要再其上定义属性的对象。prop要定义或修改的属性的名称。descriptor将定义或修改的属性描述符。返回值节 被传递给函数的对象。在ES6中，由于Symbol类型的特殊性，用Symbol类型的值来做对象的key与常规的定义或修改不同，而Object.defineProperty是定义key为Symbol的值来做对象的key与常规的定义或修改不同，而Object.defineProperty是定义key为Symbol的属性的方法之一。

Object.entries()方法返回一个给定对象自身可枚举属性的键值对数组，其排列与使用for…in 循环遍历该对象时返回的顺序一致（区别在于for-in循环也枚举原型链中的属性）

const object = { name: 'zhangsan', age: 12 }
console.log(Object.entries(object))// [['name', 'zhangsan'], ['age', 12]]

Object.freeze()方法可以冻结一个对象。一个被冻结的对象再也不能被修改;冻结一个对象则不能向这个对象添加新的属性，不能删除已有属性，不能修改该对象已有属性的可枚举型、可配置性、可写行,以及不能修改已有属性的值。此外，冻结一个对象后该对象的原型也不能被修改。freeze()返回和传入的参数相同的对象。

const person = {name: '张三', age: 12 }
const person2 = Object.freeze(person)
person.name = '李四' // {name: '张三', age: 12 }
person === person2 // true

Object.fromEntries()把键值对列表转换为一个对象。

Map 转化为 Object
通过 Object.fromEntries,可以将Map转化为Object

const map = new Map([ ['name', '张三'], ['age', 12]])
const obj = Object.fromEntries(map)
console.log(obj) // {name: "张三", age: 12}


Array 转化为 Object
const arr = [ ['0', 'a'], ['1', 'b'], ['2', 'c']]
const obj1 = Object.fromEntries(arr) // {0: "a", 1: "b", 2: "c"}

对象转换为 Object
Object.fromEntries 是 Object.entries()的反转函数，借用 array  manipulation methods 可以转化对象

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

Onject.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) // true
Object.is(null, null) // true

Object.is(0, -0); // false
Object.is(-0, -0); // true
Object.is(NaN, 0/0); // true

Onject.isForzen() 方法判断一个对象是否被冻结

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

// 一个冻结对象也是一个密封对象。
Object.isSealed(forzen) // === true

// 当然更是一个不可拓展对象
Object.isExtensible(forzen) // === false
在ES5中,如果参数不是一个对象类型,将跑出一个TypeError异常。在ES2015中, 非对象参数将被视为一个冻结的普通对象,因此会返回true。

Object.isFrozen(1);
// TypeError: 1 is not an object (ES5 code)

Object.isFrozen(1);
// true (ES2015 code)

Object.keys() 方法会返回一个由一个给定对象的自身可枚举属性组成的数组,数组中属性名的排列顺序和试用for…in 循环遍历该对象时返回的顺序一致。

// simple array
var arr = [‘a’, ‘b’, ‘c’];
console.log(Object.keys(arr)); // [‘0’, ‘1’, ‘2’]

// array like object
var obj = {0: ‘a’, 1: ‘b’, 2: ‘c’};
console.log(Object.keys(obj)); // [‘0’, ‘1’, ‘2’]

// array like object with random key ordering
var anObj = {100: ‘a’, 2: ‘b’, 7: ‘c’};
console.log(Object.keys(anObj)); // [‘2’, ‘7’, ‘100’]

// getFoo is a property which isn’t enumerable
var myObj = Object.create({}, {
getFoo: {
value: function (){ return this.foo};
}
});
myObj.foo = 1;
console.log(Object.keys(myObj)); // [‘foo’]

Object.values()方法返回一个给定对象自身的所有可枚举属性值的数组，值的顺序与使用for…in循环的顺序相同(区别在于for…in循环枚举原型链中的属性)

var onj = {foo :’bar’, baz: 42};
console.log(Object.Values(obj)); // [‘bar’, 42]

// array like object
var obj = { 0: ‘a’, 1: ‘b’, 2: ‘c’};
console.log(Object.values(obj)); // [‘a’, ‘b’, ‘c’]

// array like object with random key ordering

// when we use numeric keys, the value returned in a numerical order according to the keys

var an_obj = {100: ‘a’, 2: ‘b’, 7: ‘c’};
console.log(Object.values(an_obj)); // [‘b’, ‘c’, ‘a’]

// getFoo is property which isn’t enumerable

var my_obj = Object.create({}, {getFoo:{value:function(){ return this.foo; }}});

my_obj.foo = ‘bar’;
console.log(Object.values(my_obj)); // [‘bar’]

// non-object argument will be coerced to an object
console.log(Object.values(‘foo’)); // [‘f’, ‘o’, ‘o’]