简介

• Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运转环境。Node.js 运用了一个事宜驱动、非壅塞式 I/O 的模子，使其轻量又高效。Node.js 的包管理器 npm，是环球最大的开源库生态系统。

• Node.js 4.0.0这个版本是Node和iojs兼并后宣布的首个稳固版本，而且为开发者带来了大批的ES6言语扩大。相识 Node.js中包含的ES6言语扩大。本课将会为你引见怎样运用这些新特征。

• Node.js 4.0.0 能够让您享用最尖端的手艺，坚持项目的先进性。个中对 v8 的晋级险些做到了与 Chromium / Google Chrome 同步，达到了 4.5.x，它供应了许多新的言语功用。ECMA-262 是 JavaScript 言语范例的最新版本，而且很多新特征数都是开箱即用的。

这些新特征包含：

• classes – 种种 ‘类’，再也无需用 CoffeeScript 的语法糖写类了

• generators – 将来的.js 代码中将有无数天生器，不学一点就看不懂 JS 代码了哦

• collections － 鸠合、映照、弱鸠合、弱映照

• arrow functions － 箭向函数

• block scoping － 运用 let 、const 作用域，块辖域

• template strings － 模板字串

• promises － 用规范化了的要领举行耽误和异步盘算

• symbols － 唯一的、不可修改的数据

严厉形式

严厉形式在语义上与一般的JavaScript有一些差别。

• 起首，严厉形式会将JavaScript圈套直接变成显著的毛病。

• 其次，严厉形式修改了一些引擎难以优化的毛病：一样的代码有些时刻严厉形式会比非严厉形式下更快。

• 第三，严厉形式禁用了一些有可能在将来版本中定义的语法。

由于我们ECMAScript 6中的一些特征，必须在严厉形式下，才够运用，而不报错。

严厉形式能够应用到全部script标签或某一般函数中。

为全部script标签开启严厉形式, 须要在一切语句之前放一个特定语句 “use strict”; （或 ‘use strict’;）

// 全部语句都开启严厉形式的语法
"use strict";
 let v = "Hi!  I'm a strict mode script!";

一样的，要给某个函数开启严厉形式，得把 “use strict”; (或 ‘use strict’; )声明一字不漏地放在函数体一切语句之前。

function strict()
{
// 函数级别严厉形式语法
'use strict';
return "Hi! I'm a strict mode function!" ;
}
function notStrict() { 
return "I'm not strict.";
}

let

let 许可把变量的作用域限制在块级域中。与 var 差别处是：var 说明变量要么是全局的，要么是函数级的，而没法是块级的。

let vs var

let的作用域是块，而var的作用域是函数

'use strict';
var a = 5;
var b = 10;
if (a === 5) {
let a = 4; // The scope is inside the if-block
var b = 1; // The scope is inside the function
console.log(a); // 4
console.log(b); // 1
} 
console.log(a); // 5
console.log(b); // 1

let在轮回中

能够运用let关键字绑定变量在轮回的局限而不是运用一个全局变量(运用var)定义。

'use strict';
for (let i = 0; i < 10; i++) {
console.log(i); // 0, 1, 2, 3, 4 ... 9
}
console.log(i); // i is not defined

上面报错，由于变量i不存在于for语句外的作用域中。let建立块级作用域变量的，运用var建立一个全局变量。

const

const这个声明建立一个常量,能够全局或部分的函数声明。

一个常量能够是全局的或者是部分的,常量遵照与变量雷同的作用域划定规矩。

一个常量不能够被从新赋值,而且不能被反复声明.所以,虽然能够在声明一个常量的时刻不举行初始化,但如许做是没有意义的,由于这个常量的值永久会坚持undefined。

一个常量不能和它地点作用域内的其他变量或函数具有雷同的称号。

示例
下面的例子演示了常量的行动。

const num = 10;
num =20;
console.log(num); // 10

假如我们在上面声明常量num，在声明var num，这时候会报错，num已声明。

const num = 10;
var num = 20;
console.log(num); // 'num' has already been declared

块级作用域

许多言语中都有块级作用域，JavaScript运用var声明变量，以function来分别作用域，大括号“{}” 却限制不了var的作用域。用var声明的变量具有变量提拔（declaration hoisting）的效果。

ES6里增加了一个let，能够在{}， if， for里声明。用法同var，但作用域限制在块级，let声明的变量不存在变量提拔。

'use strict';
function f1() {
var a = 1;
let n = 2;
if (true) {

  var a = 20;
  let n = 10;
}
console.log(n); // 2
console.log(a); // 20
}
f1();

类声明和类表达式

ES6 中的类实际上就是个函数，而且正如函数的定义体式格局有函数声明和函数表达式两种一样，类的定义体式格局也有两种，分别是：类声明、类表达式。

类声明

　　类声明是定义类的一种体式格局，就像下面如许，运用 class 关键字后跟一个类名（这里是 Ploygon），就能够定义一个类。

'use strict';
class Polygon {
    constructor(height, width) {
    
    this.height = height;
    this.width = width;
    }
}

变量提拔

　　类声明和函数声明差别的一点是，函数声明存在变量提拔征象，而类声明不会。也就是说，你必须先声明类，然后才运用它，不然代码会抛出 ——ReferenceError 非常，像下面如许：

var p = new Polygon(); // ReferenceError

class Polygon {}

类表达式

类表达式是定义类的别的一种体式格局，就像函数表达式一样，在类表达式中，类名是无足轻重的。假如定义了类名，则该类名只需在类体内部才访问到。

'use strict';
// 匿名类表达式
var Polygon = class {
    constructor(height, width) {
    
    this.height = height;
    this.width = width;
    }
};
// 定名类表达式
var Polygon = class Polygon {
    constructor(height, width) {
    
    this.height = height;
    this.width = width;
    }
};

组织函数

类的成员须要定义在一对花括号 {} 里，花括号里的代码和花括号自身组成了类体。类成员包含类组织器和类要领（包含静态要领和实例要领）。

class 依据 constructor 要领来建立和初始化对象。

constructor要领是类的默许要领，经由过程new敕令天生对象实例时，自动挪用该要领。一个类只能有一个constructor要领，假如没有显式定义，一个空的constructor要领会被默许增加。

constructor() {}
constructor要领默许返回实例对象（即this），完全能够指定返回别的一个对象。

'use strict';
class Foo {
    constructor() {   
          return Object.create(null);
    }
}
new Foo() instanceof Foo
// false

上面代码中，constructor函数返回一个全新的对象，效果致使实例对象不是Foo类的实例。

constructor 要领是一个特别的类要领，它既不是静态要领也不是实例要领，它仅在实例化一个类的时刻被挪用。一个类只能具有一个名为 constructor 的要领，不然会抛出 SyntaxError 非常。

严厉形式

类和模块的内部，默许就是严厉形式，所以不须要运用use strict指定运转形式。只需你的代码写在类或模块当中，就只需严厉形式可用。

静态要领

static关键字定义了一个类的静态要领。静态要领被称为无需实例化类也可当类被实例化。静态要领一般用于为应用程序建立有用函数。

示例

'use strict';
class Point {

    constructor(x, y) {
        this.x = x;
        this.y = y;
    }

    static distance(a, b) {
        const dx = a.x - b.x;
        const dy = a.y - b.y;
    
        return Math.sqrt(dx*dx + dy*dy);
    }
}

const p1 = new Point(5, 5);
const p2 = new Point(10, 10);

console.log(Point.distance(p1, p2));

运用 extends 关键字建立子类

extends 关键字能够用来建立继续于某个类的子类。

这个例子是依据名为Animal类建立一个名为Dog的类。

'use strict';
class Animal { 
    constructor(name) {
        this.name = name;
    }
    speak() {
        console.log(this.name + ' makes a noise.');
    }
}

class Dog extends Animal {
    speak() {
        console.log(this.name + ' barks.');
    }
}
var dog = new Dog('NiNi');
dog.speak();