关注前端小讴，浏览更多原创技术文章

相干代码 →

10.12 递归

• 递归函数 是一个函数通过名称 调用本人

function factorial(num) {if (num <= 1) {return 1} else {return num * factorial(num - 1)
  }
}

• 函数逻辑与函数名是 藕和 的，因而将递归函数赋值给其余变量，并解除原函数名与函数之间的关系后，会报错

let anotherFactorial = factorial // 拜访指针
factorial = null // 切断 factorial 与函数之间的分割
console.log(anotherFactorial(4)) // TypeError: factorial is not a function

• 应用 arguments.callee 解藕（arguments.callee指向 arguments 所在函数的指针）

function factorial2(num) {if (num <= 1) {return 1} else {return num * arguments.callee(num - 1)
  }
}
let anotherFactorial2 = factorial2 // 拜访指针
factorial2 = null // 切断 factorial 与函数之间的分割
console.log(anotherFactorial2(4)) // 24，arguments.callee 指向 anotherFactorial2

• 严格模式 下不能拜访 argumengts.callee（会报错），应用 命名函数表达式 达到目标

let factorial3 = function f(num) {if (num <= 1) {return 1} else {return num * f(num - 1) // 无论赋值给哪个变量，表达式 f 都不会变
  }
}
let anotherFactorial3 = factorial3
factorial3 = null
console.log(anotherFactorial3(4)) // 24

10.13 尾调用优化

• ES6 新增非常适合 尾调用 的内存治理优化 机制，即 内部函数的返回值 是一个 外部函数的返回值

function outerFunction() {return innerFunction() // 尾调用
}

• ES6 优化之前，该例会在内存中如下操作（每多调用一次嵌套函数，就多减少 1 个栈帧）：

  • 执行到 outerFunction 函数体，第 1 个栈帧被推到栈上
  • 执行 outerFunction 函数体到 return 语句，计算返回值要先计算innerFunction
  • 执行到 innerFunction 函数体，第 2 个栈帧被推到栈上
  • 执行 innerFunction 函数体，计算返回值
  • 将返回值传回 outerFunction，而后outerFunction 再返回值
  • 将栈帧弹出栈外

• ES6 优化之后，该例会在内存中如下操作（无论调用多少次嵌套函数，都只有 1 个栈帧）：

  • 执行到 outerFunction 函数体，第 1 个栈帧被推到栈上
  • 执行 outerFunction 函数体到 return 语句，计算返回值要先计算innerFunction
  • 因为 innerFunction 的返回值也是 outerFunction 的返回值，因而 引擎发现能够把第一个栈帧弹出栈外
  • 弹出 outerFunction 的栈帧
  • 执行到 innerFunction 函数体，第 2 个栈帧被推到栈上
  • 执行 innerFunction 函数体，计算返回值
  • 将 innerFunction 的栈帧弹出栈外
• ES6 尾调用优化的 要害：如果函数的逻辑容许基于尾调用将其销毁，引擎就会那么多

10.13.1 尾调用优化的条件

• 需确定内部栈帧真的没必要存在：

  • 外码需在 严格模式 下执行

    • 非严格模式容许应用的 f.arguments 和f.caller都会援用内部函数的栈帧
  • 内部函数的返回值是对尾调用函数的调用
  • 尾调用函数返回后，不须要执行额定的逻辑
  • 尾调用函数不是援用内部函数作用域中自在变量的闭包

;('use strict')

function outerFunction() {innerFunction() // 无优化，尾调用没有返回
}

function outerFunction() {let innerFunctionResult = innerFucntion()
  return innerFunctionResult() // 无优化，尾调用没有间接返回}

function outerFunction() {return innerFunction().toString() // 无优化，尾调用返回后必须转型为字符串（有额定逻辑）}

function outerFunction() {
  let foo = 'bar'
  function innerFunction() {return foo}
  return innerFunction() // 无优化，尾调用是一个闭包}

function outerFunction(a, b) {innerFunction(a + b) // 有优化，栈帧销毁前执行参数计算
}

function outerFunction(a, b) {if (a < b) return a
  innerFunction(a + b) // 有优化，初始返回值不波及栈帧
}

function outerFunction(condition) {return condition ? innerFunctionA() : innerFunctionB() // 有优化，2 个外部函数都在尾部}

10.13.1 尾调用优化的代码

• 尾调用优化在 递归场景 下的成果最显著，因为递归代码最容易在栈内存中迅速产生大量栈帧
• 以 斐波那契数列 为例，应用尾调用优化减小浏览器的累赘：

function fib(n) {if (n < 2) {return n}
  return fib(n - 1) + fib(n - 2) // 返回语句有相加操作，不合乎优化条件
}

// 应用 2 个嵌套的函数重构斐波那契数列
;('use strict')

function fib(n) {return fibImp1(0, 1, n) // 以 0 为初始值，1 作为第 1 个数字，n 为第几个数字
}
function fibImp1(a, b, n) {if (n === 0) return a
  return fibImp1(b, a + b, n - 1) // 内部函数的返回值是外部函数的返回值，合乎优化条件
}

总结 & 问点

• 什么是递归函数？写一段代码示意阶乘，要求解耦函数逻辑和函数名
• 严格模式下，写一段代码示意阶乘，要求函数名能够赋给任意变量
• 什么是尾调用优化？其是如何优化内存治理的？尾调用优化的条件是什么？
• 写一段代码，应用尾递归优化计算斐波那契数列