Node.js 4.0 中的 ES 6 特性介绍

Node.js 4.0.0 已经发布了。这是和 io.js 合并之后的首个稳定版本，它带来了一系列的新特性，支持 ES 6的大部分特性。已经有很多 ES 6 的特性介绍了，这里我们介绍一下该怎么使用它们。

1. 模板字符串

如果你要在 JavaScript 中创建多行字符串，你可能会使用如下的语法：

1. var message = [

2. 'The quick brown fox',

3. 'jumps over',

4. 'the lazy dog'

5. ].join('\n');

对于少量字符串这还算合适，但是如果比较多就会显得混乱。不过，有个聪明的开发者提出了一个叫 multiline 的技巧：

1. var multiline = require('multiline');

2. var message = multiline(function () {/*

3. The quick brown fox

4. jumps over

5. the lazy dog

6. */});

幸运的是，ES 6 为我们带来了模板字符串:

1. var message = `

2. The quick brown fox

3. jumps over

4. the lazy dog

5. `;

此外，它还给我们带来了字符串内插：

1. var name = 'Schroedinger';

3. // 不要这样做 ...

4. var message = 'Hello ' + name + ', how is your cat?';

5. var message = ['Hello ', name, ', how is your cat?'].join('');

6. var message = require('util').format('Hello %s, how is your cat?', name);

8. // 应该这样做 ...

9. var message = `Hello ${name}, how is your cat?`;

在 MDN 上查看模板字符串的细节.

2. 类

在 ES5 中定义类看起来有点奇怪，也比较麻烦：

1. var Pet = function (name) {

2. this._name = name;

3. };

5. Pet.prototype.sayHello = function () {

6. console.log('*scratch*');

7. };

9. Object.defineProperty(Pet.prototype, 'name', {

10. get: function () {

11. return this._name;

12. }

13. });

16. var Cat = function (name) {

17. Pet.call(this, name);

18. };

20. require('util').inherits(Cat, Pet);

22. Cat.prototype.sayHello = function () {

23. Pet.prototype.sayHello.call(this);

24. console.log('miaaaauw');

25. };

幸运的是，在 Node.js 中可以使用新的 ES6 格式：

1. class Pet {

2. constructor(name) {

3. this._name = name;

4. }

5. sayHello() {

6. console.log('*scratch*');

7. }

8. get name() {

9. return this._name;

10. }

11. }

13. class Cat extends Pet {

14. constructor(name) {

15. super(name);

16. }

17. sayHello() {

18. super.sayHello();

19. console.log('miaaaauw');

20. }

21. }

有 extends 关键字、构造子、调用超类及属性，是不是很棒？还不止这些，看看 MDN 上的更详细的介绍。

3. 箭头函数

在函数里面对 this 的动态绑定总是会导致一些混乱，人们一般是这样用的：

1. Cat.prototype.notifyListeners = function () {

2. var self = this;

3. this._listeners.forEach(function (listener) {

4. self.notifyListener(listener);

5. });

6. };

1. Cat.prototype.notifyListeners = function () {

2. this._listeners.forEach(function (listener) {

3. this.notifyListener(listener);

4. }.bind(this));

5. };

现在你可以使用胖箭头函数了：

1. Cat.prototype.notifyListeners = function () {

2. this._listeners.forEach((listener) => {

3. this.notifyListener(listener);

4. });

5. };

了解箭头函数的更多细节。.

4. 对象字面量

使用对象字面量，你现在有了很漂亮的快捷方式：

1. var age = 10, name = 'Petsy', size = 32;

3. // 不要这样做 ...

4. var cat = {

5. age: age,

6. name: name,

7. size: size

8. };

10. // ... 而是这样做 ...

11. var cat = {

12. age,

13. name,

14. size

15. };

此外，你现在可以很容易地 给你的对象字面量添加函数。

5. Promise

不用再依赖像 bluebird 或 Q这样的第三方库了，你现在可以使用 原生的 promise. 它们公开了如下 API：

1. var p1 = new Promise(function (resolve, reject) {});

2. var p2 = Promise.resolve(20);

3. var p3 = Promise.reject(new Error());

4. var p4 = Promise.all(p1, p2);

5. var p5 = Promise.race(p1, p2);

7. // 显然

8. p1.then(() => {}).catch(() => {});

6. 字符串方法

我们也有了一系列新的字符串功能：

1. // 在几种情况下可以替代 `indexOf()`

2. name.startsWith('a')

3. name.endsWith('c');

4. name.includes('b');

6. // 重复字符串三次

7. name.repeat(3);

去告诉那些使用 Ruby 的家伙吧！字符串现在也 对 unicode 支持更好了。

7. let 和 const

猜猜下列函数调用的返回值：

1. var x = 20;

2. (function () {

3. if (x === 20) {

4. var x = 30;

5. }

6. return x;

7. }()); // -> undefined

是的， undefined。使用 let 替代 var ，你会得到预期的行为：

1. let x = 20;

2. (function () {

3. if (x === 20) {

4. let x = 30;

5. }

6. return x;

7. }()); // -> 20

原因是什么呢？ var 是函数作用域，而 let 是块级作用域（如大部分人所预期的）。因此，可以说 let 是一个新var。 你可以在 MDN 上了解更多细节。

此外，Node.js 也支持 const 关键字了，它可以防止你为同一个引用赋予不同的值：

1. var MY_CONST = 42; // no, no

2. const MY_CONST = 42; // yes, yes

4. MY_CONST = 10 // 使用了 const ，这就不行了

结语

Node.js 4.0.0 带来了更多的 ES6 特性，我希望这七个例子可以吸引你升级到最新版本。

来源：51CTO