（一）閉包
一、函式作為返回值
高階函式除了可以接受函式作為引數外，還可以把函式作為結果值返回。
求和的函式定義：
function sum(arr) {
    return arr.reduce(function (x, y) {
        return x + y;
    });
}
sum([1, 2, 3, 4, 5]); // 15
可以不返回求和的結果，而是返回求和的函式！
function lazy_sum(arr) {
    var sum = function () {
        return arr.reduce(function (x, y) {
            return x + y;
        });
    }
    return sum;
}
當呼叫lazy_sum()時，返回的並不是求和結果，而是求和函式：
var f = lazy_sum([1, 2, 3, 4, 5]); // function sum()
呼叫函式f時，才真正計算求和的結果：
f(); // 15
在這個例子中，在函式lazy_sum中又定義了函式sum，並且，內部函式sum可以引用外部函式lazy_sum的引數和區域性變數，當lazy_sum返回函式sum時，相關引數和變數都儲存在返回的函式中，這種稱為“閉包（Closure）”的程式結構擁有極大的威力。
請再注意一點，當我們呼叫lazy_sum()時，每次呼叫都會返回一個新的函式，即使傳入相同的引數：
var f1 = lazy_sum([1, 2, 3, 4, 5]);
var f2 = lazy_sum([1, 2, 3, 4, 5]);
f1 === f2; // false
f1()和f2()的呼叫結果互不影響。
二、閉包
注意到返回的函式在其定義內部引用了局部變數arr，所以，當一個函式返回了一個函式後，其內部的區域性變數還被新函式引用，所以，閉包用起來簡單，實現起來可不容易。
另一個需要注意的問題是，返回的函式並沒有立刻執行，而是直到呼叫了f()才執行。我們來看一個例子：
function count() {
    var arr = [];
    for (var i=1; i<=3; i++) {
        arr.push(function () {
            return i * i;
        });
    }
    return arr;
}
var results = count();
var f1 = results[0];
var f2 = results[1];
var f3 = results[2];
在上面的例子中，每次迴圈，都建立了一個新的函式，然後，把建立的3個函式都新增到一個Array中返回了。
你可能認為呼叫f1()，f2()和f3()結果應該是1，4，9，但實際結果是：
f1(); // 16
f2(); // 16
f3(); // 16
全部都是16！原因就在於返回的函式引用了變數i，但它並非立刻執行。等到3個函式都返回時，它們所引用的變數i已經變成了4，因此最終結果為16。
返回閉包時牢記的一點就是：返回函式不要引用任何迴圈變數，或者後續會發生變化的變數。
如果一定要引用迴圈變數怎麼辦？方法是再建立一個函式，用該函式的引數繫結迴圈變數當前的值，無論該迴圈變數後續如何更改，已繫結到函式引數的值不變：
function count() {
    var arr = [];
    for (var i=1; i<=3; i++) {
        arr.push((function (n) {
            return function () {
                return n * n;
            }
        })(i));
    }
    return arr;
}
var results = count();
var f1 = results[0];
var f2 = results[1];
var f3 = results[2];
f1(); // 1
f2(); // 4
f3(); // 9
注意這裡用了一個“建立一個匿名函式並立刻執行”的語法：
(function (x) {
    return x * x;
})(3); // 9
理論上講，建立一個匿名函式並立刻執行可以這麼寫：
function (x) { return x * x } (3);
但是由於JavaScript語法解析的問題，會報SyntaxError錯誤，因此需要用括號把整個函式定義括起來：
(function (x) { return x * x }) (3);
通常，一個立即執行的匿名函式可以把函式體拆開，一般這麼寫：
(function (x) {
    return x * x;
})(3);
說了這麼多，難道閉包就是為了返回一個函式然後延遲執行嗎？
在面向物件的程式設計語言裡，比如Java和C++，要在物件內部封裝一個私有變數，可以用private修飾一個成員變數。
在沒有class機制，只有函式的語言裡，藉助閉包，同樣可以封裝一個私有變數。我們用JavaScript建立一個計數器：
'use strict';
function create_counter(initial) {
    var x = initial || 0;
    return {
        inc: function () {
            x += 1;
            return x;
        }
    }
}
它用起來像這樣：
var c1 = create_counter();
c1.inc(); // 1
c1.inc(); // 2
c1.inc(); // 3
var c2 = create_counter(10);
c2.inc(); // 11
c2.inc(); // 12
c2.inc(); // 13
在返回的物件中，實現了一個閉包，該閉包攜帶了區域性變數x，並且，從外部程式碼根本無法訪問到變數x。換句話說，閉包就是攜帶狀態的函式，並且它的狀態可以完全對外隱藏起來。
閉包還可以把多引數的函式變成單引數的函式。例如，要計算xy可以用Math.pow(x, y)函式，不過考慮到經常計算x2或x3，我們可以利用閉包建立新的函式pow2和pow3：
function make_pow(n) {
    return function (x) {
        return Math.pow(x, n);
    }
}
// 建立兩個新函式:
var pow2 = make_pow(2);
var pow3 = make_pow(3);
pow2(5); // 25
pow3(7); // 343
腦洞大開
很久很久以前，有個叫阿隆佐·邱奇的帥哥，發現只需要用函式，就可以用計算機實現運算，而不需要0、1、2、3這些數字和+、-、*、/這些符號。
JavaScript支援函式，所以可以用JavaScript用函式來寫這些計算。來試試：

'use strict';
// 定義數字0:
var zero = function (f) {
    return function (x) {
        return x;
    }
};
// 定義數字1:
var one = function (f) {
    return function (x) {
        return f(x);
    }
};
// 定義加法:
function add(n, m) {
    return function (f) {
        return function (x) {
            return m(f)(n(f)(x));
        }
    }
}
// 計算數字2 = 1 + 1:
var two = add(one, one);
// 計算數字3 = 1 + 2:
var three = add(one, two);
// 計算數字5 = 2 + 3:
var five = add(two, three);
// 你說它是3就是3，你說它是5就是5，你怎麼證明？
// 呵呵，看這裡:
// 給3傳一個函式,會列印3次:
(three(function () {
    console.log('print 3 times');
}))();
// 給5傳一個函式,會列印5次:
(five(function () {
    console.log('print 5 times');

}))();

（二）箭頭函式

ES6標準新增了一種新的函式：Arrow Function（箭頭函式）。為什麼叫Arrow Function？因為它的定義用的就是一個箭頭：
x => x * x
上面的箭頭函式相當於：
function (x) {
    return x * x;
}
箭頭函式相當於匿名函式，並且簡化了函式定義。箭頭函式有兩種格式，一種像上面的，只包含一個表示式，連{ ... }和return都省略掉了。還有一種可以包含多條語句，這時候就不能省略{ ... }和return：
x => {
    if (x > 0) {
        return x * x;
    }
    else {
        return - x * x;
    }
}
如果引數不是一個，就需要用括號()括起來：
// 兩個引數:
(x, y) => x * x + y * y
// 無引數:
() => 3.14
// 可變引數:
(x, y, ...rest) => {
    var i, sum = x + y;
    for (i=0; i<rest.length; i++) {
        sum += rest[i];
    }
    return sum;
}
如果要返回一個物件，就要注意，如果是單表示式，這麼寫的話會報錯：
// SyntaxError:
x => { foo: x }
因為和函式體的{ ... }有語法衝突，所以要改為：
// ok:
x => ({ foo: x })
this

箭頭函式看上去是匿名函式的一種簡寫，但實際上，箭頭函式和匿名函式有個明顯的區別：箭頭函式內部的this是詞法作用域，由上下文確定。
由於JavaScript函式對this繫結的錯誤處理，下面的例子無法得到預期結果：
var obj = {
    birth: 1990,
    getAge: function () {
        var b = this.birth; // 1990
        var fn = function () {
            return new Date().getFullYear() - this.birth; // this指向window或undefined
        };
        return fn();
    }
};
現在，箭頭函式完全修復了this的指向，this總是指向詞法作用域，也就是外層呼叫者obj：
var obj = {
    birth: 1990,
    getAge: function () {
        var b = this.birth; // 1990
        var fn = () => new Date().getFullYear() - this.birth; // this指向obj物件
        return fn();
    }
};
obj.getAge(); // 25
如果使用箭頭函式，以前的那種hack寫法：
var that = this;
就不再需要了。
由於this在箭頭函式中已經按照詞法作用域綁定了，所以，用call()或者apply()呼叫箭頭函式時，無法對this進行繫結，即傳入的第一個引數被忽略：
var obj = {
    birth: 1990,
    getAge: function (year) {
        var b = this.birth; // 1990
        var fn = (y) => y - this.birth; // this.birth仍是1990
        return fn.call({birth:2000}, year);
    }
};
obj.getAge(2015); // 25