ECMAScriptNode.js 的ES6初特色 1-作用域声明与接近基础运用

新的nodejs7.5已生,但不少经历了node4的口也会见忍不住慨叹,发展绝抢了。是的,前端技术迅速发展,势不可挡啊。打好基础才是素有。这其中为基础之nodejs4讲述ES6的片段初特点。

 

简介

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
语言专业之时髦版本,而且许多新特征数都是开箱即用的。这些新特性包括:

  • 1 classes – 各种 ‘类’,再为随便需用 CoffeeScript 的语法糖写类了
    2 generators - 未来的.js 代码中将有无数生成器,不学一点就看不懂 JS 代码了哦
    3 collections - 集合、映射、弱集合、弱映射
    4 arrow functions - 箭向函数
    5 block scoping - 使用 let 、const 作用域,块辖域
    6 template strings - 模板字串
    7 promises - 用标准化了的方法进行延迟和异步计算
    8 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();

宣称一个看似,命名吧(Person),构造函数(constructor)中定义name属性,并定义一个实例方法sayName(){…}中打印’My
name is’+this.name ,根据名吧Person类创建一个叫吧Tom的近乎。

'use strict';
class Person{
 constructor(name){
   this.name=name;
 }
   sayName(){
  console.log("test=>"+ this.name);
  }
}
var p1=new Person("star1");
p1.sayName();


var p2=new Person("star2");
p2.sayName();