对象Object:
- 常用方法
- Object.assign(target, ...sources)
- Object.is(value1, value2)
- Object.create()
- Object.getOwnPropertyNames()
- Object.keys()
- Object.values()
- Object.entries()
- Object.fromEntries()
- Object.defineProperty(obj, prop, descriptor)
- Object.getOwnPropertyDescriptor(obj, prop)
- Object.getOwnPropertyDescriptors(obj)
- Object.hasOwn(obj,prop)
- Object.prototype.hasOwnProperty()
常用方法
Object.assign(target, …sources)
介绍:此方法将所有可枚举(Object.propertyIsEnumerable() 返回 true)和自有(Object.hasOwnProperty() 返回 true)属性从一个或多个源对象复制到目标对象,返回修改后的对象。(修改目标对象)
/**
*target:目标对象,也是修改后的返回值。
*source:源对象,包含将被合并的属性。可以多个
*/
var target = { a:"1",b:"2"}
var source = {b:"3",c:"4"}
var result = Object.assign(target,source)
console.log(target) // {a:"1",b:"3",c:"4"}
console.log(result) // {a:"1",b:"3",c:"4"}
console.log(result === target) // true
typeof Object.assign(2) // "object"
Object.assign(undefined) // 报错
Object.assign(null) // 报错
如果该参数不是对象,则会先转成对象,然后返回。
Object.assign(2) // 2
typeof Object.assign(2) // "object"
由于undefined和null无法转成对象,所以如果它们作为参数,就会报错。
Object.assign(undefined) // 报错
Object.assign(null) // 报错
undefined和null不在首参数,就不会报错,将会跳过。
Object.assign({},undefined,null) // 不报错
其他类型的值(即数值、字符串和布尔值)不在首参数,也不会报错。
但是,除了字符串会以数组形式,拷贝入目标对象,其他值都不会产生效果。
const obj1= { a: 1, b: 2 };
const obj2= 10;
const obj3= true;
const obj4= "abc"
Object.assign(obj2); // 10
Object.assign(obj1,obj2); // { a: 1, b: 2 } 不报错
Object.assign(obj3,obj2); // true
Object.assign(obj4,obj2,obj3); // { "abc" }
Object.assign({},obj4,obj2,obj3); // { 0: "a", 1: "b", 2: "c" }
可以用来处理数组,但是会把数组视为对象。
Object.assign([1, 2, 3], [4, 5]) // [4, 5, 3]
只能进行值的复制,如果要复制的值是一个取值函数,那么将求值后再复制。
若复制的值是一个赋值或取值函数,则为undefined
const target = {};
const source = {
get foo() { return 1 }
set bar(value) {}
};
Object.assign(target, source) //{ foo: 1 ,bar: undefined}
Object.is(value1, value2)
判断两个值是否为同一个值。
返回值:一个布尔值
Object.is(null, null); // true
Object.is(undefined, undefined); // true
var foo = { a: 1 };
var bar = { a: 1 };
Object.is(foo, bar); // false
Object.is(0, -0); // false
Object.is(+0, -0); // false
Object.is(-0, -0); // true
Object.is(NaN, 0/0); // true
Object.is(NaN, Number.NaN) // true
Object.create()
方法用于创建一个新对象,使用现有的对象来作为新创建对象的原型(prototype)。
返回值:一个新对象,带着指定的原型对象及其属性。
// obj将在原型对象上,而不是直接属性
var Obj ={
name:'zhangsan',
age:18,
show:function () {
console.log(this.name +" is " +this.age);
}
}
var MyObj = Object.create(Obj,{
hobby:{
value:"football", // 初始化赋值
writable:true, // 是否是可改写的
configurable:true, // 是否能够删除,是否能够被修改
enumerable:true //是否可以用for in 进行枚举
}
})
注意:Object.create(null) 创建的对象是一个空对象,在该对象上没有继承 Object.prototype 原型链上的属性或者方法
Object.create(null) //{}
new Object() // {[[Prototype]]: Object}
var obj = {} // {[[Prototype]]: Object}
Object.getOwnPropertyNames()
方法返回一个由 指定对象的所有自身属性的属性名(包括不可枚举属性但不包括 Symbol 值作为名称的属性) 组成的数组。
注意:该方法不会获取到原型链上的属性
var arr = ["a", "b", "c"];
console.log(Object.getOwnPropertyNames(arr)); // ["0", "1", "2", "length"]
var obj = { 0: "a", 1: "b", 2: "c"};
console.log(Object.getOwnPropertyNames(obj)); // ["0", "1", "2"]
Object.keys()
返回一个数组,成员是参数对象自身的 (不含继承的) 所有 可遍历(enumerable) 属性的键名。
注意:在 ES5 里,如果此方法的参数不是对象(而是一个原始值),那么它会抛出 TypeError。在 ES2015 中,非对象的参数将被强制转换为一个对象。
var obj = { foo: 'bar', baz: 42 };
Object.keys(obj) // ["foo", "baz"]
Object.keys("foo"); // TypeError: "foo" is not an object (ES5 code)
Object.keys("foo"); // ["0", "1", "2"] (ES2015 code)
Object.values()
返回一个数组,成员是参数对象自身的 (不含继承的) 所有 可遍历(enumerable) 属性的键值。
如果参数是一个字符串,会返回各个字符组成的一个数组。
如果参数不是对象,Object.values会先将其转为对象。由于数值和布尔值的包装对象,都不会为实例添加非继承的属性。所以,Object.values会返回空数组。
属性名为数值的属性,是按照数值大小,从小到大遍历的
const obj = { foo: 'bar', baz: 42 };
Object.values(obj) // ["b", "c", "a"]
Object.values('foo') // ['f', 'o', 'o']
Object.values(42) // []
Object.values(true) // []
Object.values({ 100: 'a', 2: 'b', 7: 'c' }) // ["b", "c", "a"]
Object.entries()
返回一个数组,成员是参数对象自身的 (不含继承的) 所有 可遍历(enumerable) 属性的键值对数组。
const obj = { foo: 'bar', baz: 42 };
Object.entries(obj) // [ ["foo", "bar"], ["baz", 42] ]
基本用途是遍历对象的属性。
let obj = { one: 1, two: 2 };
for (let [k, v] of Object.entries(obj)) {
console.log(
`${JSON.stringify(k)}: ${JSON.stringify(v)}`
);
}
// "one": 1
// "two": 2
Object.fromEntries()
此方法是Object.entries()的逆操作,用于将一个键值对数组转为对象。
Object.fromEntries([
['foo', 'bar'],
['baz', 42]
])
// { foo: "bar", baz: 42 }
Object.defineProperty(obj, prop, descriptor)
方法会直接在一个对象上定义一个新属性,或者修改一个对象的现有属性,并返回此对象。
descriptor属性介绍:
value: 该属性对应的值。可以是任何有效的 JavaScript 值(数值,对象,函数等)。默认为 undefined
configurable: 仅当该属性的 configurable 为 true 时,该属性才能够被改变,也能够被删除。默认为 false
enumerable: 仅当该属性的 enumerable 为 true 时,该属性才能够出现在对象的枚举属性中。默认为 false
writable: 仅当仅当该属性的writable为 true 时,该属性才能被赋值运算符改变。默认为 false
get: 一个给属性提供 getter 的方法,如果没有 getter 则为 undefined。该方法返回值被用作属性值。undefined
set: 一个给属性提供 setter 的方法,如果没有 setter 则为 undefined。该方法将接受唯一参数,并将该参数的新值分配给该属性。默认为undefined。
注意:value和writable不能与get/set同时存在。
/**
* obj:要定义属性的对象。
* prop:对象中要定义或修改的属性
* descriptor:属性描述
*/
let obj = {}
Object.defineProperty(obj, 'myProp', {
value: 42,
writable: true,
configurable:true,
enumerable:true,
get:function(){
},
set:function(value){
}
});
Object.getOwnPropertyDescriptor(obj, prop)
方法会返回某个对象属性的描述对象(descriptor)
/**
* obj:需要查找的目标对象
* prop:对象的属性名
*/
let obj = {
name:"zhangsan"
}
Object.getOwnPropertyDescriptor(obj,"name")
//{ value: "zhangsan", writable: true, enumerable: true, configurable: true }
Object.getOwnPropertyDescriptors(obj)
返回指定对象 所有 自身属性(非继承属性)的描述对象。
const obj = {
foo: 123,
get bar() { return 'abc' }
};
Object.getOwnPropertyDescriptors(obj)
// { foo:
// { value: 123,
// writable: true,
// enumerable: true,
// configurable: true },
// bar:
// { get: [Function: get bar],
// set: undefined,
// enumerable: true,
// configurable: true } }
该方法的引入目的,主要是为了解决Object.assign()无法正确拷贝get属性和set属性的问题。
let obj = {
set foo(value){}
}
let res = Object.defineProperties({}, Object.getOwnPropertyDescriptors(obj))
Object.getOwnPropertyDescriptors(res)
// { get: undefined,
// set: [Function: set foo],
// enumerable: true,
// configurable: true }
Object.hasOwn(obj,prop)
可以判断是否为自身的属性。
/**
* obj:需要查找的目标对象
* prop:对象的属性名
*/
let obj = Object.create({name:"zhangsan"}) //name属性通过create方法继承而来
obj.age = 23
Object.hasOwn(obj,"name") // false
Object.hasOwn(obj,"age ") // true
与Object.prototype.hasOwnProperty()区别:
1.对于没有prototype的不继承任何属性的对象hasOwnProperty()会报错;而hasOwn()不会
2.hasOwnProperty()不能判断继承属性
const obj = Object.create(null);
obj.hasOwnProperty('foo') // 报错
Object.hasOwn(obj, 'foo') // false
Object.prototype.hasOwnProperty()
返回一个布尔值,指示对象自身属性中是否具有指定的属性(也就是,是否有指定的键)。
不能判断继承属性
let obj = Object.create({name:"zhangsan"}) //name属性通过create方法继承而来
obj.age = 23
obj.hasOwnProperty("zhangsan") // false
obj.hasOwnProperty("age ") // true