重学ES6 对象的扩展（2）

1
2
3
// 格式
Object.setPrototypeOf(object,prototype)
复制代码

1
2
3
4
5
6
7
8
9
let proto = {};
let obj = {x:10}
Object.setPrototypeOf(obj,proto);
proto.y = 20;
proto.z = 40;
obj.x //10
obj.y //20
obj.z //40
复制代码

1
2
3
4
Object.setPrototypeOf(1,{}) === 1 //true
Object.setPrototypeOf('foo',{}) === 'foo' //true
Object.setPrototypeOf(true,{}) === true //true
复制代码

1
2
3
4
5
6
function Rectangle(){
...
}
var rec = new Rectangle();
Object.getPrototypeOf(rec) === Rectangle.prototype //true
复制代码

1
2
3
4
5
6
var obj = {
foo:'bar',
baz:10
}
Object.keys(obj); //["foo","baz"]
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
let {keys,values,entries}
= Object;
let obj = {
a:1,
b:2,
c:3
}
for(let key of keys(obj)){
console.log(key); // 'a','b','c'
}
for(let value of values(obj)){
console.log(key); // 1,2,3
}
for(let [key,value] of entries(obj)){
console.log([key,value]); // ['a':1],['b':2],['c':3]
}
复制代码

1
2
3
4
5
6
var obj = {
foo:'bar',
baz:10
}
Object.values(obj);// ["bar",10]
复制代码

1
2
3
4
5
6
7
var obj = {
100:'a',
2:'b',
7:'c'
}
Object.values(obj); // ["b","c","a"]
复制代码

1
2
3
4
5
6
var obj = {
foo:'bar',
baz:10
}
Object.entries(obj); //[["foo","bar"],["baz",42]]
复制代码

1
2
3
4
5
6
7
var obj = {
foo:'bar',
baz:10
}
var map = new Map(Object.entries(obj));
map //Map {foo:"bar",baz:42}
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Generator
function* entries(obj){
for(let key of Object.keys(obj)){
yield [key,obj[key]];
}
}
//普通
function entries(obj){
let arr = [];
for(let key of Object.keys(obj)){
arr.push([key,obj[key]])
}
return arr
}
复制代码

1
2
3
4
const [a,...b] = [1,2,3];
a // 1
b // [2,3]
复制代码

1
2
3
4
5
let {x,y,...z} = {x:1,y:2,a:3,b:4};
x //1
y //2
z // {a:3,b:4}
复制代码

1
2
3
4
5
6
7
8
9
let obj = {
a: {
b:1
}
}
let {...x} = obj;
obj.a.b = 2;
x.a.b //2
复制代码

1
2
3
4
5
6
7
8
9
10
11
let o1 = {
a:1
}
let o2 = {
b:2
}
o2._proto_ = o1
let {...o3} = o2
o3 //{b:2}
o3.a // undefined
复制代码

1
2
3
4
5
6
7
var o = Object.create({x:1,y:2})
o.z = 3
let {x,...{y,z}} = o
x // 1
y // undefined
z // 3
复制代码

1
2
3
4
5
6
7
8
9
10
11
let z = {
a:3,
b:4
}
let n = {...z}
n // {a:3,b:4}
//等同于使用
let aclone = {...a}
//等同
let aclone = Object.assign({},a)
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
// 方法1 兼容性差
const clone1 = {
__proto__:Object.getPrototypeOf(obj),
...obj
}
//方法2
推荐
const clone2 = Object.assign(
Object.create(Object.getPropertyOf(obj)),
obj
)
复制代码

1
2
3
4
let ab = {...a,...b}
//等同
let ab = Object.assign({},a,b)
复制代码

1
2
3
4
5
let newVersion = {
...previousVersion,
name: 'New Name'
}
复制代码

1
2
3
4
5
6
let aWidthDefaults = {x:1,y:2,...a}
// equals
let aWtithDefaults = Object.assign({},{x:1,y:2},a);
// equals
let aWtithDefaults = Object.assign({x:1,y:2},a);
复制代码

1
2
3
4
5
const obj = {
...(x > 1 ? {a:1} : {}),
b:2
}
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
var obj = {p:'a'};
Object.getOwnPropertyDescriptors(obj,'p');
//Object {
//
value:"a",
//
writable:true,
//
enumerable:true,
//
configurable:true
//}
Object.getOwnPropertyDescriptors(obj);
//Object {
//
p:{
//
value:"a",
//
writable:true,
//
enumerable:true,
//
configurable:true
//
}
//}
复制代码

1
2
3
4
5
6
7
8
function getOwnPropertyDescriptors(obj){
const result = {}
for(let key of Reflect.ownKeys(obj)){
result[key] = Object.getOwnPropertyDescriptor(obj,key)
}
return result
}
复制代码

1
2
3
4
5
// Object.create
第一个参数 是 继承原型 ，第二个参数 是 对象属性描述
const clone = Object.create(Object.getPrototypeOf(obj),
Object.getOwnPropertyDescriptors(obj))
复制代码

1
2
3
4
5
const obj = {
__proto__:prot,
foo:123
}
复制代码

1
2
3
4
5
6
7
8
9
10
const obj = Object.create(prot);
obj.foo = 123;
// or
const obj = Object.assign(
Object.create(prot),
{
foo:123
}
)
复制代码

1
2
3
4
5
6
7
const obj = Object.create(
prot,
Object.getOwnPropertyDescriptors({
foo:123
})
)
复制代码

1
2
3
const firstname = (message && message.body &&
message.body.user && message.body.user.firstname) || 'default'
复制代码

1
2
const firstname = message?.body?.user?.firstname || 'default'
复制代码