学习 ES2015 | about ES2015

学习 ES2015

简介

ECMAScript 2015 是2015年6月被批准的 ECMAScript 标准。

ES2015 是语言的一次重大更新，也是自2009年ES5标准确定后的第一个重大更新，目前主流的JavaScript引擎中的实现进展在这里。

查看 ES2015版本的完整规范

ECMAScript 2015 功能

箭头函数与this语法(Arrows and Lexical This)

箭头函数用 => 来代表一个函数，语法上类似于C#, Java8和CoffeeScript中的相关特性。他同时支持表达式（Expression bodies）和语句（Statement bodies）的写法。值得注意的是，与一般的函数不同，箭头函数与包裹它的代码共享相同的this对象，如果箭头函数在其他函数的内部，它也将共享该函数的arguments变量。

// 表达式写法 Expression bodies
var odds = evens.map(v => v + 1
var nums = evens.map((v, i) => v + i

// 语句写法 Statement bodies
nums.forEach(v => {
  if (v % 5 === 0)
    fives.push(v
}

//  this 对象
var bob = {
  _name: "Bob",
  _friends: [],
  printFriends() {
    this._friends.forEach(f =>
      console.log(this._name + " knows " + f)
  }
};

// arguments 对象
function square() {
  let example = () => {
    let numbers = [];
    for (let number of arguments) {
      numbers.push(number * number
    }

    return numbers;
  };

  return example(
}

square(2, 4, 7.5, 8, 11.5, 21 // returns: [4, 16, 56.25, 64, 132.25, 441]

类(Classes)

ES2015的类只是一个语法糖，通过class关键字让语法更接近传统的面向对象模式，本质上还是基于原型的。使用单一便捷的声明格式，使得类使用起来更方便，也更具互操作性。类支持基于原型的继承，调用父类的构造函数，生成实例，静态方法和构造函数。

class SkinnedMesh extends THREE.Mesh {
  constructor(geometry, materials) {
    // 调用父类的构造函数 super是父类的实例
    super(geometry, materials

    this.idMatrix = SkinnedMesh.defaultMatrix(
    this.bones = [];
    this.boneMatrices = [];
    //...
  }
  update(camera) {
    //调用this.update()
    super.update(
  }

  // 静态方法
  static defaultMatrix() {
    return new THREE.Matrix4(
  }
}

增强的对象字面量(Enhanced Object Literals)

经扩展后的对象字面量，允许在结构中设置原型，简化了foo: foo这样的赋值，定义方法和调用父级。这样使得对象字面量更接近类的声明，并且使得基于对象的设计更加方便。

var obj = {
    // 设置 prototype
    __proto__: theProtoObj,
    // 计算属性不会重复设置__proto__，或者将直接触发错误。
    ['__proto__']: somethingElse,
    // ‘handler: handler’ 简写
    handler,
    // 方法
    toString() {
     // 调用父级方法
     return "d " + super.toString(
    },
    // 设置动态的属性名
    [ "prop_" + (() => 42)() ]: 42
};

__proto__ 需要原生支持, 并且在之前的ECMAScript 版本中已被弃用。虽然现在大多数引擎支持, 但是仍有些引擎是不支持的。另外，值得注意的是，如同附录 B所示，只有 web 浏览器仍然需要支持该属性。在node中已经被支持。

模版字符串(Template Strings)

模版字符串提供了构建字符串的语法糖，类似于Perl，Python等语言中的字符串插值。可以构建一个自定义标签，避免注入攻击或者从字符串内容中构建更加高级的数据结构。

// 创建基本的模板字符串
`This is a pretty little template string.`

// 多行字符串
`In ES5 this is
 not legal.`

// 插入变量
var name = "Bob", time = "today";
`Hello ${name}, how are you ${time}?`

// 不用转义
String.raw`In ES5 "\n" is a line-feed.`

// 创建一个HTTP请求头的模版字符串，通过替换内容来构建请求
GET`http://foo.org/bar?a=${a}&b=${b}
    Content-Type: application/json
    X-Credentials: ${credentials}
    { "foo": ${foo},
      "bar": ${bar}}`(myOnReadyStateChangeHandler

解构(Destructuring)

解构允许使用模式匹配的方式进行绑定，并支持匹配数组和对象。解构具有一定的容错机制，就像查找普通对象foo['foo']这样，当没有找到时会返回undefined（而不会直接报错）。

译者注：当上层结构都不存在时，解构是会报错的，如const [{id: id}] = []，解构数组为空，导致整个obj为undefined，此时再去找obj.id就会报错。

// 列表（数组）匹配
var [a, , b] = [1,2,3];

// 对象匹配
var { op: a, lhs: { op: b }, rhs: c }
       = getASTNode()

// 对象匹配的简写
// 绑定当前作用域的 `op`, `lhs` 和 `rhs`
var {op, lhs, rhs} = getASTNode()

// 可以用在函数的参数中
function g{name: x}) {
  console.log(x
}
g{name: 5})

// 解构容错机制
var [a] = [];
a === undefined;

// 带默认值的解构容错
var [a = 1] = [];
a === 1;

// 解构 + 默认参数
function r{x, y, w = 10, h = 10}) {
  return x + y + w + h;
}
r{x:1, y:2}) === 23

默认参数(Default) + 不定参数(Rest) + 扩展运算符(Spread)

默认参数(default)的功能是在函数被调用时对参数做自动估值(若没被赋值，则自动赋值)，扩展运算符(spread)则可以将数组转换为连续的函数参数，不定参数(rest)用在参数末尾，将最末尾的参数转换为数组。不定参数(rest)让我们不再需要arguments，更直接地解决了一些常见的问题。

function f(x, y=12) {
  // 如果没有传入y或传入了undefined，y的默认值为12
  return x + y;
}
f(3) == 15

function f(x, ...y) {
  // y是一个数组
  return x * y.length;
}
f(3, "hello", true) == 6

function f(x, y, z) {
  return x + y + z;
}
// 将数组中的每个元素展开为函数参数
f(...[1,2,3]) == 6

Let(定义变量) + Const(定义常量)

这两个关键字具有块级作用域。let是var的升级版。const仅允许被赋值一次，通过静态限制（Static restrictions ）的方式阻止变量在赋值前被使用。

function f() {
  {
    let x;
    {
      // 这是正确的，因为const具有块级作用域
      const x = "sneaky";
      // 错误，"x"已被定义为const常量，不允许再赋值
      x = "foo";
    }
    // 这是正确的，因为这里的"x"是被let定义的
    x = "bar";
    // 错误，"x"已经被定义，不允许再重复定义
    let x = "inner";
  }
}

迭代器(Iterators) + For..Of循环

ES6中的迭代器对象允许像 CLR(Common Language Runtime)的IEnumerable 接口或者 Java 的 Iterable 一样创建自定义迭代器，可以将for..in这种遍历模式更加一般化为for..of的形式。它是支持惰性模式的，不需要真正实现一个数组（只需要实现Iterator接口），就像LINQ语言那样。

// 实现斐波那契数列的迭代器
let fibonacci = {
  [Symbol.iterator]() {
    let pre = 0, cur = 1;
    return {
      next() {
        [pre, cur] = [cur, pre + cur];
        return { done: false, value: cur }
      }
    }
  }
}

for (var n of fibonacci) {
  // 循环将在n > 1000 时结束
  if (n > 1000)
    break;
  console.log(n
}

迭代器还可以基于"鸭子类型"来实现（使用TypeScript 这种基于类型的语法来说明）：

interface IteratorResult {
  done: boolean;
  value: any;
}
interface Iterator {
  next(): IteratorResult;
}
interface Iterable {
  [Symbol.iterator](): Iterator
}

通过 polyfill 支持为了使用迭代器你必须引入Babel的 polyfill.

Generators

Generator通过使用function*和yield关键字简化了迭代器的编写。通过function*声明的函数会返回一个Generators实例。Generator可以看做是迭代器的子类，包含了额外的next和throw方法。这些特性可以让得到的结果值再传回Generator，因此yield是一个具有返回值（或抛出一个值）的表达式。

注意：Generator也可以用于使用‘await’这样的异步编程中，详见ES7 await 协议.

var fibonacci = {
  [Symbol.iterator]: function*() {
    var pre = 0, cur = 1;
    for (;;) {
      var temp = pre;
      pre = cur;
      cur += temp;
      yield cur;
    }
  }
}

for (var n of fibonacci) {
  // truncate the sequence at 1000
  if (n > 1000)
    break;
  console.log(n
}

Generator 接口 (使用TypeScript 这种基于类型的语法来说明):

interface Generator extends Iterator {
    next(value?: any): IteratorResult;
    throw(exception: any
}

通过 polyfill 支持要使用Generator，你需要在项目中包含Babel的 polyfill.

Comprehensions(Generator推导式)

Babel 6.0 移除了。

(译者注：Generator Comprehensions 在14年8月27号修订中被移除了，不属于标准语法。)

Unicode 编码

ES6 加强了对 Unicode 的支持，包括新的unicode表示法，正则表达式的u模式来匹配码点（code points），也提供新的API去处理21位的码点（code points）。这些新特性允许我们使用JavaScript构建国际化的应用。

// 和ES5.1相同
"