尾调用与尾递归优化

　

〇、是为序

　之前也看到过尾递归及其优化，但在当时并不彻底可以理解，最近几天陆陆续续复习了一下《汇编语言》和《本身动手写操做系统》两本书，对于函数调用背后的栈机制有了更加清晰的理解，回过头来看尾递归就以为容易理解多了。

　　就像阮一峰老师在下文中所写的那样，栈溢出在递归程序编写过程当中是常会出现的错误，但有时把递归程序改写成非递归可能并不是易事，此时考虑一下采用尾递归或者相关优化技术就很是有必要，虽然这篇文章是使用javascript为例写的，但对于C++等也彻底适用，特转载此文以备忘。

 

　　如下转自http://www.ruanyifeng.com/blog/2015/04/tail-call.html

　　尾调用（Tail Call）是函数式编程的一个重要概念，本文介绍它的含义和用法。

1、什么是尾调用？

　　尾调用的概念很是简单，一句话就能说清楚，就是指某个函数的最后一步是调用另外一个函数。

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

　　

上面代码中，函数f的最后一步是调用函数g，这就叫尾调用。

如下两种状况，都不属于尾调用。

// 状况一
function f(x){
  let y = g(x);
  return y;
}

// 状况二
function f(x){
  return g(x) + 1;
}

　　

上面代码中，状况一是调用函数g以后，还有别的操做，因此不属于尾调用，即便语义彻底同样。状况二也属于调用后还有操做，即便写在一行内。

尾调用不必定出如今函数尾部，只要是最后一步操做便可。

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() 的调用记录，只保留 g(3) 的调用记录。

这就叫作"尾调用优化"（Tail call optimization），即只保留内层函数的调用记录。若是全部函数都是尾调用，那么彻底能够作到每次执行时，调用记录只有一项，这将大大节省内存。这就是"尾调用优化"的意义。

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

　　

因而可知，"尾调用优化"对递归操做意义重大，因此一些函数式编程语言将其写入了语言规格。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、参考连接

• 尾调用，from 维基百科
• Tail Calls, Default Arguments, and Excessive Recycling in ES-6, by raganwald
• Proper Tail Calls, from programming in Lua