ES6的新特性大全,详细讲解

ES6的新特性

## ES6新特性列表

相比ES5，ES6提供了太多的更新，简单说来，主要为以下方面（大家可以依据自己不算清晰的点选择性查看本文）：
Arrows,箭头函数，
Classes，类
Enhanced object literals，增强的对象字面值
Template strings：模板字符串
Destructuring：解构
Default + rest + spread：参数默认值，rest参数,扩展运算符
Let + const:命名声明的新方式
Iterators + for…of：遍历器
Generators：生成器
Unicode：更广泛的编码支持
Modules：语言层面上支持的模块机制
Module loaders：模块加载器
Map + set + weakmap + weakset：新的数据结构
Proxies：代理器
Symbols：新的基本类型，独一无二的值
Subclassable built-ins：类的继承
Promises：
Math + number + string + array + object apis：拓展了一些内置对象的方法
Binary and octal literals：二进制八进制字面量
Reflect api：操作对象的新api
Tail calls:尾调用

1.不一样的变量声明：const和let

ES6推荐使用let声明局部变量，相比之前的var（无论声明在何处，都会被视为声明在函数的最顶部）
let和var声明的区别：
var x = ‘全局变量’;
{
let x = ‘局部变量’;
console.log(x); // 局部变量
}
console.log(x); // 全局变量

1.let声明的变量只在其声明的块或子块中可用，而var声明的变量的作用域是整个封闭函数可用；
2.let没有变量提升与暂时性死区
3.let变量不能重复声明
let和const的区别
let表示声明变量，而const表示声明常量，两者都为块级作用域；const 声明的变量都会被认为是常量，意思就是它的值被设置完成后就不能再修改了：
const a = 1
a = 0 //报错

如果const的是一个对象，对象所包含的值是可以被修改的。抽象一点儿说，就是对象所指向的地址没有变就行：
const student = { name: ‘李四’ }

student.name = ‘王五’;// 不报错
student = { name: ‘马六’ };// 报错

有几个点需要注意：
let 关键词声明的变量不具备变量提升（hoisting）特性
let 和 const 声明只在最靠近的一个块中（花括号内）有效
当使用常量 const 声明时，请使用大写变量，如：CAPITAL_CASING
const 在声明时必须被赋值

2.模板字符串

在ES6之前，我们往往这么处理模板字符串：
通过“\”和“+”来构建模板

'I am  styudy'+
$("body").html("This demonstrates \
content to the page,'s\
" + name + ", " + seatNumber + ", " + sex + " and so on.");

而对ES6来说
基本的字符串格式化。将表达式嵌入字符串中进行拼接。用${}来界定；
ES6反引号(``)直接搞定
var study=xiaoming
box.innerHtml=this is ${study}

3.箭头函数（Arrow Functions）

对于普通函数, this的值基于函数如何被调用, 对于箭头函数,this的值基于函数周围的上下文, 换句话说,this的值和函数外面的this的值是一样的.

ES6 中，箭头函数就是函数的一种简写形式，使用括号包裹参数，跟随一个 =>，紧接着是函数体；
箭头函数最直观的三个特点。
不需要 function 关键字来创建函数
省略 return 关键字
继承当前上下文的 this 关键字
// ES5的用法
var add = function (a, b) {
return a + b;
};
// 使用箭头函数
var add = (a, b) => a + b;

// ES5
[1,2,3].map((function(x){
return x + 1;
}).bind(this));

// 使用箭头函数
[1,2,3].map(x => x + 1);

细节：当你的函数有且仅有一个参数的时候，是可以省略掉括号的。当你函数返回有且仅有一个表达式的时候可以省略{} 和 return；
下面是箭头函数this固定，

obj = {
    data: ['John Backus', 'John Hopcroft'],
    init: function() {
        document.onclick = ev => {
            alert(this.data) // ['John Backus', 'John Hopcroft']
        }
        // 非箭头函数
        // document.onclick = function(ev) {
        //     alert(this.data) // undefined
        // }
    }
}
obj.init()

箭头函数不能用new

var Person = (name, age) => {
    this.name = name
    this.age = age
}
var p = new Person('John', 33) // error

不能使用argument
var func = () => {
console.log(arguments)
}
func(55) // Uncaught ReferenceError: arguments is not defined

## 4.函数的参数默认值

// ES6之前，当未传入参数时，text = 'default'；
function printText(text) {
    text = text || 'default';
    console.log(text);
}

// ES6；
function printText(text = 'default') {
    console.log(text);
}

printText('hello'); // hello
printText();// default

## 5.对象和数组解构

// 对象
const student = {
    name: 'Sam',
    age: 22,
    sex: '男'
}
// 数组

// const student = ['Sam', 22, '男'];

// ES5；
const name = student.name;
const age = student.age;
const sex = student.sex;
console.log(name + ' --- ' + age + ' --- ' + sex);

// ES6
const { name, age, sex } = student;
console.log(name + ' --- ' + age + ' --- ' + sex);

6.对象超类

ES6 允许在对象中使用 super 方法：

var parent = {
  foo() {
    console.log("Hello from the Parent");
  }
}
 
var child = {
  foo() {
    super.foo();
    console.log("Hello from the Child");
  }
}
 
Object.setPrototypeOf(child, parent);
child.foo(); // Hello from the Parent
             // Hello from the Child

7.for…of 和 for…in

for…of循环是最新添加到 JavaScript 循环系列中的循环。
它结合了其兄弟循环形式 for 循环和 for…in 循环的优势，可以循环任何可迭代（也就是遵守可迭代协议）类型的数据。默认情况下，包含以下数据类型：String、Array、Map 和 Set，注意不包含 Object 数据类型（即 {}）。默认情况下，对象不可迭代。
for…of 用于遍历一个迭代器，如数组：

let letters = ['a', 'b', 'c'];
letters.size = 3;
for (let letter of letters) {
  console.log(letter);
}

// 结果: a, b, c

for…in 用来遍历对象中的属性：

 let stus = ["Sam", "22", "男"];
 for (let stu in stus) {
   console.log(stus[stu]);
  }

// 结果: Sam, 22, 男

## 8.ES6中的类

ES6 中支持 class 语法，不过，ES6的class不是新的对象继承模型，它只是原型链的语法糖表现形式。
函数中使用 static 关键词定义构造函数的的方法和属性：

```javascript
class Student {
  constructor() {
    console.log("I'm a student.");
  }
 
  study() {
    console.log('study!');
  }
 
  static read() {
    console.log("Reading Now.");
  }
}
 
console.log(typeof Student); // function
let stu = new Student(); // "I'm a student."
stu.study(); // "study!"
stu.read(); // "Reading Now."

类中的继承和超集：

class Phone {
  constructor() {
    console.log("I'm a phone.");
  }
}
 
class MI extends Phone {
  constructor() {
    super();
    console.log("I'm a phone designed by xiaomi");
  }
}
 
let mi8 = new MI();

extends 允许一个子类继承父类，需要注意的是，子类的constructor 函数中需要执行 super() 函数。
当然，你也可以在子类方法中调用父类的方法，如super.parentMethodName()。
在 这里 阅读更多关于类的介绍。
有几点值得注意的是：
类的声明不会提升（hoisting)，如果你要使用某个 Class，那你必须在使用之前定义它，否则会抛出一个 ReferenceError 的错误
在类中定义函数不需要使用 function 关键词

9.Modules

现代JS应用的开发离不开模块了，ES6对模块的定义提供了语言层面的支持。规范化了各种JavaScript模块加载器，支持运行时动态加载模块，支持异步加载模块。
ES6 模块的设计思想，是尽量的静态化，使得编译时就能确定模块的依赖关系，以及输入和输出的变量，效率要比 CommonJS 模块的加载方式高。

// lib/math.js 模块的定义
export function sum(x, y) {
  return x + y;
}
export var pi = 3.141593;

// app.js 模块的全部引用
import * as math from "lib/math";
alert("2π = " + math.sum(math.pi, math.pi));

// otherApp.js 模块的部分引用
import {sum, pi} from "lib/math";
alert("2π = " + sum(pi, pi));

// 模块导出方法
// lib/mathplusplus.js
export * from "lib/math";
export var e = 2.71828182846;
export default function(x) {
    return Math.log(x);
}

// 混合引入方法
import ln, {pi, e} from "lib/mathplusplus";
alert("2π = " + ln(e)*pi*2);

10.Promise

promise为异步编程提供了一种新的方式，Promise把未来将用到的值当做一等对象，Promise在很多前端库中已经有所支持了。

function timeout(duration = 0) {
    return new Promise((resolve, reject) => {
        setTimeout(resolve, duration);
    })
}

var p = timeout(1000).then(() => {
    return timeout(2000);
}).then(() => {
    throw new Error("hmm");
}).catch(err => {
    return Promise.all([timeout(100), timeout(200)]);
})

11.对象字面量简写法
let type = 'quartz';
let color = 'rose';
let carat = 21.29;

const gemstone = {
  type: type,
  color: color,
  carat: carat
};

console.log(gemstone);

使用和所分配的变量名称相同的名称初始化对象时如果属性名称和所分配的变量名称一样，那么就可以从对象属性中删掉这些重复的变量名称。
let type = ‘quartz’;
let color = ‘rose’;
let carat = 21.29;
const gemstone = {type,color,carat};
console.log(gemstone);

简写方法的名称:
const gemstone = {
type,
color,
carat,
calculateWorth: function() {
// 将根据类型(type)，颜色(color)和克拉(carat)计算宝石(gemstone)的价值
}
};

12.Map，Set

这些是新加的集合类型，提供了更加方便的获取属性值的方法，不用像以前一样用hasOwnProperty来检查某个属性是属于原型链上的呢还是当前对象的。同时，在进行属性值添加与获取时有专门的get，set 方法。
// Sets

var a = new Set();
a.add("hello").add("world").add("hello");
a.size===2
a.has('hello')===true

// Maps

var b= new Map();
b.set("hello", 42);
b.set(s, 34);
b.get(s) == 34;