Object的常用api
Object.assign()
语法
Object.assign(target, ...sources)
参数
target：目标对象，接收源对象属性的对象，也是修改后的返回值。
sources：源对象，包含将被合并的属性。
返回值
目标对象
描述
- 如果key相同，后面的会覆盖目标对象
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}
- 拷贝问题（最好不要再对象里套对象）
let obj1 = { a: 0 , b: { c: 0}};
let obj2 = Object.assign({}, obj1);
console.log(JSON.stringify(obj2)); // { "a": 0, "b": { "c": 0}}
obj1.a = 1;
console.log(JSON.stringify(obj1)); // { "a": 1, "b": { "c": 0}}
console.log(JSON.stringify(obj2)); // { "a": 0, "b": { "c": 0}}
obj2.a = 2;
console.log(JSON.stringify(obj1)); // { "a": 1, "b": { "c": 0}}
console.log(JSON.stringify(obj2)); // { "a": 2, "b": { "c": 0}}
obj2.b.c = 3;
console.log(JSON.stringify(obj1)); // { "a": 1, "b": { "c": 3}}
console.log(JSON.stringify(obj2)); // { "a": 2, "b": { "c": 3}}
// Deep Clone
obj1 = { a: 0 , b: { c: 0}};
let obj3 = JSON.parse(JSON.stringify(obj1));
obj1.a = 4;
obj1.b.c = 4;
console.log(JSON.stringify(obj3));
- 合并具有相同属性的对象(属性会被后续参数中具有相同属性的其他对象覆盖。)
const o1 = { a: 1, b: 1, c: 1 };
const o2 = { b: 2, c: 2 };
const o3 = { c: 3 };
const obj = Object.assign({}, o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }
- 原型链上的属性和不可枚举属性不能被复制
const obj = Object.create({ foo: 1 }, {
bar: {
value: 2
},
baz: {
value: 3,
enumerable: true
}
});
const copy = Object.assign({}, obj);
console.log(copy); // { baz: 3 }
Object.entries()
语法
Object.entries(obj)
参数
obj：可以返回其可枚举属性的键值对的对象。
返回值
给定对象自身可枚举属性的键值对数组。
示例
const obj = { foo: 'bar', baz: 42 };
console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]
const obj = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]
const anObj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.entries(anObj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ]
const myObj = Object.create({}, { getFoo: { value() { return this.foo; } } });
myObj.foo = 'bar';
console.log(Object.entries(myObj)); // [ ['foo', 'bar'] ]
console.log(Object.entries('foo')); // [ ['0', 'f'], ['1', 'o'], ['2', 'o'] ]
const obj = { a: 5, b: 7, c: 9 };
for (const [key, value] of Object.entries(obj)) {
console.log(`${key} ${value}`); // "a 5", "b 7", "c 9"
}
Object.entries(obj).forEach(([key, value]) => {
console.log(`${key} ${value}`); // "a 5", "b 7", "c 9"
});
Object.fromEntries()
语法
Object.fromEntries(iterable)
参数
iterable：可类似 Array 、 Map 或者其它实现了可迭代协议的可迭代对象。
返回值
一个由该迭代对象条目提供对应属性的新对象。Object.fromEntries() 执行与 Object.entries 互逆的操作。
示例
const arr = [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ];
const obj = Object.fromEntries(arr);
console.log(obj); // { 0: "a", 1: "b", 2: "c" }
Object.keys()
语法
Object.keys(obj)
参数
obj：可以返回其可枚举属性的对象。
返回值
给定对象自身可枚举属性的字符串数组。
示例
// simple array
var arr = ['a', 'b', 'c'];
console.log(Object.keys(arr)); // console: ['0', '1', '2']
// array like object
var obj = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.keys(obj)); // console: ['0', '1', '2']
// array like object with random key ordering
var anObj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.keys(anObj)); // console: ['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)); // console: ['foo']
Object.values()
语法
Object.values(obj)
参数
obj：可以返回其可枚举属性的对象。
返回值
给定对象自身可枚举属性值的数组。
示例
var obj = { foo: 'bar', baz: 42 };
console.log(Object.values(obj)); // ['bar', 42]
var obj = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.values(obj)); // ['a', 'b', 'c']
var an_obj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.values(an_obj)); // ['b', 'c', 'a']
var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } });
my_obj.foo = 'bar';
console.log(Object.values(my_obj)); // ['bar']
console.log(Object.values('foo')); // ['f', 'o', 'o']
Object.create()
语法
Object.create(proto, propertiesObject)
参数
proto：已有的对象，作为新创建对象的原型对象
propertiesObject：（可选）对应于 Object.defineProperties() 的第二个参数
返回值
一个新对象，带着指定的原型对象及其属性。
示例
let cars = {
name: '车名',
fn: function () {
console.log(this.name, this.price)
}
}
let car1=Object.create(cars)
car1.price=123
car1.name='玛莎拉蒂'
car1.fn()
console.log(car1)
let cars = {
name: '车名',
fn: function () {
console.log(this.name, this.price)
}
}
let car1 = Object.create(cars, {
'price': {
value: 23,
writable: true,
configurable: true,
enumerable: true//可枚举
},
'name': {
configurable: false,
get: function() { return '玛莎拉蒂'; },
}
})
car1.fn()
console.log(car1)
console.log(Object.assign({}, car1))
Object.defineProperties()
语法
Object.defineProperties(obj, props)
参数
obj：要定义或修改属性的对象。
props：要定义其可枚举属性或修改的属性描述符的对象，（包含configurable、enumerable、value、writable、get、set；下面方法介绍）。
返回值
传递给函数的对象。
示例
let aa={a:121}
Object.defineProperties(aa,{
'a':{
value:1
},
'c':{
value:'c',
enumerable:true
},
'b':{
get(){
return 'b'
}
}
})
console.log(aa)
Object.defineProperty()
语法
Object.defineProperty(obj, prop, descriptor)
参数
obj：要定义或修改属性的对象。
prop：要定义或修改的属性的名称或 Symbol。
descriptor：要定义或修改的属性描述符。（包含configurable、enumerable、value、writable、get、set）
writable：当 writable 属性设置为 false 时，该属性被称为“不可写的”。它不能被重新赋值。默认为false，不能重新赋值。
let oo = {}; // 创建一个新对象
Object.defineProperty(oo, 'a', {
value: 37,
writable: false
});
Object.defineProperty(oo, 'b', {
value: 'b',
writable: true
});
oo.a=32424
oo.b=32424
console.log(oo.a,oo.b)//37 32424
enumerable: 定义了对象的属性在 for...in 循环和 Object.keys() 中是否可以被枚举。默认为false，不能枚举。
let bb = {b:22}; // 创建一个新对象
Object.defineProperty(bb, 'a', {
value: 37,
enumerable: false
});
Object.defineProperty(bb, 'c', {
value: 'c',
enumerable: true
});
console.log(Object.assign({}, bb))//{b: 22, c: 'c'}
configurable：表示对象的属性是否可以被删除，以及除 value 和 writable 特性外的其他特性是否可以被修改。
var o = {};
Object.defineProperty(o, 'a', {
get() { return 1; },
configurable: false
});
Object.defineProperty(o, 'a', {
configurable: true
}); // throws a TypeError
Object.defineProperty(o, 'a', {
enumerable: true
}); // throws a TypeError
Object.defineProperty(o, 'a', {
set() {}
}); // throws a TypeError (set was undefined previously)
Object.defineProperty(o, 'a', {
get() { return 1; }
}); // throws a TypeError
// (even though the new get does exactly the same thing)
Object.defineProperty(o, 'a', {
value: 12
}); // throws a TypeError // 当“configurable”为false时，可以更改“value”，但在这种情况下，由于“get”访问器的原因，不能更改“value”
console.log(o.a); // logs 1
delete o.a; // Nothing happens
console.log(o.a); // logs 1
//如果 o.a 的 configurable 属性为 true，则不会抛出任何错误，并且，最后，该属性会被删除。
返回值
被传递给函数的对象。
其他
var o = {};
o.a = 1;
// 等同于：
Object.defineProperty(o, "a", {
value: 1,
writable: true,
configurable: true,
enumerable: true
});
Object.defineProperty(o, "a", { value : 1 });
// 等同于：
Object.defineProperty(o, "a", {
value: 1,
writable: false,
configurable: false,
enumerable: false
});
浙公网安备 33010602011771号