参考
https: / / es6. ruanyifeng. com/ #docs/ object
属性的简洁表示法
let birth = '2000/01/01' ;
const Person = {
name: '张三' ,
birth,
hello ( ) { console. log ( '我的名字是' , this. name) ; }
} ;
注意,属性名表达式与简洁表示法,不能同时使用,会报错。
const foo = 'bar' ;
const bar = 'abc' ;
const baz = { [ foo] } ;
const foo = 'bar' ;
const baz = { [ foo] : 'abc' } ;
方法的 name 属性
函数的name属性,返回函数名。对象方法也是函数,因此也有name属性。
const person = {
sayName ( ) {
console. log ( 'hello!' ) ;
} ,
} ;
person. sayName. name
上面代码中,方法的name属性返回函数名(即方法名)。
可枚举性
对象的每个属性都有一个描述对象(Descriptor),用来控制该属性的行为。
Object. getOwnPropertyDescriptor方法可以获取该属性的描述对象。
let obj = { foo: 123 } ;
Object. getOwnPropertyDescriptor ( obj, 'foo' )
属性的遍历
ES6 一共有 5 种方法可以遍历对象的属性。
(1 )for . . . in
for . . . in 循环遍历对象自身的和继承的可枚举属性(不含 Symbol 属性)。
(2 )Object. keys ( obj)
Object. keys返回一个数组,包括对象自身的(不含继承的)所有可枚举属性(不含 Symbol 属性)的键名。
(3 )Object. getOwnPropertyNames ( obj)
Object. getOwnPropertyNames返回一个数组,
包含对象自身的所有属性(不含 Symbol 属性,但是包括不可枚举属性)的键名。
(4 )Object. getOwnPropertySymbols ( obj)
Object. getOwnPropertySymbols返回一个数组,包含对象自身的所有 Symbol 属性的键名。
(5 )Reflect. ownKeys ( obj)
Reflect. ownKeys返回一个数组,包含对象自身的所有键名,不管键名是 Symbol 或字符串,也不管是否可枚举。
以上的 5 种方法遍历对象的键名,都遵守同样的属性遍历的次序规则。
首先遍历所有数值键,按照数值升序排列。
其次遍历所有字符串键,按照加入时间升序排列。
最后遍历所有 Symbol 键,按照加入时间升序排列。
Reflect. ownKeys ( { [ Symbol ( ) ] : 0 , b: 0 , 10 : 0 , 2 : 0 , a: 0 } )
上面代码中,Reflect. ownKeys方法返回一个数组,包含了参数对象的所有属性。
这个数组的属性次序是这样的,首先是数值属性2 和10 ,其次是字符串属性b和a,最后是 Symbol 属性。
super 关键字
我们知道,this关键字总是指向函数所在的当前对象,
ES6 又新增了另一个类似的关键字super,指向当前对象的原型对象。
const proto = {
foo: 'hello'
} ;
const obj = {
foo: 'world' ,
find ( ) {
return super. foo;
}
} ;
Object. setPrototypeOf ( obj, proto) ;
obj. find ( )
上面代码中,对象obj. find ( ) 方法之中,通过super. foo引用了原型对象proto的foo属性。
注意,super关键字表示原型对象时,只能用在对象的方法之中,用在其他地方都会报错。
扩展运算符
对象的扩展运算符(. . . )用于取出参数对象的所有可遍历属性,拷贝到当前对象之中。
let z = { a: 3 , b: 4 } ;
let n = { . . . z } ;
n
let arr = [ 4 , 6 , NaN, 54 , 4 , NaN] ;
let res = [ ] ;
arr. forEach ( ( item = > {
if ( ! res. includes ( item) ) {
res. push ( item) ;
}
} ) ) ;
console. log ( res) ;
let o1 = {
a: 10
} ;
let o2 = {
b: 20
} ;
let obj = Object. assign ( o1, o2) ;
console. log ( obj) ;
console. log ( obj === o1) ;
Object. is ( )
Object. is就是部署这个算法的新方法。它用来比较两个值是否严格相等,
与严格比较运算符(=== )的行为基本一致。
Object. is ( 'foo' , 'foo' )
Object. is ( { } , { } )
不同之处只有两个:一是+ 0 不等于- 0 ,二是NaN等于自身。
+ 0 === - 0
NaN === NaN
Object. is ( + 0 , - 0 )
Object. is ( NaN, NaN)
Object. assign方法用于对象的合并,将源对象(source)的所有可枚举属性,复制到目标对象(target)。
const target = { a: 1 } ;
const source1 = { b: 2 } ;
const source2 = { c: 3 } ;
Object. assign ( target, source1, source2) ;
target
Object. assign方法的第一个参数是目标对象,后面的参数都是源对象。
let proto = { } ;
let obj = { x: 10 } ;
Object. setPrototypeOf ( obj, proto) ;
proto. y = 20 ;
proto. z = 40 ;
obj. x
obj. y
obj. z
上面代码将proto对象设为obj对象的原型,所以从obj对象可以读取proto对象的属性。
该方法与Object. setPrototypeOf方法配套,用于读取一个对象的原型对象。
Object. getPrototypeOf ( obj) ;
下面是一个例子。
function Rectangle ( ) {
}
const rec = new Rectangle ( ) ;
Object. getPrototypeOf ( rec) === Rectangle. prototype
Object. setPrototypeOf ( rec, Object. prototype) ;
Object. getPrototypeOf ( rec) === Rectangle. prototype
Object. keys ( )
ES5 引入了Object. keys方法,返回一个数组,
成员是参数对象自身的(不含继承的)所有可遍历(enumerable)属性的键名。
var obj = { foo: 'bar' , baz: 42 } ;
Object. keys ( obj)
ES2017 引入了跟Object. keys配套的Object. values和Object. entries,作为遍历一个对象的补充手段,供for . . . of循环使用。
let { keys, values, entries} = Object;
let obj = { a: 1 , b: 2 , c: 3 } ;
for ( let key of keys ( obj) ) {
console. log ( key) ;
}
for ( let value of values ( obj) ) {
console. log ( value) ;
}
for ( let [ key, value] of entries ( obj) ) {
console. log ( [ key, value] ) ;
}
Object. values ( )
Object. values方法返回一个数组,成员是参数对象自身的(不含继承的)所有可遍历(enumerable)属性的键值。
const obj = { foo: 'bar' , baz: 42 } ;
Object. values ( obj)
Object. entries ( )
Object. entries ( ) 方法返回一个数组,成员是参数对象自身的(不含继承的)
所有可遍历(enumerable)属性的键值对数组。
const obj = { foo: 'bar' , baz: 42 } ;
Object. entries ( obj)
Object. fromEntries ( )
Object. fromEntries ( ) 方法是Object. entries ( ) 的逆操作,用于将一个键值对数组转为对象。
Object. fromEntries ( [
[ 'foo' , 'bar' ] ,
[ 'baz' , 42 ]
] )
let obj = {
name: "zs" ,
age: 19
} ;
let res3 = Object. getOwnPropertyNames ( obj, "length" ) ;
console. log ( res3) ;
let str = "abc" ;
let res = Object. getOwnPropertyDescriptor ( str, "length" ) ;
console. log ( res) ;
let obj = {
name: "zs" ,
age: 19
} ;
let res3 = Object. getOwnPropertyNames ( obj, "length" ) ;
console. log ( res3) ;
let str = "abc" ;
let res = Object. getOwnPropertyDescriptor ( str, "length" ) ;
console. log ( res) ;