一、尾调用
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) //89feibonaqi(20) //报错尾递归：
function feibonaqi(n, a1 = 1, a2 = 1) { if (n <= 1) return a2; return feibonaqi(n-1, a2, a1+a2);}feibonaqi(10) //89feibonaqi(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：返回调用以后函数的那个函数。
尾调用优化产生时，函数的调用栈会改写，因而下面两个变量就会失真。严格模式禁用这两个变量，所以尾调用模式仅在严格模式下失效。