1 什麼是尾呼叫？

尾呼叫（ Tail Call ）是函數語言程式設計的一個重要概念，本身非常簡單，一句話就能說清楚，就是指某個函式的最後一步是呼叫另一個函式。

function f(x){
    return g(x);
}

上面程式碼中，函式 f 的最後一步是呼叫函式 g ，這就叫尾呼叫。

以下三種情況，都不屬於尾呼叫。

//  情況一
function f(x){
    let y = g(x);
    return y;
}
//  情況二
function f(x){
    return g(x) + 1;
}
//  情況三
function f(x){
    g(x);
}

上面程式碼中，情況一是呼叫函式 g 之後，還有賦值操作，所以不屬於尾呼叫，即使語義完全一樣。情況二也屬於呼叫後還有操作，即使寫在一行內。情況三等同於下面的程式碼。

function f(x){
    g(x);
    return undefined;
}

尾呼叫不一定出現在函式尾部，只要是最後一步操作即可。

function f(x) {
    if (x > 0) {
        return m(x)
    }
    return n(x);
}

上面程式碼中，函式 m 和 n 都屬於尾呼叫，因為它們都是函式 f 的最後一步操作。

2 尾呼叫優化

尾呼叫之所以與其他呼叫不同，就在於它的特殊的呼叫位置。

我們知道，函式呼叫會在記憶體形成一個 “ 呼叫記錄 ” ，又稱 “ 呼叫幀 ” （ call frame ）（也叫執行上下文），儲存呼叫位置和內部變數等資訊。如果在函式 A 的內部呼叫函式 B ，那麼在 A 的呼叫幀上方，還會形成一個 B 的呼叫幀。等到 B 執行結束，將結果返回到 A ， B 的呼叫幀才會消失。如果函式 B 內部還呼叫函式 C ，那就還有一個 C 的呼叫幀，以此類推。所有的呼叫幀，就形成一個 “ 呼叫棧 ” （ call stack ）（也叫執行上下文棧，執行棧）。

尾呼叫由於是函式的最後一步操作，所以不需要保留外層函式的呼叫幀，因為呼叫位置、內部變數等資訊都不會再用到了，只要直接用內層函式的呼叫幀，取代外層函式的呼叫幀就可以了。

function f() {
    let m = 1;
    let n = 2;
    return g(m + n);
}
f();
//  等同於
function f() {
    return g(3);
}
f();
//  等同於
g(3);

上面程式碼中，如果函式 g 不是尾呼叫，函式 f 就需要儲存內部變數 m 和 n 的值、 g 的呼叫位置等資訊。但由於呼叫 g 之後，函式 f 就結束了，所以執行到最後一步，完全可以刪除 f(x) 的呼叫幀，只保留 g(3) 的呼叫幀。

這就叫做 “ 尾呼叫優化 ” （ Tail call optimization ），即只保留內層函式的呼叫幀。如果所有函式都是尾呼叫，那麼完全可以做到每次執行時，呼叫幀只有一項，這將大大節省記憶體。這就是 “ 尾呼叫優化 ” 的意義。

注意，只有不再用到外層函式的內部變數，內層函式的呼叫幀才會取代外層函式的呼叫幀，否則就無法進行 “ 尾呼叫優化 ” 。

function addOne(a){
    var one = 1;
    function inner(b){
        return b + one;
    }
    return inner(a);
}

上面的函式不會進行尾呼叫優化，因為內層函式inner用到了外層函式addOne的內部變數one。

3 尾遞迴

函式呼叫自身，稱為遞迴。如果尾呼叫自身，就稱為尾遞迴。

遞迴非常耗費記憶體，因為需要同時儲存成千上百個呼叫幀，很容易發生 “ 棧溢位 ” 錯誤（ stack overflow ）。但對於尾遞迴來說，由於只存在一個呼叫幀，所以永遠不會發生 “ 棧溢位 ” 錯誤。

function factorial(n) {
    if (n === 1) return 1;
    return n * factorial(n - 1);
}
factorial(5) // 120

上面程式碼是一個階乘函式，計算 n 的階乘，最多需要儲存 n 個呼叫記錄，複雜度 O(n) 。
如果改寫成尾遞迴，只保留一個呼叫記錄，複雜度 O(1) 。

function factorial(n, total) {
    if (n === 1) return total;
    return factorial(n - 1, n * total);
}
factorial(5, 1) // 120

還有一個比較著名的例子，就是計算 fibonacci 數列，也能充分說明尾遞迴優化的重要性
如果是非尾遞迴的 fibonacci 遞迴方法

function Fibonacci (n) {
    if ( n <= 1 ) {return 1};
    return Fibonacci(n - 1) + Fibonacci(n - 2);
}
Fibonacci(10); // 89
// Fibonacci(100)
// Fibonacci(500)
//  堆疊溢位了

如果我們使用尾遞迴優化過的 fibonacci 遞迴演算法

function Fibonacci2 (n , ac1 = 1 , ac2 = 1) {
    if( n <= 1 ) {return ac2};
    return Fibonacci2 (n - 1, ac2, ac1 + ac2);
}
Fibonacci2(100) // 573147844013817200000
Fibonacci2(1000) // 7.0330367711422765e+208
Fibonacci2(10000) // Infinity

由此可見， “ 尾呼叫優化 ” 對遞迴操作意義重大，所以一些函數語言程式設計語言將其寫入了語言規格。 ES6 也是如此，第一次明確規定，所有 ECMAScript 的實現，都必須部署 “ 尾呼叫優化 ” 。這就是說，在 ES6 中，只要使用尾遞迴，就不會發生棧溢位，相對節省記憶體。

4 遞迴函式的改寫

尾遞迴的實現，往往需要改寫遞迴函式，確保最後一步只調用自身。做到這一點的方法，就是把所有用到的內部變數改寫成函式的引數。比如上面的例子，階乘函式 factorial 需要用到一箇中間變數 total ，那就把這個中間變數改寫成函式的引數。這樣做的缺點就是不太直觀，第一眼很難看出來，為什麼計算 5 的階乘，需要傳入兩個引數 5 和 1 ？
兩個方法可以解決這個問題。

方法一是在尾遞迴函式之外，再提供一個正常形式的函式。

function tailFactorial(n, total) {
    if (n === 1) return total;
    return tailFactorial(n - 1, n * total);
}
function factorial(n) {
    return tailFactorial(n, 1);
}
factorial(5) // 120

上面程式碼通過一個正常形式的階乘函式 factorial ，呼叫尾遞迴函式 tailFactorial ，看起來就正常多了。
函數語言程式設計有一個概念，叫做柯里化（ currying ），意思是將多引數的函式轉換成單引數的形式。這裡也可以使用柯里化。

function currying(fn, n) {
    return function (m) {
        return fn.call(this, m, n);
    };
}
function tailFactorial(n, total) {
    if (n === 1) return total;
    return tailFactorial(n - 1, n * total);
}
const factorial = currying(tailFactorial, 1);
factorial(5) // 120

面程式碼通過柯里化，將尾遞迴函式 tailFactorial 變為只接受 1 個引數的 factorial 。
第二種方法就簡單多了，就是採用 ES6 的函式預設值。

function factorial(n, total = 1) {
    if (n === 1) return total;
    return factorial(n - 1, n * total);
}
factorial(5) // 120

上面程式碼中，引數 total 有預設值 1 ，所以呼叫時不用提供這個值。
總結一下，遞迴本質上是一種迴圈操作。純粹的函數語言程式設計語言沒有迴圈操作命令，所有的迴圈都用遞迴實現，這就是為什麼尾遞迴對這些語言極其重要。對於其他支援 “ 尾呼叫優化 ” 的語言（比如 Lua ， ES6 ），只需要知道迴圈可以用遞迴代替，而一旦使用遞迴，就最好使用尾遞迴。

5 嚴格模式

ES6 的尾呼叫優化只在嚴格模式下開啟，正常模式是無效的。
這是因為在正常模式下，函式內部有兩個變數，可以跟蹤函式的呼叫棧。
func.arguments：返回呼叫時函式的引數。
func.caller：返回呼叫當前函式的那個函式。
尾呼叫優化發生時，函式的呼叫棧會改寫，因此上面兩個變數就會失真。嚴格模式禁用這兩個變數，所以尾呼叫模式僅在嚴格模式下生效。

function restricted() {
    "use strict";
    restricted.caller; //  報錯
    restricted.arguments; //  報錯
}
restricted();

6 尾遞迴優化的實現

尾遞迴優化只在嚴格模式下生效，那麼正常模式下，或者那些不支援該功能的環境中，有沒有辦法也使用尾遞迴優化呢？回答是可以的，就是自己實現尾遞迴優化。
它的原理非常簡單。尾遞迴之所以需要優化，原因是呼叫棧太多，造成溢位，那麼只要減少呼叫棧，就不會溢位。怎麼做可以減少呼叫棧呢？就是採用 “ 迴圈 ” 換掉 “ 遞迴 ” 。
下面是一個正常的遞迴函式。

function sum(x, y) {
    if (y > 0) {
        return sum(x + 1, y - 1);
    } else {
        return x;
    }
}
sum(1, 100000)

上面程式碼中，sum是一個遞迴函式，引數x是需要累加的值，引數y控制遞迴次數。一旦指定sum遞迴 100000 次，就會報錯，提示超出呼叫棧的最大次數。
蹦床函式（ trampoline ）可以將遞迴執行轉為迴圈執行。

function trampoline(f) {
    while (f && f instanceof Function) {
        f = f();
    }
    return f;
}

上面就是蹦床函式的一個實現，它接受一個函式f作為引數。只要f執行後返回一個函式，就繼續執行。注意，這裡是返回一個函式，然後執行該函式，而不是函式裡面呼叫函式，這樣就避免了遞迴執行，從而就消除了呼叫棧過大的問題。
然後，要做的就是將原來的遞迴函式，改寫為每一步返回另一個函式。

function sum(x, y) {
    if (y > 0) {
        return sum.bind(null, x + 1, y - 1);
    } else {
        return x;
    }
}

上面程式碼中，sum函式的每次執行，都會返回自身的另一個版本。
現在，使用蹦床函式執行sum，就不會發生呼叫棧溢位。

trampoline(sum(1, 100000))
// 100001
//蹦床函式並不是真正的尾遞迴優化，下面的實現才是。
function tco(f) {
    var value;
    var active = false;
    var accumulated = [];
    return function accumulator() {
        accumulated.push(arguments);
        if (!active) {
            active = true;
            while (accumulated.length) {
                value = f.apply(this, accumulated.shift());
            }
            active = false;
            return value;
        }
    };
}
var sum = tco(function(x, y) {
    if (y > 0) {
        return sum(x + 1, y - 1)
    }else {
        return x
    }
});
sum(1, 100000)
// 100001

上面程式碼中，tco函式是尾遞迴優化的實現，它的奧妙就在於狀態變數active。預設情況下，這個變數是不啟用的。一旦進入尾遞迴優化的過程，這個變數就激活了。然後，每一輪遞迴sum返回的都是undefined，所以就避免了遞迴執行；而accumulated陣列存放每一輪sum執行的引數，總是有值的，這就保證了accumulator函式內部的while迴圈總是會執行。這樣就很巧妙地將 “ 遞迴 ” 改成了 “ 迴圈 ” ，而後一輪的引數會取代前一輪的引數，保證了呼叫棧只有一層。