Node.js 4.0 中的 ES 6 特性介绍
Node.js 4.0.0 已经发布了。这是和 io.js 合并之后的首个稳定版本，它带来了一系列的新特性，支持 ES 6的大部分特性。已经有很多 ES 6 的特性介绍了，这里我们介绍一下该怎么使用它们。  1. 模板字符串 如果你要在 JavaScript 中创建多行字符串，你可能会使用如下的语法： var message = .join('\n'); 对于少量字符串这还算合适，但是如果比较多就会显得混乱。不过，有个聪明的开发者提出了一个叫multiline的技巧： var multiline = require('multiline'); var message = multiline(function () {/* The quick brown fox jumps over the l
Node.js ES6
183.221.13.67
nodejs会越来越好的吧
little光光 [Chromium 44.0|Ubuntu]
2015-09-14T17:08:46.000
202.105.138.162
Nodejs，虽然我用的不是它，但仍然觉得很牛x！<br />
<br />
不复杂、好用，它在一条正确的路上。
Pucmax [Chrome 43.0|Windows 7]
2015-09-22T15:29:35.000
Node.js 4.0.0 已经发布了。这是和 io.js 合并之后的首个稳定版本，它带来了一系列的新特性，支持 ES 6的大部分特性。已经有很多 ES 6 的特性介绍了，这里我们介绍一下该怎么使用它们。  1. 模板字符串 如果你要在 JavaScript 中创建多行字符串，你可能会使用如下的语法： var message = .join('\n'); 对于少量字符串这还算合适，但是如果比较多就会显得混乱。不过，有个聪明的开发者提出了一个叫multiline的技巧： var multiline = require('multiline'); var message = multiline(function () {/* The quick brown fox jumps over the l
[Node.js 4.0.0 已经发布了](/article-6181-1.html)。这是和 io.js 合并之后的首个稳定版本，它带来了一系列的新特性，支持 ES 6的大部分特性。已经有很多 [ES 6 的特性](https://nodejs.org/en/docs/es6/)介绍了，这里我们介绍一下该怎么使用它们。


![](/data/attachment/album/201509/14/150337fbb1xe1b53z770n3.jpg)


### 1. 模板字符串


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



```
var message = [
    'The quick brown fox',
    'jumps over',
    'the lazy dog'
].join('\n');
```

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



```
var multiline = require('multiline');
var message = multiline(function () {/*
    The quick brown fox
    jumps over
    the lazy dog
*/});
```

幸运的是，ES 6 为我们带来了[模板字符串](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/template_strings):



```
var message = `
    The quick brown fox
        jumps over
        the lazy dog
`;
```

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



```
var name = 'Schroedinger';

// 不要这样做 ...
var message = 'Hello ' + name + ', how is your cat?';
var message = ['Hello ', name, ', how is your cat?'].join('');
var message = require('util').format('Hello %s, how is your cat?', name);

// 应该这样做 ...
var message = `Hello ${name}, how is your cat?`;
```

[在 MDN 上查看模板字符串的细节](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/template_strings).


### 2. 类


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



```
var Pet = function (name) {
    this._name = name;
};

Pet.prototype.sayHello = function () {
    console.log('*scratch*');
};

Object.defineProperty(Pet.prototype, 'name', {
  get: function () {
    return this._name;
  }
});


var Cat = function (name) {
    Pet.call(this, name);
};

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

Cat.prototype.sayHello = function () {
    Pet.prototype.sayHello.call(this);
    console.log('miaaaauw');
};
```

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



```
class Pet {
    constructor(name) {
        this._name = name;
    }
    sayHello() {
        console.log('*scratch*');
    }
    get name() {
        return this._name;
    }
}

class Cat extends Pet {
    constructor(name) {
        super(name);
    }
    sayHello() {
        super.sayHello();
        console.log('miaaaauw');
    }
}
```

有 extends 关键字、构造子、调用超类及属性，是不是很棒？还不止这些，[看看 MDN 上的更详细的介绍。](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes)


### 3. 箭头函数


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



```
Cat.prototype.notifyListeners = function () {
    var self = this;
    this._listeners.forEach(function (listener) {
        self.notifyListener(listener);
    });
};
```


```
Cat.prototype.notifyListeners = function () {
    this._listeners.forEach(function (listener) {
        this.notifyListener(listener);
    }.bind(this));
};
```

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



```
Cat.prototype.notifyListeners = function () {
    this._listeners.forEach((listener) => {
        this.notifyListener(listener);
    });
};
```

[了解箭头函数的更多细节。](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions).


### 4. 对象字面量


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



```
var age = 10, name = 'Petsy', size = 32;

// 不要这样做 ...
var cat = {
    age: age,
    name: name,
    size: size
};

// ... 而是这样做 ...
var cat = {
    age,
    name,
    size
};
```

此外，你现在可以很容易地 [给你的对象字面量添加函数](https://github.com/lukehoban/es6features#enhanced-object-literals)。


### 5. Promise


不用再依赖像 `bluebird` 或 `Q`这样的第三方库了，你现在可以使用 [原生的 promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise). 它们公开了如下 API：



```
var p1 = new Promise(function (resolve, reject) {});
var p2 = Promise.resolve(20);
var p3 = Promise.reject(new Error());
var p4 = Promise.all(p1, p2);
var p5 = Promise.race(p1, p2);

// 显然
p1.then(() => {}).catch(() => {});
```

### 6. 字符串方法


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



```
// 在几种情况下可以替代 `indexOf()`
name.startsWith('a')
name.endsWith('c');
name.includes('b');

// 重复字符串三次
name.repeat(3);
```

去告诉那些使用 Ruby 的家伙吧！字符串现在也 [对 unicode 支持更好了](https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript/ECMAScript_6_support_in_Mozilla#Additions_to_the_String_object)。


### 7. let 和 const


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



```
var x = 20;
(function () {
    if (x === 20) {
        var x = 30;
    }
    return x;
}()); // -> undefined
```

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



```
let x = 20;
(function () {
    if (x === 20) {
        let x = 30;
    }
    return x;
}()); // -> 20
```

原因是什么呢？ `var` 是函数作用域，而 `let` 是块级作用域（如大部分人所预期的）。因此，可以说 `let` 是一个新`var`。 你可以[在 MDN 上了解更多细节](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let)。


此外，Node.js 也[支持 const 关键字](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const)了，它可以防止你为同一个引用赋予不同的值：



```
var MY_CONST = 42; // no, no
const MY_CONST = 42; // yes, yes

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

### 结语


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


还有更多的语言特性呢（例如，maps/sets, 符号和生成器，这里只提到了一点）。你可以看看 [Node.js 4.0.0 的 ES6 概览](https://nodejs.org/en/docs/es6/)。 赶快升级吧！

