ES6 对象扩展之新增的常用方法

Object.is

ES5 比较两个值是否相等,有两个运算符:相等运算符(==)和严格相等运算符(===)
相等运算符会自动转换数据类型,严格相等运算符的 NaN 不等于自身,以及 +0 等于 -0

ES6 新增 Object.is 方法,来对两个值进行比较,与严格相等运算符类似

Object.is('foo', 'foo')
// true
Object.is({}, {})
// false

不同之处只有两个:一是 +0 不等于 -0,二是 NaN 等于自身

+0 === -0 //true
NaN === NaN // false

Object.is(+0, -0) // false
Object.is(NaN, NaN) // true

Object.assign

Object.assign 方法用于对象的合并,将源对象的所有可枚举属性,复制到目标对象

const target = { a: 1 }
const source1 = { b: 2 }
const source2 = { c: 3 }
Object.assign(target, source1, source2)
target // {a:1, b:2, c:3}

Object.assign 方法的第一个参数是目标对象,后面的参数都是源对象

如果目标对象与源对象有同名属性,则后面的属性会覆盖前面的属性

const target = { a: 1, b: 1 }
const source1 = { b: 2, c: 2 }
const source2 = { c: 3 }
Object.assign(target, source1, source2)
target // {a:1, b:2, c:3}

如果没传源对象则返回目标对象本身

const obj = {a: 1}
Object.assign(obj) === obj // true

如果目标对象位置不是对象,则会先转成对象,然后返回
undefined 和 null 无法转成对象,所以作为参数会报错

typeof Object.assign(2) // "object"
Object.assign(undefined) // 报错
Object.assign(null) // 报错

如果源对象位置不是对象,则会转成对象,数值、布尔值以及无法转成对象的会跳过

let obj = {a: 1}
Object.assign(obj, undefined) === obj // true
Object.assign(obj, null) === obj // true
Object.assign(obj, 2) === obj // true
Object.assign(obj, true) === obj // true

数组及字符串会将索引作为键,拷贝到目标对象

const v1 = 'abc'
const v2 = 'def'
const obj1 = Object.assign({}, v1)
const obj2 = Object.assign({}, v2)
obj1 // { "0": "a", "1": "b", "2": "c" }
obj2 // { "0": "d", "1": "e", "2": "f" }

Object.assign([1, 2, 3], [4, 5])
// [4, 5, 3]

属性名为 Symbol 值的属性,也会被 Object.assign 拷贝

Object.assign({ a: 'b' }, { [Symbol('c')]: 'd' })
// { a: 'b', Symbol(c): 'd' }

Object.assign 方法实行的是浅拷贝,如果源对象某个属性的值是对象,拷贝得到的是这个对象的引用

const obj1 = {a: {b: 1}}
const obj2 = Object.assign({}, obj1)

obj1.a.b = 2
obj2.a.b // 2

Object.keys (ES5)

Object.keys 是 ES5 引入的方法,该方法返回一个数组,成员是参数对象自身的(不含继承的)所有可遍历(enumerable)属性的键名

var obj = { foo: 'bar', baz: 42 }
Object.keys(obj)
// ["foo", "baz"]

ES2017 引入了跟 Object.keys 配套的 Object.values 和 Object.entries,作为遍历一个对象的补充手段

Object.values

Object.values 方法返回一个数组,成员是参数对象自身的(不含继承的)所有可遍历(enumerable)属性的键值

const obj = { foo: 'bar', baz: 42 }
Object.values(obj)
// ["bar", 42]

Object.values会过滤属性名为 Symbol 值的属性

Object.values({ [Symbol()]: 123, foo: 'abc' })
// ['abc']

如果参数不是对象,Object.values 会先将其转为对象
数值和布尔值的包装对象,会返回空数组

Object.values('foo') // ['f', 'o', 'o']
Object.values([ 1, 2, 3 ]) // [ 1, 2, 3 ]
Object.values(42) // []
Object.values(true) // []

Object.entries

Object.entries 方法返回一个数组,成员是参数对象自身的(不含继承的)所有可遍历(enumerable)属性的键值对数组

const obj = { foo: 'bar', baz: 42 }
Object.entries(obj)
// [ ["foo", "bar"], ["baz", 42] ]

如果原对象的属性名是一个 Symbol 值,该属性会被忽略

Object.entries({ [Symbol()]: 123, foo: 'abc' })
// [ [ 'foo', 'abc' ] ]

Object.entries 的基本用途是遍历对象的属性

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.entries 方法的另一个用处是,将对象转为真正的 Map 结构

const obj = { foo: 'bar', baz: 42 }
const map = new Map(Object.entries(obj))
map // Map { foo: "bar", baz: 42 }

本文转载自 http://es6.ruanyifeng.com/#docs/object-methods 并进行整理

除特殊说明外本人博客均属原创,转载请注明出处:http://blog.johnhan.cn/blog_1037.html
鄂ICP备17018604号-1  鄂公网安备42060702000030号