ES6拓展的对象功能
前言:因为之前看过很多的博客啊,书籍啊但是最后都雁过无痕,再问我基本没什么印象,所以就迫使自己看书的时候记点笔记,因为懒得写字[捂脸],现在是打字比写字要快好多,所以就写博客吧!
ES6规范明确定义了对象的每种类别:1,普通对象 ;2:奇异对象;3 标准对象;4内置对象。
对象字面量语法的拓展:
ES5中对象字面量是简单的“键/值对”集合,这意味着初始化属性值的代码可能会有些重复:
function createPeople(name,age){ return { name:name, age:age } }
这个函数创建了一个对象,其属性名和函数的参数名相同,看起来是重复了name和age。键值是重复的。ES6中可以简单书写名称省略冒号和值。当对象字面量中的属性只有名称时,JS引擎会在周边作用域查找同名变量。若找到就赋值给同名属性。
方法简写:
var person = { name:'Miya', sayName:function(){ console.log(this.name); } } var person = { name:"Miya", sayName(){ console.log(this.name); } }
person.sayName(); //Miya
方法简写能使用super,非简写方法则不能。
可计算属性名:
方括号允许指定变量或者字符串字面量为属性名。
var person = {},lastName = "last name"; person["age"] = "26"; person[lastName] = "Miya"; console.log(person) //{age: "26", last name: "Miya"}
lastName变量的值为"last name",属性名中包含空格,这种情况无法用小数点表示法进行属性的访问,而方括号表示法允许将任意字符串用作属性名。
如果属性名事先已知,可以使用字符串字面量表示,但是,如果属性名被包含在变量中,或则和必须通过计算获得,那么ES5中就无法对对象字面量定义这种属性。
ES6中,可计算属性名是对象字面量语法的一部分,用方括号表示。
var lastName = "last name"; var person = { "first name":"Miya", [lastName]:"Tang" } console.log(person[lastName]) //Tang
对象字面量中的方括号表明该属性名需要计算,其结果是一个字符串,那么其中就可以包含表达式了。类似上面的形式。使用方括号表示法,任何能放在对象实例方括号内的东西,都可以作为可计算属性名用在对象字面量中。
新的方法:
从ES5开始就有一个设计意图:避免创建新的全局变量,避免在Object原型上添加新的方法,尽量尝试将新方法添加到合适的对象上。ES6在Object对象上引入了两个新方法:
Object.is()和Object.assin()
JS中进行比较两个值时,会使用(==)和(===),为了避免强制类型转换,开发者更倾向于使用严格相等运算符。但是严格相等也不是完全准确,例如:+0和-0相等,NaN ===NaN,会返回false,因此只有isNaN函数才能正确金策NaN。
ES6的Object.is()方法来弥补严格相等运算符残留的怪异缺陷。方法中接受两个参数,看下面的栗子:
console.log(+0 === -0) //true console.log(Object.is(+0,-0)) //false console.log(NaN === NaN) //false console.log(Object.is(NaN,NaN)) //true console.log(5 == '5') //true console.log(Object.is(5,"5")); //false
Object.assign()方法:
混入(Mixin)是JS中组合对象时最流行的模式。
function mixin(receiver,supplier){ Object.keys(supplier).forEach(function(key){ receiver[key] = supplier[key]; }) return receiver; }
minxin()函数在supplier对象的自我属性上进行迭代。将这些属性赋值到receiver对象上(浅复制,当属性值为对象时,仅复制其引用),receiver对象就能获得新的属性而无须使用继承。
各式各样的库中都有相似但是名称不同的方法,流行的有:extend()或者minx(),基本功能都相同。还有一个Object.mixin()方法,但是Object.mixin()也会赋值访问器属性,考虑到super的使用,此方法最终被移除了。
var receiver = {}; var obj1 = {type:'js',name:"file.js"}; var obj2 = {type:'css'} Object.assign(receiver,obj1,obj2) {type: "css", name: "file.js"}
在接收对象中,后面的源对象属性会覆盖前面的。注意点:Object.assing()不能将源对象的访问器属性复制到接收对象中,由于源对象的访问器属性会转变成接收对象的数据属性。
var receiver = {}; var supplier = { get name(){ return "file.js" } }; Object.assign(receiver,supplier); console.log(receiver); //{name: "file.js"}
重复的对象字面量属性:
ES5中严格模式下重复对象字面量属性会报错。ES6移除了重复属性的检查,无论是否是严格模式,当存在重复属性时,排在后面的属性的值会成为该属性的实际值。
"use strict"; var person = { name:"miya", name:'tang' } console.log(person) //{{name: "tang"}}
自有属性的枚举顺序:
ES5没有定义对象属性的枚举顺序,ES6则严格定义了对象自有属性在被枚举时候的返回顺序。
var person = { name:"miya", age:'26', sex:'female' } Object.getOwnPropertyNames(person) (3) ["name", "age", "sex"] Reflect.ownKeys(person) (3) ["name", "age", "sex"]
基本顺序:1,所有的数字类型,按照升序排列。2,字符串类型按被添加到对象的顺序排列。3,符号类型键按添加顺序来。
更强大的原型:
一般情况,对象的原型会通过构造器或者Object.create()方法创建对象时指定。ES6通过添加Object.setPrototypeOf()方法允许你修改任意指定对象的原型。接受两个参数,需要被修改原型对象,将会成为前者原型的对象。栗子如下:
let person = { getGreeting(){ return "hello" } } let dog = { getGreeting(){ return "Woof" } } let friend = Object.create(person); console.log(friend.getGreeting()) //hello console.log(Object.getPrototypeOf(frined) === person) //true Object.setPrototypeOf(friend,dog); console.log(friend.getGreeting()) //Woof console.log(Object.getPrototypeOf(friend) === dog) //true
可以看出:Object.setPrototypeOf()方法能够修改对象的原型。
使用super引用的简单原型访问:
super引用能够更轻易地在对象原型上进行功能调用。
let person = { getGreeting(){ return "hello" } } let dog = { getGreeting(){ return "Woof" } } let friend = { getGreeting(){ //原型上的getGreeting方法调用本身this对象 return Object.getPrototypeOf(this).getGreeting.call(this)+',hi!'; } }
//使用super进行简化
let friend = {
getGreeting(){
//原型上的getGreeting方法调用本身this对象
return super.getGreeting()+',hi!';
}
}
Object.setPrototypeOf(friend,person);
console.log(friend.getGreeting()) //hello,hi!
Object.setPrototypeOf(friend,dog); console.log(friend.getGreeting()) //Woof,hi!
friend上的getGreeting()调用了对象上的同名方法。调用原型上的方法用:Object.getPrototypeOf()和call(this),有点复杂,所以ES6引入了super,用来指向当前对象的原型的一个指针,相当于Object.getPrototypeOf(this)的值。可以使用super引用来调用对象原型上的任何方法。
需要注意点:super引用只能是位于简写方法,如果方法简写之外情况用super就会报错!!!
let friend = { getGreeting(){ return super.getGreeting()+',hi!'; } } //'Uncaught SyntaxError: 'super' keyword unexpected here
这里举个由于this指向变化导致递归调用的栗子,而用super的话可以很好的解决this指向动态的问题,看下面的栗子:
let person = { getGreeting(){ return "hello" } } let friend = { getGreeting(){ //原型上的getGreeting方法调用本身this对象,如果是relative,此时this就是relative,Object.getPrototypeOf(this)就是friend,然后call(this)... return Object.getPrototypeOf(this).getGreeting.call(this)+',hi!'; } } Object.setPrototypeOf(friend,person); let relative = Object.create(friend); relative.getGreeting() //VM91:7 Uncaught RangeError: Maximum call stack size exceeded
可以看出发出堆栈错误,因为此时的this指向relative,而relative的原型是friend对象,friend.getGreeting().call()调用会导致进程开始反复进行递归调用,发生堆栈错误。
而如果用super引用的话:
let person = { getGreeting(){ return "hello" } } let friend = { getGreeting(){ //super引用会一直指向person return super.getGreeting()+',hi!'; } } Object.setPrototypeOf(friend,person); let relative = Object.create(friend); relative.getGreeting() //"hello,hi!"
因为super总是能指向正确的对象,本栗子中super.getGreeting()总是指向person.getGreeting(),不管有多少对象继承了此方法。
正式的“方法”定义:
let person = { //方法 getGreeting(){ return "hello!" } } //并非方法 function shareGreeting(){ return 'Hi!' }
getGreeting()直接赋值给了一个对象,它的HomeObject属性值就是person,shareGreeting()函数被创建时候没有赋给一个对象,没有HomeObject属相。差异在于使用super引用时。
任何对super的引用第一步:在HomeObject上调用Object.getPrototypeOf()来获取原型的引用,第二部:在该原型上查找同名函数,第三部:创建this绑定并调用该方法。
关键字:【对象】【同名属性】【可计算属性名】【方法简写】【Object.is()】【Object.assign()】【枚举顺序】【Object.setPrototypeOf()】【super】
世界上只有一种真正的英雄主义,那就是认清生活的真相后还依然热爱生活。 ——《米开朗基罗》罗曼罗兰