Space1000

http://espadrine.github.io/New-In-A-Spec/es6/

EcmaScript Sixth Edition

let, const (define block-local vars), function in block scope

destructuring: let {x, y} = pt; let [s, v, o] = triple(); (assuming let pt = {x:2, y:-5}, for instance).

parameter default values: function f(x, y=1, z=0) {⋯}

rest: function g(i, j, ...r) { return r.slice(i, j); } (instead of using arguments like a madman).

spread: let a = [0,1,2,3], o = new Something(...a);

proxies: let obj = Proxy.create(handler, proto). Long story short: ~ operator overloading with object-like elements.

weak map: let map = new WeakMap. Use it if you have circular references in it.

generators: function* gen() { yield 1; yield 2; } Actually, gen() returns ~ an object with a next() function property.

iterators: for (var [key, val] of items(x)) { alert(key + ',' + val); }. Iterators can be generators or proxies.

array and generator comprehension: [a+b for (a in A) for (b in B)] (array comprehension), (x for (x of generateValues()) if (x.color === 'blue')) (generator expression).

binary data: const Pixel = new StructType({x:uint32, y:uint32, color:Color}) (if Color is itself a StructType), new ArrayType(Pixel, 3).

class syntax, with extends, prototype, and super:

class Point extends Base {
constructor(x,y) {
super();
this[px] = x, this[py] = y;
this.r = function() { return Math.sqrt(x*x + y*y); }
}
get x() { return this[px]; }
get y() { return this[py]; }
proto_r() { return Math.sqrt(this[px] * this[px] +
this[py] * this[py]); }
equals(p) { return this[px] === p[px] &&
this[py] === p[py]; }
}

modules:

module math {
export function sum(x, y) {
return x + y;
}
export var pi = 3.141593;
}

import {sum, pi} from math;
alert(sum(pi,pi));

quasis: multiline, substitution-ready strings with extensibility. `You are ${age} years old.`.

// The following regexp spans multiple lines.
re`line1: (words )*
line2: \w+`

// It desugars to:
re({raw:'line1: (words )*\nline2: \w+',
cooked:'line1: (words )*\nline2: \w+'})

Запишу сюда, вдруг понадобится. Один раз уже пригодилось. Работающий пример javascript прокси.

function handlerMaker(obj) 
{
    return {

        getOwnPropertyDescriptor: function(name) 
        {
          console.log("getOwnPropertyDescriptor",name)
          var desc = Object.getOwnPropertyDescriptor(obj, name);
          // a trapping proxy's properties must always be configurable
          if (desc !== undefined) { desc.configurable = true; }
          return desc;
        },

        getPropertyDescriptor:  function(name) 
        {
            console.log("getPropertyDescriptor",name)
            var desc = Object.getPropertyDescriptor(obj, name); // not in ES5
            // a trapping proxy's properties must always be configurable
            if (desc !== undefined) { desc.configurable = true; }
            return desc;
        },

        getOwnPropertyNames: function()
        {
            console.log("getOwnPropertyNames")
            return Object.getOwnPropertyNames(obj);
        },

        getPropertyNames: function()
        {
            console.log("getPropertyNames")
            return Object.getPropertyNames(obj);                // not in ES5
        },

        defineProperty: function(name, desc) 
        {
            console.log("defineProperty", name, desc)
            Object.defineProperty(obj, name, desc);
        },

        delete: function(name) 
        {
            console.log("delete", name)
            return delete obj[name];
        },   

        fix: function() 
        {
            console.log("fix")
            if (Object.isFrozen(obj)) 
            {
                var result = {};
                Object.getOwnPropertyNames(obj).forEach(function(name) 
                {
                    result[name] = Object.getOwnPropertyDescriptor(obj, name);
                });
                return result;
            }
            // As long as obj is not frozen, the proxy won't allow itself to be fixed
            return undefined; // will cause a TypeError to be thrown
        },

        has: function(name) 
        { 
            console.log("has",name)
            return name in obj;
        },

        hasOwn: function(name) 
        { 
            console.log("hasOwn",name)
            return ({}).hasOwnProperty.call(obj, name); 
        },

        get: function(receiver, name) 
        { 
            console.log("get", receiver, name)
            return obj[name]; 
        },

        set: function(receiver, name, val) 
        { 
            console.log("set", receiver, name, val)
            obj[name] = val; 
            return true; 
        }, // bad behavior when set fails in non-strict mode

        enumerate: function() 
        {
            console.log("enumerate")
            var result = [];
            for (var name in obj) { result.push(name); };
            return result;
        },

        keys: function() 
        { 
            console.log("enumerate")
            return Object.keys(obj); 
        }

    }
}

var proxy = Proxy.create(handlerMaker({key:"asdf"}));

return proxy