[iojs][es6]ES6 features in iojs-1.1.0

pure-iojs-features.js

console.log("<<ES6 features in iojs default runtime>>");
console.log(process.versions);

(function letVariable() {
    "use strict";
    // "let" only allow in strict mode
    var i = 0;
    {
        let i = 10;
        console.log("[let]let i:", i);
    }
    console.log("[let] outside i:", i);
})();

(function constVariableStrict() {
    "use strict";
    
    const i = 0;
    try {
        i = 10;
    } catch (err) {
        console.log("[const] assign to const i", err);
    }
})();

(function functionInBlock() {
    "use strict";
    
    {
        // Not allowed in ES5 strict syntax, but ignored from many runtimes.
        console.log("[function in block] allowed:", foo());
        function foo() {return true;}
    }
})();

(function map() {
    var m1 = new Map();
    var m2 = new Map([["abc", 10], ["def", 20]]);

    console.log("[map] m.get(key): ", m2.get("abc"));
    console.log("[map] m.set(key, value).set(key, value):",
                m2.set("abc", 30).set("ghi", 40));
    console.log("[map] m.get(key):", m2.get("abc"));

    // iterators
    var keys = m2.keys();
    console.log("[map] keys iter 0:", keys.next().value);
    console.log("[map] keys.iter 1:", keys.next().value);
    var values = m2.values();
    console.log("[map] values iter 0:", values.next().value);
    console.log("[map] values.iter 1:", values.next().value);
    var entries = m2.entries();
    console.log("[map] entries iter 0:", entries.next().value); // [key, value]
    console.log("[map] entries iter 1:", entries.next().value);
    
    m2.forEach(function (value, key, map) {
        console.log("[map] forEach(function (value, key, map){}):",
                    value, key, map);
    });

    // removing
    console.log("[map] m.size:", m2.size);
    console.log("[map] m.delete(key):", m2.delete("abc"));
    console.log("[map] m.has(key)", m2.has("abc"));
    console.log("[map] m.clear():", m2.clear());
    console.log("[map] m.size:", m2.size);
})();

(function weakMap() {
    var wm = new WeakMap();
    // weakmap key is only allow non-primitive
    var o1 = {};
    var o2 = {};
    // weak map has only "get(key), set(key, value), has(key), delete(key)"
    wm.set(o1, new WeakMap());
    wm.get(o1).set(o2, function keepInWeakMap(){});
    console.log("[weakmap] wm.get(key).get(key): ", wm.get(o1).get(o2));
    wm.get(o1).delete(o2);
    console.log("[weakmap] wm.get(key).has(key): ", wm.get(o1).has(o2));
    // keepInWeakMap object will GCed
})();

(function set() {
    var s = new Set();
    console.log("[set] s.add(v).add(v):", s.add("abc").add("def"));
    console.log("[set] s.delete(v):", s.delete("abc"));
    console.log("[set] s.has(v):", s.has("abc"));

    // iterators compat with Map
    var keys = s.keys();
    console.log("[set] keys.next().value:", keys.next().value);
    var values = s.values();
    console.log("[set] values.next().value:", values.next().value);
    var entries = s.entries();
    console.log("[set] entries.next().value:", entries.next().value);
    s.forEach(function (value, key, set) {
        console.log("[set] s.forEach(function (value, key, set) {}):",
                    value, key, set);
    });
    
    console.log("[set] s.clear():", s.clear());
    console.log("[set] s.size:", s.size);
})();

(function weakSet() {
    var ws = new WeakSet();
    var o1 = {};

    // weakset has only add(o), has(o), delete(o)
    console.log("[weakset] ws.add(o):", ws.add(o1));
    console.log("[weakset] ws.has(o):", ws.has(o1));
    console.log("[weakset] ws.delete(o):", ws.delete(o1));
})();

(function generator1() {
    var genFunc = function* () {
        yield 0;
        yield 1;
        return 2;
    };
    console.log("[generator1] generator function:", genFunc);
    var gen = genFunc();
    console.log("[generator1] generator:", gen);
    console.log("[generator1] entry 0:", gen.next());
    console.log("[generator1] entry 1:", gen.next());
    console.log("[generator1] entry 2(done):", gen.next());
    // usually done value is ignored
})();


(function generator2() {
    var gf1 = function* (name) {
        yield name + 1;
        yield name + 2;
        return name + 3;
    };
    var gf2 = function* () {
        yield 0;
        yield* gf1("a");
        return 3;
    };
    var gen = gf2();
    console.log("[generator2] entry 0:", gen.next());
    console.log("[generator2] entry 1:", gen.next());
    console.log("[generator2] entry 2:", gen.next());
    console.log("[generator2] entry 3(done):", gen.next());
})();

(function iterator() {
    var a = ["a", "b", "c"];
    // any iterable has an iterator function at Symbol.iterator property 
    var iter = a[Symbol.iterator]();
    console.log("[iterator]: iter.next():", iter.next());
    console.log("[iterator]: iter.next():", iter.next());
    console.log("[iterator]: iter.next():", iter.next());
    console.log("[iterator]: iter.next():", iter.next());

    // for-of loop for iterator and iterable
    var iter = a[Symbol.iterator]();
    for (var i of iter) console.log("[iterator] for-of iterator:", i);
    for (var i of a) console.log("[iterator] for-of iterable:", i);

    // generator as iterator
    for (var i of function* () {
        yield 0;
        yield 1;
        return 2; //ignored
    }()) console.log("[iterator] for-of generator:", i);

    // yield* allows iterable
    for (var i of function* () {
        yield 0;
        yield* [1,2];
        return 3;
    }()) console.log("[iterator] yield* for iterable:", i);

    // customr iterable with Symbol.iterator pros
    var o = {};
    o[Symbol.iterator] = function* () {
        yield "a";
        yield "b";
    };
    for (var i of o) console.log("[iterator] custom iterable:", i);
})();

(function literalBinaryOcted() {
    console.log("[num literal] binary:", 0b0101);
    console.log("[num literal] octed:", 0o0644);
})();

(function promise() {
    var p = new Promise(function (fulfill, reject) {
        fulfill(10);
    });
    p.then(function (v) {console.log("[promise] fulfill-then:", v);});
    
    Promise.resolve(20).then(function (v) {
        console.log("[promise] resolve-then:", v);});
    
    Promise.reject(30).catch(function (e) {
        console.log("[promise] reject-catch:", e);});

    Promise.all([Promise.resolve(1), Promise.resolve(2)]).then(function (v) {
        console.log("[promise] all-then:", v);}); // array

    // the earliest fulfilled/rejected promise applyed
    Promise.race([Promise.reject(1), Promise.resolve(2)]).then(function (v) {
        console.log("[promise] race-then:", v);
    }).catch(function (e) {
        console.log("[promise] race-catch:", e);
    });
})();

(function newStringMethods() {
    console.log("[string] s.repeat(n):", "abc".repeat(3));
    console.log("[string] s.startsWith(s):", "abc".startsWith("a"));
    //console.log("[string] s.contains(s):", "abc".contains("b"));
    console.log("[string] s.normalize(form):",
                "\u1E9B\0323".normalize("NFD").length);
})();

(function template() {
    var v = 10;
    console.log("[template] `... ${expr} ...`:", `a = ${v}`);
    var s = `[template] 1 + 2 =: ${1 + 2}`;
    console.log(s);

    console.log("[template] unescaped raw string: ", String.raw`foo\nbar`);

    // custom template
    var tag = function (strings) {
        var values = Array.prototype.slice.call(arguments, 1);
        console.log("[template] tag func strings:", strings);
        console.log("[template tag func values:", values);
        return "Replaced";
    };
    console.log("[template] custom tag string:",
                tag`abc ${1+2} def ${"abc"} `);
})();

(function symbol() {
    console.log("[symbol] Symbol(k) !== Symbol(k):",
                Symbol("foo") === Symbol("foo"));
    console.log("[symbol] global symbol Symbol.for(k) === Symbol.for(k):",
                Symbol.for("foo") === Symbol.for("foo"));
    console.log("[symbol] Symbol.keyFor(globalsym):",
                Symbol.keyFor(Symbol.for("foo")));
    console.log("[symbol] @@iterator:", "abc"[Symbol.iterator]);
    console.log("[symbol] @@unscopables:", ["abc"][Symbol.unscopables]);
})();

result.txt

<<ES6 features in iojs default runtime>>
{ http_parser: '2.3.0',
  node: '1.1.0',
  v8: '4.1.0.14',
  uv: '1.3.0',
  zlib: '1.2.8',
  ares: '1.10.0-DEV',
  modules: '43',
  openssl: '1.0.1k' }
[let]let i: 10
[let] outside i: 0
[const] assign to const i [TypeError: Assignment to constant variable.]
[function in block] allowed: true
[map] m.get(key):  10
[map] m.set(key, value).set(key, value): {}
[map] m.get(key): 30
[map] keys iter 0: abc
[map] keys.iter 1: def
[map] values iter 0: 30
[map] values.iter 1: 20
[map] entries iter 0: [ 'abc', 30 ]
[map] entries iter 1: [ 'def', 20 ]
[map] forEach(function (value, key, map){}): 30 abc {}
[map] forEach(function (value, key, map){}): 20 def {}
[map] forEach(function (value, key, map){}): 40 ghi {}
[map] m.size: 3
[map] m.delete(key): true
[map] m.has(key) false
[map] m.clear(): undefined
[map] m.size: 0
[weakmap] wm.get(key).get(key):  function keepInWeakMap(){}
[weakmap] wm.get(key).has(key):  false
[set] s.add(v).add(v): {}
[set] s.delete(v): true
[set] s.has(v): false
[set] keys.next().value: def
[set] values.next().value: def
[set] entries.next().value: [ 'def', 'def' ]
[set] s.forEach(function (value, key, set) {}): def def {}
[set] s.clear(): undefined
[set] s.size: 0
[weakset] ws.add(o): {}
[weakset] ws.has(o): true
[weakset] ws.delete(o): true
[generator1] generator function: function* () {
        yield 0;
        yield 1;
        return 2;
    }
[generator1] generator: {}
[generator1] entry 0: { value: 0, done: false }
[generator1] entry 1: { value: 1, done: false }
[generator1] entry 2(done): { value: 2, done: true }
[generator2] entry 0: { value: 0, done: false }
[generator2] entry 1: { value: 'a1', done: false }
[generator2] entry 2: { value: 'a2', done: false }
[generator2] entry 3(done): { value: 3, done: true }
[iterator]: iter.next(): { value: 'a', done: false }
[iterator]: iter.next(): { value: 'b', done: false }
[iterator]: iter.next(): { value: 'c', done: false }
[iterator]: iter.next(): { value: undefined, done: true }
[iterator] for-of iterator: a
[iterator] for-of iterator: b
[iterator] for-of iterator: c
[iterator] for-of iterable: a
[iterator] for-of iterable: b
[iterator] for-of iterable: c
[iterator] for-of generator: 0
[iterator] for-of generator: 1
[iterator] yield* for iterable: 0
[iterator] yield* for iterable: 1
[iterator] yield* for iterable: 2
[iterator] custom iterable: a
[iterator] custom iterable: b
[num literal] binary: 5
[num literal] octed: 420
[string] s.repeat(n): abcabcabc
[string] s.startsWith(s): true
[string] s.normalize(form): 3
[template] `... ${expr} ...`: a = 10
[template] 1 + 2 =: 3
[template] unescaped raw string:  foo\nbar
[template] tag func strings: [ 'abc ', ' def ', ' ' ]
[template tag func values: [ 3, 'abc' ]
[template] custom tag string: Replaced
[symbol] Symbol(k) !== Symbol(k): false
[symbol] global symbol Symbol.for(k) === Symbol.for(k): true
[symbol] Symbol.keyFor(globalsym): foo
[symbol] @@iterator: function [Symbol.iterator]() { [native code] }
[symbol] @@unscopables: { copyWithin: true,
  entries: true,
  fill: true,
  find: true,
  findIndex: true,
  keys: true }
[promise] fulfill-then: 10
[promise] resolve-then: 20
[promise] reject-catch: 30
[promise] all-then: [ 1, 2 ]
[promise] race-catch: 1