object方法

1.Object.entries()

把一个对象的键值以数组的形式遍历出来，（不包括Symbol值的属性）。结果和 for...in 一致，但不会遍历原型属性。

var obj = {
    a: 1,
    b: 2,
    c: 3,
    [Symbol()]: 4
};
Object.entries(obj); // [["a", 1], ["b", 2], ["c", 3]]

（1）传入非对象的参数，强制类型转换为对象

var str = 'abcde';
Object.entries(str); 
// [["0", 'a'], ["1", 'b'], ["2", 'c'], ["3", 'd'], ["4", 'e']]

2.Object.fromEntries()

把Object.entries转换后的二维数组重新转换为对象

let obj = { 'a': 1, "b": 2, "c": 3 };

let obj1 = Object.entries(obj); //[["a", 1],["b", 2],["c", 3]]

let obj2 = Object.fromEntries(obj1) //{ a: 1, b: 2, c: 3 }

3.Object.values()

遍历对象，返回对象所有value值，组成数组。

返回所有可枚举属性值对象的数组，（不包括Symbol值的属性）。

let obj1 = { 'a': 1, "b": 2, "c": 3 };

Object.values(obj1); //[1,2,3]



var obj2 = {
    a: 1,
    b: 2,
    c: 3,
    [Symbol()]: 4
};
Object.values(obj2); // [1, 2, 3]

（1）传入非对象的参数，强制类型转换为对象。

var str = 'abcde';
Object.values(str); // ["a", "b", "c", "d", "e"]

 4.Object.keys()

遍历对象，返回对象所有key，组成数组。

返回一个给定对象的属性名数组。

var data = {'name':'zhang','age':22,'sex':'man'}

console.log(data)  //{name: "zhang", age: 22, sex: "man"}

console.log(Object.keys(data))  //(3) ["name", "age", "sex"]

Object.keys(data).forEach((key,index)=>{

	console.log(key)  //name age sex

	console.log(data[key])  //zhang 22 man
})


let obj = { 'a': 1, "b": 2, "c": 3 };

Object.keys(obj); //["a", "b", "c"]

 （1）处理对象，返回可枚举的属性数组。

let person = {
    name:"张三",
    age:25,
    address:"深圳",
    getName:function(){
         }
    }
Object.keys(person) // ["name", "age", "address","getName"]

 （2）处理数组，返回索引值数组。

let arr = [1,2,3,4,5,6]
Object.keys(arr) // ["0", "1", "2", "3", "4", "5"]

 （3）处理字符串，返回索引值数组。

let str = "saasd字符串"
Object.keys(str) // ["0", "1", "2", "3", "4", "5", "6", "7"]

 5.Object.create()

创建对象，带着指定的原型对象和属性。

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

用我理解的话来说，就是把现有对象的属性，挂到新建对象的原型上（__proto__指向原型），新建的对象享有现有对象的属性。

1、Object.create() 是把现有对象的属性，挂到新建对象的原型上，新建对象为空对象

2、Object.create() 的第二个参数，为添加的可枚举属性（即自身属性，不是原型上的）

可以把Object.create()的参数理解为：第一个参数是放在新对象的原型上的，第二个参数是放在新对象的实例上的。

创建对象的方式不同

// new Object() 方式创建
var a = {  rep : 'apple' }
var b = new Object(a)
console.log(b) // {rep: "apple"}
console.log(b.__proto__) // {}
console.log(b.rep) // {rep: "apple"}


// Object.create() 方式创建
var a = { rep: 'apple' }
var b = Object.create(a)
console.log(b)  // {}
console.log(b.__proto__) // {rep: "apple"}
console.log(b.rep) // {rep: "apple"}

Object.create()方法创建的对象时，属性是在原型下面的，
也可以直接访问 b.rep // {rep: "apple"} ,
是它通过原型链proto来访问到b的值。

 创建对象属性的性质不同

// 创建一个以另一个空对象为原型,且拥有一个属性p的对象
o = Object.create({}, { p: { value: 42 } })

// 省略了的属性特性默认为false,所以属性p是不可写,不可枚举,不可配置的:
o.p = 24
o.p  //42

o.q = 12
for (var prop in o) {
   console.log(prop)
}
//"q"

delete o.p  //false


Object.create() 用第二个参数来创建非空对象的属性描述符默认是为false的，
而构造函数或字面量方法创建的对象属性的描述符默认为true

6.Object.assign()

复制一个对象（浅拷贝）/合并对象，

语法：Object.assign(对象1，对象2，对象3};

let obj = { 'a': 1, "b": 2, "c": 3 };

let objA = { name: "cao" }

Object.assign({}, obj); //{ a: 1, b: 2, c: 3 }

Object.assign(obj, objA); //{a: 1, b: 2, c: 3, name: "cao"}


obj //{a: 1, b: 2, c: 3, name: "cao"}
objA  //{name: 'cao'}

（1）是ES6新添加的接口，主要的用途是用来合并多个JavaScript的对象。
（2）Object.assign()接口可以接收多个参数，第一个参数是目标对象，后面的都是源对象，assign方法将多个源对象的属性和方法都合并到了目标对象上面，如果在这个过程中出现同名的属性（方法），后合并的属性（方法）会覆盖之前的同名属性（方法）。

基本用法如下：

var target  = {a : 1}; //目标对象
var source1 = {b : 2}; //源对象1
var source2 = {c : 3}; //源对象2
Object.assign(target,source1,source2);  //{a:1,b:2,c:3}

target //{a:1,b:2,c:3}

assign的设计目的是用于合并接口的，所以它接收的第一个参数（目标）应该是对象，如果不是对象的话，它会在内部转换成对象，所以如果碰到了null或者undefined这种不能转换成对象的值的话，assign就会报错。但是如果源对象的参数位置，接收到了无法转换为对象的参数的话，会忽略这个源对象参数。如：
 

const v1 = 'abc';
const v2 = true;
const v3 = 10;
const obj = Object.assign({}, v1, v2, v3);
console.log(obj); // { "0": "a", "1": "b", "2": "c" }

 为什么会出现这个结果呢？首先，第一个参数位置接收到的是对象，所以不会报错，其次，由于字符串转换成对象时，会将字符串中每个字符作为一个属性，所以，abc三个字符作为“0”，“1”，“2”三个属性被合并了进去，但是布尔值和数值在转换对象时虽然也成功了，但是属性都是不可枚举的，所以属性没有被成功合并进去。在这里需要记住 “assign不会合并不可枚举的属性”。
 

Object(true) // {[[PrimitiveValue]]: true}
Object(10)  //  {[[PrimitiveValue]]: 10}
Object('abc') // {0: "a", 1: "b", 2: "c", length: 3, [[PrimitiveValue]]: "abc"}

 上面就是对于布尔值、数值和字符串转换成对象后得到的结果。
同样，Object.assign拷贝的属性是有限制的，只会拷贝对象本身的属性（不会拷贝继承属性），也不会拷贝不可枚举的属性。但是属性名为Symbol值的属性，是可以被Object.assign拷贝的。
如果assign只接收到了一个对象作为参数的话，就是说没有源对象要合并到目标对象上，那会原样把目标对象返回。

1、Object.assign进行的拷贝是浅拷贝。也就是说，如果拷贝过来的属性的值是对象等复合属性，那么只能拷贝过来一个引用。

const obj1 = {a: {b: 1}};
const obj2 = Object.assign({}, obj1);
obj1.a.b = 2;
obj2.a.b // 2

 2、Object.assign进行合并的时候，一旦碰到同名属性，就会出现覆盖现象。所以使用时务必小心。

var target  = {a : 1}; //目标对象
var source1 = {b : 2}; //源对象1
var source2 = {c : 3}; //源对象2
var source3 = {c : 4}; //源对象3，和source2中的对象有同名属性c
Object.assign(target,source1,source2,source3);
//结果如下：
//{a:1,b:2,c:4}

3、Object.assign是针对Object开发的API，一旦在源对象的参数未知接收到了其他类型的参数，会尝试类型转换。如果是数组类型的话，类型转换的结果是将每个数组成员的值作为属性键值，将数组成员在数组中的位置作为属性键名。多个数组组成参数一同传入的话还会造成覆盖。具体例子如下：
 

Object.assign([1, 2, 3], [4, 5])
// [4, 5, 3]

assign把数组视为属性名为 0、1、2 的对象，因此源数组的 0 号属性4覆盖了目标数组的 0 号属性1。

Object.assign只能将属性值进行复制，如果属性值是一个get（取值函数）的话，那么会先求值，然后再复制。

// 源对象
const source = {
   //属性是取值函数
   get foo(){return 1}
};
//目标对象
const target = {};
Object.assign(target,source);
//{foo ; 1}  此时foo的值是get函数的求值结果

Object.assign方法的常见用途

1、为对象添加属性，下面的方法可以为对象Point类的实例对象添加属性x和属性y。

class Point{
   constructor(x,y){
      Object.assign(this,{x,y});
   }
}

2、为对象添加方法，将方法添加到类的原型对象上后，类的实例能继承这两个方法。

// 方法也是对象
// 将两个方法添加到类的原型对象上
// 类的实例会有这两个方法
Object.assign(SomeClass.prototype,{
    someMethod(arg1,arg2){...},
    anotherMethod(){...}
});

 3、克隆对象

//克隆对象的方法
function clone(origin){
    //获取origin的原型对象
    let originProto = Obejct.getPrototypeOf(origin);
    //根据原型对象，创建新的空对象，再assign
    return Object.assign(Object.create(originProto),origin);
}

 4、为属性指定默认值

// 默认值对象
const DEFAULTS = {
   logLevel : 0,
   outputFormat : 'html'
};
// 利用assign同名属性会覆盖的特性，指定默认值，如果options里有新值的话，会覆盖掉默认值
function processContent(options){
   options = Object.assign({},DEFAULTS,options);
   console.log(options);
   //...
}

处于assign浅拷贝的顾虑，DEFAULTS对象和options对象此时的值最好都是简单类型的值，否则函数会失效。

const DEFAULTS = {
  url: {
    host: 'example.com',
    port: 7070
  },
};
processContent({ url: {port: 8000} })
// {
//   url: {port: 8000}
// }

7.Object.is()

ES5 比较两个值是否相等，只有两个运算符：相等运算符（==）和严格相等运算符（===）。它们都有缺点，前者会自动转换数据类型，后者的NaN不等于自身，以及+0等于-0。JavaScript 缺乏一种运算，在所有环境中，只要两个值是一样的，它们就应该相等。

 比较两个值是否一样，与===类似 

 Object.is(不同的是 -0 != +0 ,NAN==NAN)

 Object.is(-0, +0);//false

 Object.is(NaN, NaN);//true

 
 NaN == NaN//false

 - 0 == +0;//true

ES6 提出“Same-value equality”（同值相等）算法，用来解决这个问题。Object.is就是部署这个算法的新方法。它用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致。

 

Object.is('foo', 'foo') // true 
Object.is({}, {}) // false 

不同之处只有两个：一是+0不等于-0，二是NaN等于自身。

 

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

 

 8.Object.getOwnPropertyDescriptor()

查找对象指定的属性，有就返回相应数据，没有返回undfined

let obj = { 'a': 1, "b": 2, "c": 3 };

Object.getOwnPropertyDescriptor(obj, 'a');

//{value: 1, writable: true, enumerable: true, configurable: true}


Object.getOwnPropertyDescriptor(obj, 'test');

//undfined

9.Object.getOwnPropertyDescriptors()

返回对象的所有属性的属性描述符，没有属性返回{}

 

let obj = { 'a': 1, "b": 2, "c": 3 };

Object.getOwnPropertyDescriptors(obj);

//{

      a: {value: 1, writable: true, enumerable: true, configurable: true},

      b: {value: 2, writable: true, enumerable: true, configurable: true}，

      c: {value: 3, writable: true, enumerable: true, configurable: true}，

     }

Object.getOwnPropertyDescriptors({});

//{}

10.Object.getOwnPropertyNames()

遍历对象，返回对象所有key，组成数组,与Object.keys()效果一致

let obj = { 'a': 1, "b": 2, "c": 3 };

Object.getOwnPropertyNames(obj);

//["a", "b", "c"]

11.Object.getPrototypeOf()

该方法返回对象的原型对象，如果没有的话，则返回null

let obj = { 'a': 1, "b": 2, "c": 3 };

Object.getPrototypeOf(obj);