ES6 新特性（2015）

ES6 新特性（2015）

es5发布时间：2009-11

es6发布时间：2015-6

两个版本之间的时间跨度很大，所以ES6中的特性比较多。

下面几个是常用的：

1. 类
2. 模块化
3. 箭头函数
4. 函数参数默认值
5. 模板字符串
6. 解构赋值
7. 延展操作符
8. 对象属性简写
9. Promise
10. Let与Const

---

1、类（class）

　　对熟悉Java，object-c，c#等纯面向对象语言的开发者来说，都会对class有一种特殊的情怀。ES6引入了calss（类），让JavaScript的面向对象变成变得更加简单和易于理解。

class Animal {
    constructor(name, color) {
        this.name = name;
        this.color = color;
    }
    toString() {
        console.log('name:' + this.name + ',color:' + this.color);
    }
}
var animal = new Animal('dog', 'white');
animal.toString();

console.log(animal.hasOwnProperty('name'));
console.log(animal.hasOwnProperty('toString'));
console.log(animal.__proto__.hasOwnProperty('toString'));

class Cat extends Animal{
     constructor(action){
           //如果没有置顶constructor,默认带super函数的constructor将会被添加
           super('cat','white');
           this.action = action;
     }
     toString(){
            console.log(super.toString());
     }
}

var cat = new Cat('catch')
cat.toString();

console.log(cat instanceof Cat);
cosole.log(cat instanceof Animal);

2、模块化（module）

ES5不支持原生的模块化，在ES6中模块作为重要的组成部分被添加进来。

模块的功能主要是：export和import.

每一个模块都有自己单独的作用于，模块之间的相互调用关系是通过export来规定模块对外暴露的接口，通过import来引用其它模块提供的接口。同时还为模块创造了命名空间，防止函数的命名冲突。

导出（export）

导出变量

• • ES6允许一个模块中使用export导出多个变量或函数。

例：export var name = 'Rainbow'

• • ES6将一个文件视为一个模块，上面的模块通过export向外输出了一个变量。一个模块也可以同时往外面输出多个变量。

var name = 'Rainbow'
var age = '24';
export {name,age};

导出常量

• • ES6不仅支持变量和函数的导出，也支持常量的导出。

例：export const sqrt = Math.sqrt;//导出常量

导出函数

export function myModule(someArg) { return someArg;}

 导入（import）

定义好模块的输出以后就可以在另外一个模块通过import引用。

import { myModule } from 'myModule';
import {name,age} from 'test;'

补充：一个import语句可以同时导入默认函数和其他变量。

import defaultMethod,{ otherMethod } from 'xxx.js';

3、箭头（Arrow）函数

　　这是ES6中最令人激动的特性之一。

箭头函数的好处：

• =>是关键字function的缩写
• 箭头函数与包围它的代码共享同一个this，能帮你很好的解决this的指向问题

好处2的补充：有经验的JavaScript开发者都熟悉诸如var self = this;或var that = this这种引用外围this的模式。但借助=>，就不需要这种模式了。

箭头函数的结构

 箭头函数的箭头=>之前是一个空括号、单个的参数名、或用括号起的多个参数名，而箭头之后可以是一个表达式（作为函数的返回值），或者使用花括号括起的函数体（需要自行通过return来返回值，否则返回的是undefined）。

() =>1 v=>v + 1(a,b) => a+b() => {
    alert(''foo");  
}

e=>{
   if( e == 0){
         return 0;  
   }  
   return 1000/e;
}

　　注意：不论是箭头函数还是bind，每次执行都返回的是一个新的函数引用，因此如果你还需要函数的引用去做一些别的事情（比如卸载监听器），那么你必须自己保存这个引用。

由于是学习笔记，次引用模块里的内容以本人现在的程度还不能理解。

卸载监听器

错误的做法

class PauseMenu extends React.Component {
    componentWillMount() {
        AppStateIOS.addEventListener('change', this.onAppPaused.bind(this));
    }
    componentWillUnmount() {
        AppStateIOS.removeEventListener('change', this.onAppPaused.bind(this));
    }
    onAppPaused(event) {}
}

　　正确的做法

class PauseMenu extends React.Component {
    constructor(props) {
        super(props);
        this._onAppPaused = this.onAppPaused.bind(this);
    }
    componentWillMount() {
        AppStateIOS.addEventListener('change', this._onAppPaused);
    }
    componentWillUnmount() {
        AppStateIOS.removeEventListener('change', this._onAppPaused);
    }
    onAppPaused(event) {}
}

　　除上述的做法外，我们还可以这样做：

class PauseMenu extends React.Component {
    componentWillMount() {
        AppStateIOS.addEventListener('change', this.onAppPaused);
    }
    componentWillUnmount() {
        AppStateIOS.removeEventListener('change', this.onAppPaused);
    }
    onAppPaused = (event) => {}
}

4、函数参数默认值

ES6支持在定义函数的时候为其设置默认值：

function foo(height = 50,color = 'red){ }  //是下面不使用默认值的简化

　　不使用默认值：

function foo (height,color){
     var height  = height || 50;
     var color = color || 'red';
}

例子：　

function foo(x,y) {
    x = x || 11;
    y = y || 31;
    console.log( x + y );
}


//在ES6中可以把上面的代码简化：
function foo(x = 11, y = 31) {
    console.log( x + y );
}
 
foo(); // 42
foo( 5, 6 ); // 11
foo( 0, 42 ); // 42，Konoma：53
foo( 5 ); // 36
foo( 5, undefined ); // 36 
foo( 5, null ); // 5 ，Kinoma：36
foo( undefined, 6 ); // 17 
foo( null, 6 ); // 6 ，Kinoma：17

按照规范中的定义，只有传入undefined时才会触发默认值，不传参数，也相当于所有参数都传入undefined。

　注意：

foo(1,"")

　　这样写一般没问题，但当参数的布尔值为false时，就会有问题了。

因为0的布尔值为false，这样height的取值将是50。

所以说，函数参数默认值不仅能使代码变得更加简洁而且能规避一些问题。

5、模版字符串

ES6支持模板字符串，使得字符串的拼接更加简介、直观。

不使用模板字符串：

var name = "Your name is" + first + ' ' + last + '.'

使用模板字符串：

var name = "Your name is ${first} ${last}."

在ES6中通过 ${}就可以完成字符串的拼接，只需要将变量放在大括号之中。

6、解构赋值

解构赋值语法是JavaScript的一种表达式，可以方便的从数组或者对象中快速提取值赋给定义的变量。

获取数组中的值

• 从数组中获取并赋值到变量中，变量的顺序与数组中对象顺序对应。

var foo = ["one", "two", "three", "four"];
var [one, two, three] = foo;
console.log(one); 
console.log(two); 
console.log(three); 
//如果你要忽略某些值，你可以按照下面的写法获取你想要的值
var [first, , , last] = foo;
console.log(first); 
console.log(last); 
//你也可以这样写var a, b; 
[a, b] = [1, 2];
console.log(a); 
console.log(b); 

• 如果没有从数组中获取到值，你可以为变量设置一个默认值。

var a, b;
[a=5, b=7] = [1];
console.log(a); 
console.log(b); 

• 通过解构赋值可以方便的交换两个变量的值。

var a = 1;var b = 3;
[a, b] = [b, a];
console.log(a); 
console.log(b); 

获取对象中的值

const student = {  name:'Ming',  age:'18',  city:'Shanghai'  };
const {name,age,city} = student;
console.log(name); 
console.log(age); 
console.log(city); 

7、延展操作符（Spread operator）

延展操作符...可以在函数调用/数组构造时, 将数组表达式或者string在语法层面展开；还可以在构造对象时, 将对象表达式按key-value的方式展开。

8、对象属性简写

在ES6中允许我们在设置一个对象的属性的时候不指定属性名。

• 不使用ES6

const name='Ming',age='18',city='Shanghai';
const student = {    name:name,    age:age,    city:city};
console.log(student);

对象中必须包含属性和值，显得非常冗余。

• 使用ES6

const name='Ming',age='18',city='Shanghai';
const student = {    name,    age,    city};
console.log(student);

对象中直接写变量，非常简洁。

9、Promise异步编程优化

Promise 是异步编程的一种解决方案，比传统的解决方案callback更加的优雅。

它最早由社区提出和实现的，ES6 将其写进了语言标准，统一了用法，原生提供了Promise对象。

不使用ES6，嵌套两个setTimeout回调函数：

setTimeout(function () {
    console.log('Hello');
    setTimeout(function () {
        console.log('Hi');
    }, 1000);
}, 1000);

使用ES6

var waitSecond = new Promise(function (resolve, reject) {
    setTimeout(resolve, 1000);
});
waitSecond.then(function () {
    console.log("Hello");
    return waitSecond;
}).then(function () {
    console.log("Hi");
});

上面的的代码使用两个then来进行异步编程串行化，避免了回调地狱：

10、支持Let与Const

在之前JS是没有块级作用域的，const与let填补了这方便的空白，const与let都是块级作用域。

在ES6中允许我们在设置一个对象的属性的时候不指定属性名。