Node.js ES6（harmony模式）支持情况一览

2014年3月9日 on javascript , NodeJs

本文地址：http://www.2fz1.com，转载请注明来源。

ES6指：ECMAScript 6草案 (2012.4) 规定。

Node.js需要0.11.*版本来开启ES6实验阶段的支持，官网最新版本下载链接。

安装 0.11.* 以后的版本后，通过node --harmony来启动应用程序。本文只例出Node.js支持的新特性，暂未支持的特性，不在本文介绍范围。以下特性均通过Node.js v0.11.9测试！

const

声明一个只读的命名常量，一个常量不可以被重新赋值，并且不能被重复声明。

const例子

const a = 'a';
console.log(a); //a
a = 'b';
console.log(a); //a

//以下重复定义，会报错
//Error:Variable 'a' has already been declared
var a = 'c';
const a = 'd';
console.log(a);

generators

生成器函数。JS的异步编程新利器，生成器函数通常和 yield 关键字同时使用。函数执行到每个 yield 时都会中断并返回 yield 的右值（通过 next 方法返回对象中的 value 字段）。下次调用 next，函数会从 yield 的下一个语句继续执行。等到整个函数执行完，next 方法返回的 done 字段会变成 true。

该新特性涉及的知识较多，请大家自行搜索查阅。

generators例子

创建一个生成器函数，在function与字面量之间，添加一个“ * ”号，可以左右留有空格。

function * foo(){};
console.log ( foo.toString() ); //function* foo(){}
console.log ( foo.constructor ); //[Function: GeneratorFunction]

//函数是否是generatorFunction的判断方法
function isGeneratorFunction(obj) {
  return obj &amp;&amp; obj.constructor &amp;&amp; 'GeneratorFunction' === obj.constructor.name
}

console.log( isGeneratorFunction(foo) ); //true

使用生成器函数

function * list(a,b,c){
    var y1 = yield a;
    console.log(y1); //next2
    var y2 = yield b;
    console.log(y2); //next3
    var y3 = yield c;
    console.log(y3); //next4
    return 'done';
};

var List = list(1,2,3); //注意这边是看起来是调用，实际上foo只是做生成器的编译处理，并没有运行函数内程序，需要调用next()才会运行。
console.log( List.next('next1') ); //{ value: 1, done: false }
console.log( List.next('next2') ); //{ value: 2, done: false }
console.log( List.next('next3') ); //{ value: 3, done: false }
console.log( List.next('next4') ); //{ value: 'done', done: true }

上述代码有两点要注意：

next()的返回值value是yield的在值。
yield的返回值与其右值无关，其值为下一个next()函数调用时传入的第一个参数。

Map

Map对象就是简单的键/值映射.其中键和值可以是任意值(原始值或对象值).

在判断两个值是否为同一个键的时候,使用的并不是===运算符,而是使用了一种称之为”same-value”的内部算法, 该算法很特殊, 对于Map对象来说, +0 (按照以往的经验与 -0 是严格相等的)和-0 是两个不同的键. 而NaN在作为Map对象的键时和另外一个NaN是一个相同的键(尽管NaN !== NaN).（关于NaN及+0和-0请参阅本文的Object.is）

Map例子

var myMap = new Map();

//Map继承了Obejct
myMap[-0] = -0;
myMap[+0] = +0;
myMap['+0'] = '+0';
myMap[NaN] = NaN;
myMap[NaN] = NaN;
myMap[{}] = {};
myMap[new Object()] = new Object();
console.log(myMap); //{ '0': 0, '+0': '+0', NaN: NaN, '[object Object]': {} }

//真正的Map实例
var keyObj = {},keyObj2 = {},keyFunc = function () {};
myMap.set('a','a');
myMap.set(-0,'-0');
myMap.set(+0,'+0');
myMap.set(keyObj,'{}');
myMap.set(keyObj2,'{}2');
myMap.set(keyFunc,'function() {}');
console.log( myMap.get('a') ); //a
console.log( myMap.get(-0) ); //-0
console.log( myMap.get(+0) ); //-0
console.log( myMap.get(keyObj) ); //{}
console.log( myMap.get(keyObj2) ); //{}2
console.log( myMap.get(keyFunc) ); //function() {}

Set

一个Set对象允许你向里面存储任意类型的唯一值(不能重复), 不管是原始值还是对象值. 在Set中,判断两个值是否相等的算法与 ===运算符不同,该算法很特殊, 对于Set来说,+0 (按照以往的经验与-0是严格相等的) 和-0 是两个不同的值,还有NaN和另一个NaN是相同的值,不能同时存进一个Set中.

Set例子

var mySet = new Set();
mySet.add(1);
mySet.add('a');
mySet.add({});
mySet.add({});
mySet.add(-0);
mySet.add(+0);
console.log(mySet.size); //6
console.log ( mySet.has(+0) ); //true

mySet.delete(1);
console.log(mySet.size); //5

WeakMap

WeakMap对象就是简单的键/值映射.但键只能是对象值,不可以是原始值。WeakMap 相对于普通的 Map，也是键值对集合，只不过 WeakMap 的 key 只能是非空对象（non-null object）。

WeakMap例子

var wm1 = new WeakMap(),
    wm2 = new WeakMap();
var o1 = {},
    o2 = function(){};

wm1.set(o1,wm2); //值可以为任意值，包括另一个WeakMap
console.log(wm1.get(o1)); //{}
wm1.set(wm2,o2); //键只能是对象引用，不能是基本类型，但可以是另一个WeakMap
console.log(wm1.get(wm2)); //[Function]

为什么要使用WeakMap?

WeakMap 对它的 key 仅保持弱引用，也就是说它不阻止垃圾回收器回收它所引用的 key。WeakMap 最大的好处是可以避免内存泄漏。一个仅被 WeakMap 作为 key 而引用的对象，会被垃圾回收器回收掉。正因为是弱类型引用，WeakMap不能迭代，也没有size方法，这一点一定要分清楚。

Object.is

判断两个值是否真正是同一个值。类似于===运算符，不过有两个特例，NaN和Nan，-0和+0;

Object.is例子

console.log(0 === -0); //true
console.log( Object.is(0,-0) ); //false
console.log( Object.is(+0,-0) ); //false
console.log( Object.is('a','a') ); //true
console.log( Object.is({},{}) ); //false
console.log( NaN === NaN ); //false;
console.log( Object.is(NaN,NaN) ); //true
var obj = {};
var obj2 = obj;
console.log( Object.is(obj,obj2) ); //true

String.prototype.repeat

返回一个重复当前字符串若干次数的新字符串。参数必须大于等于0。

String.prototype.repeat例子

var str = 'abc';
console.log( str.repeat(0) ); //''
console.log( str.repeat(1) ); //'abc'
console.log( str.repeat(2) ); //'abcabc'
console.log( str.repeat(-1) ); //Error,Invalid count value

String.prototype.startsWith

判断当前字符串是否是以另一个字符串”开头”的，返回布尔值，第一个参数为要查找的字符串，第二次参数为开始查找的位置，默认为0。

String.prototype.startsWith例子

var str = 'abc def';
console.log( str.startsWith('a') ); //true
console.log( str.startsWith('d',4) ); //true

String.prototype.endsWith

判断当前字符串是否是以另一个字符串”结尾”的，返回布尔值，第一个参数为要查找的字符串，第二次参数为结束查找的位置，默认为字符串的结尾处。

String.prototype.endsWith例子

var str = 'abc def';
console.log( str.endsWith('def') ); //true
console.log( str.endsWith('d',5) ); //true

String.prototype.contains

判断一个字符串是否被包含在另一个字符串中，返回布尔值，第一个参数为要查找的字符串，第二次参数为开始查找的位置，默认为0。

String.prototype.contains例子

var str = 'abc def';
console.log( str.contains('def') ); //true
console.log( str.contains('d',4) ); //true
console.log( str.contains('a',1) ); //false

Array.prototype.find

在数组查找成员，找到后马上返回该成员，停止查找。接受一个function参数，并需要返回布尔值，该function有三个参数传入，依次是：当前数组成员值，当前数组成员索引，当前数组。

Array.prototype.find例子

console.log(Array.prototype.find); //[Function: find]
var arr = ['a','b','c','d','e','f','g','a'];
var pos = arr.find(function(thisVal,thisIndex,thisArr){
    if(thisVal=='a' || thisVal=='c'){
        return true;
    }
});
console.log(pos); //a

Array.prototype.findIndex

和 Array.prototype.find 类似，不过返回的是找到成员的索引值。

Array.prototype.findIndex例子

console.log(Array.prototype.findIndex); //[Function: findIndex]
var arr = ['a','b','c','d','e','f','g','c'];
var pos = arr.findIndex(function(thisVal,thisIndex,thisArr){
    if(thisVal=='c'){
        return true;
    }
});
console.log(pos); //2

Number.isFinite

判定指定的参数是否是有限的。和全局的 isFinite 方法相比，这个方法不会强制把参数转换为数值。这意味着只有数值类型的值，并且是有限的，则返回true

Number.isFinite例子

console.log( Number.isFinite(Infinity) ); //false
console.log( Number.isFinite(-Infinity) ); //false
console.log( Number.isFinite(NaN) ); //false

console.log( Number.isFinite('0') ); //false
console.log( isFinite('0') ); //true

console.log( Number.isFinite(0) ); //true

Number.isNaN

判断一个值是否是NaN.和全局函数isNaN不同的是,该函数没有自动类型转换的问题.

Number.isNaN例子

console.log( Number.isNaN(NaN) ); //true
console.log( Number.isNaN(0 / 0) ); //true
console.log( Number.isNaN('NaN') ); //false
console.log( isNaN('NaN') ); //true

Math.imul

该函数返回两个参数的类C的32位整数乘法运算的运算结果.

Math.imul例子

Math.imul(2, 4) // 8
Math.imul(-1, 8) // -8
Math.imul(-2, -2) // 4
Math.imul(0xffffffff, 5) //-5
Math.imul(0xfffffffe, 5) //-10

最后修改时间：2014年9月10日星期三晚上8点52