尾调用

function foo(data) {    a(data);    return b(data);}

function bar(data) {    if ( a(data) ) {        return b(data);    }    return c(data);}

function foo1(data) {    return a(data) + 1;}

function foo2(data) {    var ret = a(data);    return ret;}

function foo3(data) {    var ret = a(data);    return (ret === 0) ? 1 : ret;}

def recsum(x):  if x == 1:    return x  else:    return x + recsum(x - 1)

调用recsum(5)为例，SICP中描述了相应的栈空间变化：

recsum(5)5 + recsum(4)5 + (4 + recsum(3))5 + (4 + (3 + recsum(2)))5 + (4 + (3 + (2 + recsum(1))))5 + (4 + (3 + (2 + 1)))5 + (4 + (3 + 3))5 + (4 + 6)5 + 1015

可观察，堆栈从左到右，增加到一个峰值后再计算从右到左缩小，这往往是我们不希望的，所以在C语言等语言中设计for, while, goto等特殊结构语句，使用迭代、尾递归，对普通递归进行优化，减少可能对内存的极端消耗。修改以上代码，可以成为尾递归：

def tailrecsum(x, running_total=0):  if x == 0:    return running_total  else:    return tailrecsum(x - 1, running_total + x)

或者使用迭代：

for i in range(6):  sum += i

对比后者尾递归对内存的消耗：

tailrecsum(5, 0) tailrecsum(4, 5) tailrecsum(3, 9)tailrecsum(2, 12) tailrecsum(1, 14) tailrecsum(0, 15) 15

则是线性的。

要方便地实现尾调用优化，一般需借助编译器或运行环境提供的现成的尾递归优化特性，或是依赖所用程序语言能直接支持更底层的指令跳转。

在 Perl 里，程序员可以直接用一种带有函数名称的 “goto” 叙述变体：goto &NAME; 直接使用尾调用。

在程序语言实现中，消除尾递归里的尾调用比消除一般的尾调用容易很多。举例来说，Java 虚拟机（JVM）的实现会消除尾递归里的尾调用（因为重新使用了原来的调用栈），但是不会消除一般的尾调用（因为改变了的调用栈）。Scala 等同样基于 JVM 平台的语言可以有效地实现单个函数的尾递归优化，但是对于多个函数的相互尾递归就无法优化了。

JavaScript则原本不支持尾调用优化，到其第6代语言核心标准“ECMAScript 6”开始规定程序引擎应在严格模式下使用尾调用优化。而且ECMAScript 6限定了尾位置不含闭包的尾调用才能进行优化。

对于直接生成汇编的编译器，尾部调用消除很简单：只要校正栈上的形参之后把 “call” 的机器码换成一个 “jump” 的就行了。从编译器的观点，以下代码

function foo()   return a()

先会被翻译成（这是合法的 x86 汇编）：

foo: call a ret

然后，尾部调用消除指的是将最后两个指令以一个 “jump” 指令替换掉：

foo: jmp a

在 a 函数完成的时候，它会直接返回到 foo 的返回地址，省去了不必要的 ret 指令。

函数调用可能带有参数，因此生成的汇编必须确保被调用函数的函数帧在跳过去之前已设置好。举例来说，若是平台的调用栈除了返回位置以外还有函数参数，编译器需要输出调整调用栈的指令。在这类平台上，考虑代码：

function foo(data1, data2)   a(data1)   return b(data2)

其中 data1、data2 是参数。编译器会把这个代码翻译成以下汇编：

foo:  mov  reg, ; 透过栈指针（sp）取得 data1 并放到暂用暂存器。  push reg            ; 将 data1 放到栈上以便 a 使用。  call a              ; a 使用 data1。  pop                 ; 把 data1 從栈上拿掉。  mov  reg, ; 透过栈指針（sp）取得 data2 並放到暂用暂存器。   push reg            ; 将 data2 放到栈上以便 b 使用。   call b              ; b 使用 data2。  pop                 ; 把 data2 從栈上拿掉。  ret

尾部调用优化会将代码变成：

foo:  mov  reg, ; 透过栈指针（sp）取得 data1 并放到暂用暂存器。  push reg            ; 将 data1 放到栈上以便 a 使用。  call a              ; a 使用 data1。  pop                 ; 把 data1 從栈上拿掉。  mov  reg, ; 透过栈指針（sp）取得 data2 並放到暂用暂存器。    mov  ,reg ; 把 data2 放到 b 预期的位置。  jmp  b              ; b 使用 data2 並返回到调用 foo 的函数。

更改后的代码不管在执行速度或是栈空间的使用上的性能都比较好。

由于很多 Scheme 的编译器使用 C 作为中间目标语言，问题可转化为如何在 C 里在不让栈向上增长的前提下实现尾部递归（假设 C 的编译器不优化尾部调用）。很多实现透过一种叫做弹跳床（英语：Trampoline_(computing)） (trampoline)的设备，也就是一块不断进行函数调用的代码。所有函数代码的加载过程都透过这个弹跳床。当一个函数需要调用另一个函数时，它不是直接调用该函数，而是将该函数的位置、该调用使用的参数等信息传递给弹跳床，让爱插手的弹跳床去代为执行。这样就可以确保 C 的栈不会向上增长并且可以让迭代无限地继续。

用 Groovy、Visual Basic .NET、C# 等等支持高阶函数的语言实现弹跳床是可能的。

通常被用于解释递归的程序是计算阶乘。以下计算阶乘的 Scheme 程序不是尾部递归，而只是一般递归：

(define (factorial n)  (if (= n 1)      1      (* n (factorial (- n 1)))))

因此，如果调用 factorial 时的参数 n 足够大，这一程序会出现堆栈溢出。然而，如果将同一程序写作尾部递归，按 Scheme 的标准将不会出现溢出：

(define (factorial n)  (define (iter product counter)    (if (> counter n)        product        (iter (* counter product)              (+ counter 1))))  (iter 1 1))

在第2个程序中，注意 iter 函数直接返回其递归调用，而没有对其进行运算。因此，这是一个尾部递归，这让直译器或编译器将本来是

  call factorial (3)   call iter (3 1)    call iter (2 3)     call iter (1 6)      call iter (0 6)      return 6     return 6    return 6   return 6  return 6

的运行过程组合成在时间、空间上性能都较好的类型：

  call factorial (3)   call iter (3 1)   将参数变为 (2 3)，跳至 "iter"   将参数变为 (1 6)，跳至 "iter"   将参数变为 (0 6)，跳至 "iter"   return 6  return 6

因为在中间过程中重复使用 iter 的函数帧，这种重组节省了空间。这也代表程序员不需要为了担心栈空间或是堆空间用完。在一般的实现中，尾部递归的型态也比其他型态更快速，不过仅仅是常量倍数的差异（非指数差异）。

很多使用函数语言的程序员会为了使用这个优化将递归的代码写成为尾部递归的形式。这通常需要一个多出来代表 “搜集器” 的形参（上述例子的 product 参数）。在一些语言中的一些函数的实现中（像是过滤一个列的实现等等），如果要使用尾部递归则需要将本来没有副作用的纯函数改写成会更动其他参引的形式。