ES6 Lambda

(param1,param2,...,paramN) => {
// 函数体
}

// 参数列表与箭头符号不能换行
var func = ()
=> 1;
// SyntaxError: expected expression, got '=>'

// 注意解析的优先级
let callback;
callback = callback || function() {}; // ok
callback = callback || () => {};
// SyntaxError: invalid arrow-function arguments
// 需要加括号提高解析优先级
callback = callback || (() => {}); // ok

(param1,param2,...,paramN) => expression
// 等价于
(param1,param2,...,paramN) => {
  return expression;
}

(singleParam) => {
    statements;
};
// 等价于
(singleParam) => {
    statements;
};

// 参数列表的小括号不能省略
() => {
    statements;
};

(params) => ({ foo: bar });

(param1, param2, ...rest) => {
    statements;
};

(param1 = defaultValue1, param2 = defaultValue2, paramN = defaultValueN) => {
    statements;
};

// a+b+c = a+b+a+b
var f = ([a = 5, b = 6] = [1, 2], { x: c } = { x: a + b }) => a + b + c;

f(); // 6
f([3, 4]); // 14
f([3]); // 18
f([3, 4], { x: 5 }); // 12

var materials = ["Hydrogen", "Helium", "Lithium", "Beryllium"];

materials.map(function (material) {
    return material.length;
}); // [8, 6, 7, 9]
// 等价于
materials.map((material) => {
    return material.length;
}); // [8, 6, 7, 9]
// 等价于
// 在参数列表中直接解构数组对象的 length 属性
materials.map(({ length }) => length); // [8, 6, 7, 9]

// this 作用域问题

function Person() {
    // 构造函数中的 this 表示对象本身
    this.age = 0;

    setInterval(function growUp() {
        // 在 non-strict 模式中, growUp()函数中的 this 是全局对象
        // growUp 是全局函数，不是对象的方法
        this.age++;
        // 浏览器环境中全局对象为 window
        // window.age=undefined
        // undefined++ -> NAN
        // NAN++ -> NAN
        // 一直都是 NAN
    }, 1000);
}

var p = new Person();

// ES3/5 中，可以定义一个变量指向外部对象

function Person() {
    var that = this;
    that.age = 0;

    setInterval(function growUp() {
        // that 暂存了对象的引用
        that.age++;
    }, 1000);
}

// 还有一种方式直接绑定函数的 this 对象
function Person() {
    this.age = 0;

    setInterval(
        function growUp() {
            // 这时的 this 就是 Person 对象
            this.age++;
        }.bind(this),
        1000
    );
}

// ES6 有了箭头函数，就不用这么麻烦了，因为箭头函数中没有 this 变量
function Person() {
    this.age = 0;

    setInterval(() => {
        // 这里的 this 对象就是 Person 对象
        this.age++;
    }, 1000);
}

var p = new Person();

var func = (a, b) => a + b;
func.call(null, 1, 2); // 3
func.apply(null, [1, 2]); // 3

var arr = () => arguments[0];
arr(); // ReferenceError: arguments is not defined

var arguments = [1, 2, 3];
// 因为箭头函数没有自己的 arguments
// 所以访问的是父作用域中的 arguments
var arr = () => arguments[0];
arr(); // 1

// 使用可变参数作为 arguments 使用
var f = (...args) => args[0] + n;

// 普通函数有自己的 arguments 变量
function foo(n) {
    var f = () => arguments[0] + n;
    return f();
}

foo(1); // 2

var obj = {
    i: 10,
    // 箭头函数没有 this,所以访问的是全局 this
    b: () => console.log(this.i, this),
    c: function () {
        console.log(this.i, this);
    },
};

obj.b(); // undefined, Window {...} (or the global object)
obj.c(); // 10, Object {...}

var Foo = () => {
    this.age = 18;
};
var foo = new Foo(); // TypeError: Foo is not a constructor

var Foo = () => {};
console.log(Foo.prototype); // undefined