Object上的静态方法

摘要：挂在函数上的方法，称之为静态方法。方法返回一个由指定对象的所有自身属性的属性名包括不可枚举属性组成的数组。以上常用的方法合并或复制对象使用遍历对象使用创建对象使用以上如有偏差欢迎指正学习，谢谢。

内置提供了一个对象为 Object ，也被称之为是构造函数，用来创建对象用的。在 javascript 函数也是对象，是一种可被执行的对象，所以称Object为对象也是可以的。挂在函数上的方法，称之为静态方法。

如果对这个方法不了解，必须先看，下面的某些方法要定义不可枚举的属性时会用到。

移步阅读：https://segmentfault.com/a/1190000007434923

方法返回指定对象上一个自有属性对应的属性描述符。（自有属性指的是直接赋予该对象的属性，不需要从原型链上进行查找的属性）

属性描述符是一个对象，记录了此属性，是否可被枚举、是否可被删除、是否可被改写、属性的值。

let obj = {a:1,b:2};

console.log(Object.getOwnPropertyDescriptor(obj,"a"));

返回值是一个对象：

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

一般对象定义的属性，不使用 Object.defineProperty() 定义的，都是可被枚举、可被删除、可被改写。

方法返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性）组成的数组。

let obj = {
    a:1,
    b:2
}
console.log(Object.getOwnPropertyNames(obj)); //["a","b"]


Object.defineProperty(obj,"c",{
    enumerable: false
})

console.log(Object.getOwnPropertyNames(obj)); //["a","b","c"]

这个方法被经常用到，作用是将一个或多个对象可枚举的属性合并到目标对象上，返回为目标对象。

用法：

let target = {a:1};

let t = Object.assign(target,{b:1},{c:1})

console.log(target); // {a:1,b:1,c:1}
console.log(t); // {a:1,b:1,c:1}
console.log(target === t); // true

通过以上测试会发现，将多个对象的属性都合并到了对象 target 上，并且返回的依然是对象 target。
要注意，这种方式为浅拷贝（浅复制），遇到值为对象类型时，会引用相同的对象。

let target = {a:1};
let source = {b:1,users:["seven"]

Object.assign(target,source)

target.users.push("job"); 

console.log(target.users); // ["seven","job"]
console.log(source.users); // ["seven","job"]

以上的属性 users 对应的值为数组，数组是引用类型的值，并没有复制一份给到 target，所以对象 target 和 source 使用的是同一个对象。改变后会互相影响，如果要完全的脱离关系，可以选择深复制，利用 jQuery 的 extend 函数。

此函数常用的应用场景是覆盖函数定义的对象默认值，例如要封装一个 Ajax ,要传递很多个参数，某些参数是可选的，采用传递一个对象的方式更利于扩展：

function Ajax(options){
    let defautls = {
        method:"get",
        data:{},
        success(){},
        error(){}
    }
    Object.assign(defautls,options)
}
Ajax({
    method:"post"
})

对象属性是可选的，预先定义好默认值，当调用函数传递的属性覆盖掉默认设置的属性。

此方法用基于传入的参数对象作为原型来创建一个新对象。只能接受对象或者null作为参数。查看新对象的 proto 的值，为传入的参数对象。

let obj = {
    a:1,
    b:2
}
let newObject = Object.create(obj);

console.log(newObject.__proto__ === obj); // true

以上就是把 obj 对象作为新创建对象的原型。

也可以传入 null，意思是创建一个没有任何原型的对象，这样创建对象的方式更加高效。

应用场景为原型继承上，例如一个函数的原型需要继承另一个原型，就可以就可以基于一个原型对象创建一个新的对象，把新的对象赋值给另一个原型即可。

// 父类
function Person(){}
Person.prototype.say = function(){}

子类
function Coder(){}
// 需要继承父类Peroson原型对象
Coder.prototype = Object.create(Person.prototype.)

判断值是否相同，连一个奇葩的自身和自身不相等的 NaN 都可以判断为相同。

console.log(Object.is(1,1)); // true
console.log(Object.is(NaN,NaN)); //true

返回指定对象的原型对象，（内部[[Prototype]]属性的值）。[[Prototype]] 为内部使用的，我们一般使用 proto 这个浏览器提供的属性来获取对象的原型，但在 ES5 规范中 proto 并不是标准的属性，是浏览器为了方便开发者查看对象的原型提供的，因为这个属性使用起来方便，现在大多数浏览器都提供。如果要用规范方法获取原型对象，建议使用 Object.getPrototypeOf

console.log(Object.getPrototypeOf({}) === Object.prototype); // true

let obj = {a:1};
let newObj = Object.create(obj); // 基于obj为原型创建新的对象

console.log(Object.getPrototypeOf(newObj) === obj); // true
console.log(newObj.__proto__ === Object.getPrototypeOf(newObj)); // true

这个方法设置一个指定的对象的原型 ( 即, 内部[[Prototype]]属性）到另一个对象或 null。

let obj = {
    a:1,
    b:2
}

console.log(Object.getPrototypeOf(obj) === Object.prototype)

let newProto = {
    c:1
}

Object.setPrototypeOf(obj,newProto); // 把obj对象的原型设置为对象newProto

console.log(Object.getPrototypeOf(obj) === newProto); // true

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

要注意，Object.keys 方法不能遍历出不可枚举的属性,要遍历出不可枚举属性，可使用 Object.getOwnPropertyNames。

let obj = {
    a:1,
    b:2
}
Object.defineProperty(obj,"c",{
    enumerable: false
})

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

返回一个给定对象自身的所有可枚举属性值的数组。与使用 for...in 循环顺序保持一致，但 Object.values 不遍历原型链。
把对象的 value 值存放在一个数组中。

let obj = {
    a:1,
    b:2
}
console.log(Object.values(obj)); //[1,2]

返回一个给定对象自身可枚举属性的键值对数组,与使用 for...in 循环顺序保持一致，但 Object.entries 不遍历原型链。

let obj = {a:1,b:2};
let keyValueArr = Object.entries(obj);
console.log(keyValueArr); // 打印：[["a", 1],["b", 2]]

把对象的 key 和 value 存放在同一个数组中，第一项为 key ，第二项为 value 。

这个方法常常配合 for...of 语法使用来遍历对象，

let obj = {a:1,b:2};
for(let [key,value] of Object.entries(obj)){
    console.log(key,value); // "a",1;"b",2
}

[key,value] 形式为解构赋值，右侧 Object.entries(obj) 返回的是一个二维数组 [["a", 1],["b", 2]],这样每次拿到数组中的一项 ["a",1],利用解构赋值的形式，将数组第一项赋值给 key，第二项赋值给 value。

以上常用的方法：

合并或复制对象使用Object.assgin;

遍历对象使用 Object.keys

创建对象使用 Object.create

以上如有偏差欢迎指正学习，谢谢。