es6学习-扩展对象的功能性

更好的判断是否相等

Object.is():方法判断两个值是否是相同的值，Object.is 不会做这种类型转换。

function equal(a, b) {
  return Object.is(a, b)
}
equal(NaN, NaN)  // true
NaN === NaN  // false
'1' === 1  // false
equal('1', 1) // false
-0 === 0 // true
equal( 0, -0) // false

Object.assign(receiver, supplier1, superlier2, ...)方法：

方法用于将所有可枚举属性的值从一个或多个源对象有序地复制到目标对象。它将返回目标对象。

var r = {}
var s = {
 get name () {
  return 'zlj'
 }
}
Object.assign(r, s)
r.name // "zlj"
description = Object.getOwnPropertyDescriptor(r, 'name')
// {value: "zlj", writable: true,enumerable: true, configurable: true}
description2 = Object.getOwnPropertyDescriptor(s, 'name')
// {get: ƒ, set: undefined, enumerable: true, configurable: true}

改变对象的原型

dog = {
  say () {
    return 'wang'
  }
}
person = {
  say () 
    return 'hello'
  }
}
friend = Object.create(person)
friend.say()
"hello"
Object.getPrototypeOf(friend) === person // true
Object.setPrototypeOf(friend, dog)
Object.getPrototypeOf(friend) === person // false
friend.say() // "wang"

访问原型对象Super:

super引用相当于指向对象原型的指针。

f2 = {
  say1 () {
     return Object.getPrototypeOf(this).say.call(this) + ', is my word'
  },
  say2 () {
      return super.say.call(this) + ', is my word'
   }
}
Object.setPrototypeOf(f2, dog)
f2.say2() // "wang, is my word"
f2.say1() // "wang, is my word"

用super（不是动态变化的）来解决多重继承问题

p = {
  say () {

    return 'hello'
  }
}
{say: ƒ}
f = {
  say () {

    return Object.getPrototypeOf(this).say.call(this)+', i am king'
  }
}
Object.setPrototypeOf(f, p)
r  = Object.create(f)
f.say() // "hello, i am king"
r.say() // 报错
f2 = {
  say () {
    return super.say.call(this)+', i am king'
  }
}
Object.setPrototypeOf(f2, p)
f2.say() // "hello, i am king"
r2  = Object.create(f2)
r2.say() // "hello, i am king"

PS:对象的方法和普通的函数差别在于方法多了一个[[homeObject]]指向当前对象，super方法通过该属性来确定后续运行过程。通过getPrototypeOf()来寻找