共计 2829 个字符，预计需要花费 8 分钟才能阅读完成。
一、尾调用
1、概念
在函数的最初一个调用其余函数，则是尾调用
function a(x) {return b(x)
}2、辨别尾调用
// 这两种状况不属于尾调用
// return 语句不能蕴含表达式
function a(x) {return b(x) + 1
}
function a(x) {let y = b(x)
return y
}
function a(x) {b(x)
// return undefined
}
// 尾调用也不肯定是在函数尾部，次要是函数最初一步操作就可
function a(x) {if (x > 1) {return m(x)
}
return n(x)
}
3、尾调用优化
函数调用会有一个“调用记录”，也称为 “调用帧”，用于保留调用地位和外部变量等信息。
如函数 A 里调用了函数 B，则 A 的调用记录上会记录 B 的调用记录，期待 B 执行结束后将后果给 A，B 才会隐没。如果函数 B 调用了函数 C，也会生成一个 C 的调用记录，以此类推，所有的记录就造成了“调用栈”。
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），即只保留内层函数的调用记录。如果所有函数都是尾调用，那么齐全能够做到每次执行时，调用记录只有一项，这将大大节俭内存。这就是 ” 尾调用优化 ” 的意义。
留神，目前只有 Safari 浏览器反对尾调用优化，Chrome 和 Firefox 都不反对
二、尾递归
1、一般递归
概念：函数外部调用本身
解决的问题：
① 数据的定义是按递归进行的（阶乘）
② 问题的解法按递归实现（回溯）
③ 数据的构造依照递归定义的（树形构造、二叉树）
毛病：运行效率低、容易造成栈溢出
2、尾递归
概念：尾调用本身，就称为尾递归
递归很耗内存，每次调用都会保留所有的调用记录，容易产生栈溢出谬误。但对于尾调用来说
每次都只存在一个调用记录，就不会产生栈溢出，绝对节俭内存，优化了性能。
（1）实现阶乘
递归实现：
function factorial(n) {if (n === 1) return 1;
return n * factorial(n - 1);
}
factorial(5) // 120
调用模式：factorial(5)
5 * factorial(4)
5 * (4 * factorial(3))
...
// 计算阶乘的时候，须要保留 n 个调用记录，复杂度为 O（n）// 执行多层时会呈现栈溢出尾调用递归实现：
function factorial(n, total) {if (n === 1) return total;
return factorial(n-1, n*total);
}
factorial(5, 1) // 120
调用模式：factorial(5, 1)
factorial(4, 5)
factorial(3, 20)
...
// 尾递归则保留一个记录，复杂度为 O（1）执行阶乘函数 factorial(5, 1)时，当调用栈次数过多，调用堆栈会始终增长，直到达到限度：浏览器硬编码堆栈大小或内存耗尽。会产生 超出最大调用堆栈大小“Maximum call stack size exceeded”，
还可通过斐波那契数列，能够体现到尾递归的重要性
（2）斐波那契数列
一般递归：
function feibonaqi(n) {if (n <= 1) return 1;
return feibonaqi(n-1) + feibonaqi(n-2);
}
feibonaqi(10) //89
feibonaqi(20) // 报错
尾递归：
function feibonaqi(n, a1 = 1, a2 = 1) {if (n <= 1) return a2;
return feibonaqi(n-1, a2, a1+a2);
}
feibonaqi(10) //89
feibonaqi(20) // 109463、函数递归的改写
尾递归的实现，须要改写递归函数，确保是函数最初一步调用本身。须要把用到的外部变量变成函数的参数。
下面例子中，阶乘函数 factorial 应用了一个两头变量 total，在进行阶乘时将 total 作为函数的参数。在初始时，传入了 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函数式编程有一个办法 --“函数式柯里化”，将多参函数转成单参函数
尾递归之所以须要优化，起因是调用栈太多，造成溢出，那么只有缩小调用栈，就不会溢出。
办法二：
应用 ES6 函数默认值
function tailFactorial(n, total = 1) {if (n === 1) return total;
return tailFactorial(n - 1, n * total);
}
factorial(5) // 120三、函数柯里化
函数柯里化就是把一个多参函数转成单参函数
// 柯里化前 - 一般相加函数
function sum(x, y) {return x + y;}
factorial(2，3) // 5
// 柯里化
function sum(x) {return function(y) {return x + y;}
}
// 箭头函数
const add = a => b => a + b;
sun(2)(3)
// const f = sum(1)
// f(2)
尾递归阶乘函数应用柯里化，将多参转成单参函数
function currying(fn, n) {return function (m) {return fn.call(this, m, n);// 绑定 this
};
}
function tailFactorial(n, total) {if (n === 1) return total;
return tailFactorial(n - 1, n * total);
}
const factorial = currying(tailFactorial, 1);
factorial(5) // 120四、严格模式
ES6 的尾调用优化只在严格模式下开启，失常模式是有效的。
这是因为在失常模式下，函数外部有两个变量，能够跟踪函数的调用栈。
arguments：返回调用时函数的参数。func.caller：返回调用以后函数的那个函数。
尾调用优化产生时，函数的调用栈会改写，因而下面两个变量就会失真。严格模式禁用这两个变量，所以尾调用模式仅在严格模式下失效。
