Object上的静态方法
内置提供了一个对象为 object ,也被称之为是构造函数,用来创建对象用的。在 javascript 函数也是对象,是一种可被执行的对象,所以称object为对象也是可以的。挂在函数上的方法,称之为静态方法。
object.defineproperty()
如果对这个方法不了解,必须先看,下面的某些方法要定义不可枚举的属性时会用到。
移步:https://segmentfault.com/a/1190000007434923
object.getownpropertydescriptor()
方法返回指定对象上一个自有属性对应的属性描述符。(自有属性指的是直接赋予该对象的属性,不需要从原型链上进行查找的属性)
属性描述符是一个对象,记录了此属性,是否可被枚举、是否可被删除、是否可被改写、属性的值。
let obj = {a:1,b:2};
console.log(object.getownpropertydescriptor(obj,'a'));
返回值是一个对象:
{
configurable: true
enumerable: true
value: 1
writable: true
}
一般对象定义的属性,不使用 object.defineproperty() 定义的,都是可被枚举、可被删除、可被改写。
object.getownpropertynames()
方法返回一个由指定对象的所有自身属性的属性名(包括不可枚举属性)组成的数组。
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']
object.assign()
这个方法被经常用到,作用是将一个或多个对象可枚举的属性合并到目标对象上,返回为目标对象。
用法:
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'
})
对象属性是可选的,预先定义好默认值,当调用函数传递的属性覆盖掉默认设置的属性。
object.create()
此方法用基于传入的参数对象作为原型来创建一个新对象。只能接受对象或者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.)
object.is
判断值是否相同,连一个奇葩的自身和自身不相等的 nan 都可以判断为相同。
console.log(object.is(1,1)); // true
console.log(object.is(nan,nan)); //true
object.getprototypeof()
返回指定对象的原型对象,(内部[[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
object.setprototypeof()
这个方法设置一个指定的对象的原型 ( 即, 内部[[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
object.keys
方法会返回一个由一个给定对象的自身可枚举属性组成的数组,数组中属性名的排列顺序和使用 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']
object.values
返回一个给定对象自身的所有可枚举属性值的数组。与使用 for...in 循环顺序保持一致,但 object.values 不遍历原型链。
把对象的 value 值存放在一个数组中。
let obj = {
a:1,
b:2
}
console.log(object.values(obj)); //[1,2]
object.entries
返回一个给定对象自身可枚举属性的键值对数组,与使用 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