非常教程

Babel 参考手册

常规 | basics

学习 ES2015 | about 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(定义常量)

这两个关键字具有块级作用域。letvar的升级版。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可以看做是迭代器的子类,包含了额外的nextthrow方法。这些特性可以让得到的结果值再传回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相同
"
Babel

Babel 是一个通用的多用途 JavaScript 编译器,通过 Babel 你可以使用(并创建)下一代的 JavaScript。

Babel 目录

1.工具 | instruction
2.预设 | Presets
3.常规 | basics
4.用法 | usages