什麼是尾呼叫？

尾呼叫（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的最後一步操作。

嚴格模式

ES6 的尾呼叫優化只在嚴格模式下開啟，正常模式是無效的。
這是因為在正常模式下，函式內部有兩個變數，可以跟蹤函式的呼叫棧。

* func.arguments：返回呼叫時函式的引數。
* func.caller：返回呼叫當前函式的那個函式。
 

尾呼叫優化發生時，函式的呼叫棧會改寫，因此上面兩個變數就會失真。嚴格模式禁用這兩個變數，所以尾呼叫模式僅在嚴格模式下生效。

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

尾呼叫優化

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

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

話不多說，舉個例子

function foo () { console.log(111); }
function bar () { foo(); }
function baz () { bar(); }

baz();

呼叫棧情況參考下圖：

造成這種結果是因為每個函式在呼叫另一個函式的時候，並沒有return該呼叫，所以js引擎會認為你還沒有執行完，會保留你的呼叫幀。

baz()裡面呼叫了bar()函式，並沒有return該呼叫，所以在呼叫棧中保持自己的呼叫幀，同時bar()函式的呼叫幀在呼叫棧中生成，同理，bar()函式又呼叫了foo()函式，最後執行到foo()函式的時候，沒有再呼叫其他函式，這裡沒有顯示宣告return，所以這裡預設return undefined。

foo()執行完了，銷燬呼叫棧中自己的記錄，依次銷燬bar()和baz()的呼叫幀，最後完成整個流程。

如果對上面的例子做如下修改：

function foo () { console.log(111); }
function bar () { return foo(); }
function baz () { return bar(); }

baz();

如果尾呼叫優化生效，流程圖就會變成這樣：

我們可以很清楚的看到，尾呼叫由於是函式的最後一步操作，所以不需要保留外層函式的呼叫記錄，只要直接用內層函式的呼叫記錄取代外層函式的呼叫記錄就可以了，呼叫棧中始終只保持了一條呼叫幀。

這就叫做尾呼叫優化（Tail call optimization），即只保留內層函式的呼叫幀。如果所有的函式都是尾呼叫的話，呼叫位置、內部變數等資訊都不會再用到了，那麼在呼叫棧中的呼叫幀始終只有一條，這樣會節省很大一部分的記憶體，這也是尾呼叫優化的意義。

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)的呼叫幀。

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

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

上面的函式不會進行尾呼叫優化，因為內層函式inner用到了外層函式addOne的內部變數one。
注意，目前只有 Safari瀏覽器支援尾呼叫優化，Chrome 和 Firefox 都不支援。

尾遞迴優化

函式呼叫自身，稱為遞迴。如果尾呼叫自身，就稱為尾遞迴。
遞迴非常耗費記憶體，因為需要同時儲存成千上百個呼叫幀，很容易發生“棧溢位”錯誤（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 中只要使用尾遞迴，就不會發生棧溢位（或者層層遞迴造成的超時），相對節省記憶體。

遞迴函式的改寫

尾遞迴的實現，往往需要改寫遞迴函式，確保最後一步只調用自身。做到這一點的方法，就是把所有用到的內部變數改寫成函式的引數。比如上面的例子，階乘函式 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變為只接受一個引數的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），只需要知道迴圈可以用遞迴代替，而一旦使用遞迴，就最好使用尾遞迴。

廣州品牌設計公司https://www.houdianzi.com PPT模板下載大全https://redbox.wode007.com

尾遞迴優化的實現

尾遞迴優化只在嚴格模式下生效，那麼正常模式下，或者那些不支援該功能的環境中，有沒有辦法也使用尾遞迴優化呢？回答是可以的，就是自己實現尾遞迴優化。

它的原理非常簡單。尾遞迴之所以需要優化，原因是呼叫棧太多，造成溢位，那麼只要減少呼叫棧，就不會溢位。怎麼做可以減少呼叫棧呢？就是採用“迴圈”換掉“遞迴”。

下面是一個正常的遞迴函式。

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

sum(1, 100000)
// Uncaught RangeError: Maximum call stack size exceeded(…)

上面程式碼中，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迴圈總是會執行。

這樣就很巧妙地將“遞迴”改成了“迴圈”，而後一輪的引數會取代前一輪的引數，保證了呼叫棧只有一層。