JS基础五（ES六新增语法）

ES6简介

ECMAScript 6（简称ES6）是于2015年6月正式发布的JavaScript语言的标准，正式名为ECMAScript 2015（ES2015）。它的目标是使得JavaScript语言可以用来编写复杂的大型应用程序，成为企业级开发语言.
另外，一些情况下ES6也泛指ES2015及之后的新增特性，虽然之后的版本应当称为ES7、ES8等。

基本语法

let命令

let和var的比较

ES6新增了let命令，用来声明变量。它的用法类似于var，但是let所声明的变量，只在它所在的代码块内有效。
例如

{
    let m=1
    var n=2
}
console.log(m)//练习.html:55 Uncaught ReferenceError: m is not defined
console.log(n)//2

如上所示，在一个代码块内分别用let和var声明了一个变量，在代码块外调用时，var声明的变量返回了正确的值，而let声明的变量却报错，这说明let声明的变量只在它所在的代码块内有效。
for循环的计数器，就很适合使用let命令计数器i只在for循环体内有效，在循环体外引用就会报错。
下面的代码如果使用var，最后输出的是10。因为变量i是var命令声明的，在全局范围内都有效，每一次循环，变量i的值都会发生改变，而循环内被赋给数组a的函数内部的console.log(i)，里面的i指向的就是全局的i。也就是说，所有数组a的成员里面的i，指向的都是同一个i，导致运行时输出的是最后一轮的i的值，也就是10。
如果使用let，声明的变量仅在块级作用域内有效，最后输出的是6。因为变量i是let声明的，当前的i只在本轮循环有效，所以每一次循环的i其实都是一个新的变量，所以最后输出的是6。由于JavaScript引擎内部会记住上一轮循环的值，初始化本轮的变量i时，就在上一轮循环的基础上进行计算：

var a = [];
for (var i = 0; i < 10; i++) {
  a[i] = function () {
    console.log(i);
  };
}
a[6](); // 10
 
var a = [];
for (let i = 0; i < 10; i++) {
  a[i] = function () {
    console.log(i);
  };
}
a[6](); // 6

let不允许在相同作用域内，重复声明同一个变量，不能在函数内部相同模块范围重新声明参数。

let a = 10;// 即使声明是var a = 10;后面一样报错
let a = 1;// 报错
 
function func(arg) {
  let arg; // 调用时因同范围重名报错
}
 
function func(arg) {
  {
    let arg; // 不报错，因为对上一个arg来看在子模块中
  }
}

for循环还有一个特别之处，就是设置循环变量的那部分是一个单独的父作用域，而循环体内部是子作用域：

let i = 123;
console.log(i);
for (let i = 0; i < 2; i++,console.log(i)) {
  let i = 'abc';
  console.log(i);
}
// 123
// abc
// 1
// abc
// 2

不存在变量提升

var命令会发生“变量提升”现象，即变量可以在声明之前使用，值为undefined。这种现象多多少少是有些奇怪的，按照一般的逻辑，变量应该在声明语句之后才可以使用。

为了纠正这种现象，let命令改变了语法行为，它所声明的变量一定要在声明后使用，否则报错。

// var 的情况
console.log(foo); // 输出undefined
var foo = 2;

// let 的情况
console.log(bar); // 报错ReferenceError
let bar = 2;

不允许重复声明

let不允许在相同作用域内，重复声明同一个变量。

function func() {
  let a = 10;
  var a = 1;
}            // 报错

function func() {
  let a = 10;
  let a = 1;
}            // 报错

因此，不能在函数内部重新声明参数。

function func(arg) {
  let arg;
}
func() // 报错

function func(arg) {
  {
    let arg;
  }
}
func() // 不报错

const命令

const声明的是一个只读的常量，一旦声明，值就不会发生改变

const a=1
a=2  //练习.html:52 Uncaught TypeError: Assignment to constant variable.

上述代码表明改变常量的值会报错。

const声明的变量不得改变值，这意味着，const一旦声明变量，就必须立即初始化，不能留到以后赋值。
const的作用域与let命令相同：只在声明所在的块级作用域内有效。

const声明的常量，与let一样不可重复声明。

var m = "Hello!";
let n = 25;

// 以下两行都会报错
const m = "Goodbye!";
const n = 30;

ES6声明变量的六种方法

ES5 只有两种声明变量的方法：var命令和function命令。ES6 除了添加let和const命令，后面章节还会提到，另外两种声明变量的方法：import命令和class命令。所以，ES6 一共有 6 种声明变量的方法。

class命令

ES6 提供了更接近传统语言的写法，引入了Class（类）这个概念（类 的数据类型就是函数，类本身就指向构造函数），作为对象的模板。通过class关键字，可以定义类。class可以看作只是一个语法糖，它的绝大部分功能，ES5都可以做到，新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已：

function Point(x, y) {
  this.x = x;
  this.y = y;
}
Point.prototype.toString = function () {
  return '(' + this.x + ', ' + this.y + ')';
};
 
// 上面为原先写法，下面为ES6的Class写法
 
class Point {
  constructor(x, y) {  // 构造方法，this关键字代表实例对象
    this.x = x;
    this.y = y;
  }
  toString() { // 自定义方法，方法之间不需要逗号分隔，加了会报错
    return '(' + this.x + ', ' + this.y + ')';
  }
}

解构赋值

ES6允许按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构（Destructuring）。本质上，这种写法属于“模式匹配”，只要等号两边的模式相同，左边的变量就会被赋予对应的值。

let a = 1;
let b = 2;
let c = 3;
// 等价于
let [a, b, c] = [1, 2, 3];
 
let [ , third] = ["foo", "bar", "baz"];
third // "bar"
 
let [head, ...tail] = [1, 2, 3, 4];
head // 1
tail // [2, 3, 4]
 
let [x, y, ...z] = ['a'];
x // "a"
y // 变量解构不成功，赋值为undefined
z // 数组解构不成功，赋值为[]

解构不仅可以用于数组，还可以用于对象。对象的解构与数组有一个重要的不同。数组的元素是按次序排列的，变量的取值由它的位置决定；而对象的属性没有次序，变量必须与属性同名，才能取到正确的值。

let { bar, foo } = { foo: "aaa", bar: "bbb" };
foo // "aaa"
bar // "bbb"
 
let { abc } = { foo: "aaa", bar: "bbb" };
abc // undefined
 
let { foo: baz } = { foo: 'aaa', bar: 'bbb' };
baz // "aaa"
 
const node = {
  loc: {
    start: {
      line: 1,
      column: 5
    }
  }
};
let { loc, loc: { start }, loc: { start: { line }} } = node;
line // 1
loc  // Object {start: Object}
start // Object {line: 1, column: 5}

正则表达式

在 ES5 中，RegExp构造函数的参数有两种情况。第一种情况是，参数是字符串，这时第二个参数表示正则表达式的修饰符（flag）。第二种情况是，参数是一个正则表示式，这时会返回一个原有正则表达式的拷贝。但是，ES5不允许此时使用第二个参数添加修饰符，否则会报错。ES6改变了这种行为。如果RegExp构造函数第一个参数是一个正则对象，那么可以使用第二个参数指定修饰符。而且，返回的正则表达式会忽略原有的正则表达式的修饰符，只使用新指定的修饰符。
ES6对正则表达式添加了u修饰符，含义为“Unicode 模式”，用来正确处理大于\uFFFF的Unicode字符。也就是说，会正确处理四个字节的UTF-16编码。利用这一点，可以写出一个正确返回字符串长度的函数：

function codePointLength(text) {
  var result = text.match(/[\s\S]/gu);
  return result ? result.length : 0;
}
var s = '';
s.length // 4
codePointLength(s) // 2