如何在 JavaScript 中实现一个简单的递归函数，例如计算阶乘？
大白话如何在 JavaScript 中实现一个简单的递归函数，例如计算阶乘
什么是递归函数？
递归函数是在其定义中调用自身的函数。简单来说，就是一个函数在执行过程中又去调用了它自己。就好比你在一个房间里，这个房间有一面镜子，镜子里又反射出了这个房间，这个反射的过程就有点像递归。
以计算阶乘为例
阶乘是一个数学概念，一个正整数的阶乘是所有小于及等于该数的正整数的积，并且 0 的阶乘为 1。比如，5 的阶乘写作 5!，计算方式是 5 * 4 * 3 * 2 * 1 = 120。
下面是用 JavaScript 实现计算阶乘的递归函数：
// 定义一个名为 factorial 的函数，它接收一个参数 num 表示要计算阶乘的数
function factorial(num) {
// 这是递归的终止条件，如果 num 等于 0 或者 1，直接返回 1
// 因为 0 的阶乘和 1 的阶乘都是 1
if (num === 0 || num === 1) {
return 1;
}
// 如果 num 不等于 0 或者 1，就进行递归调用
// 这里是让 num 乘以 factorial(num - 1)，也就是让 num 乘以比它小 1 的数的阶乘
// 比如计算 5 的阶乘，就是 5 乘以 4 的阶乘，而 4 的阶乘又会继续递归计算
return num * factorial(num - 1);
}
// 调用 factorial 函数计算 5 的阶乘，并将结果存储在 result 变量中
let result = factorial(5);
// 打印结果
console.log(result);
代码执行过程分析
- 当你调用
factorial(5)时，函数会先判断5是不是等于0或者1，显然不是，所以会执行return 5 * factorial(4)。 - 接着，函数会去计算
factorial(4)，同样判断4不等于0或者1，于是执行return 4 * factorial(3)。 - 以此类推，直到调用
factorial(1)，这时满足终止条件num === 1，函数返回1。 - 然后，之前的递归调用会依次返回结果，就像一层一层剥开的洋葱，从里到外依次返回计算结果，最终得到
5 * 4 * 3 * 2 * 1 = 120。
总结
递归函数的关键在于要有一个终止条件，不然函数会一直调用自己，陷入无限循环，最终导致栈溢出错误。就像你在镜子房间里，如果没有边界，反射会一直进行下去。同时，递归函数要能把一个大问题分解成一个或多个相似的小问题，通过不断调用自身来解决这些小问题，最终得到大问题的答案。
除了计算阶乘，还有哪些常见的数学问题可以用递归函数解决？
递归函数凭借自身将复杂问题拆解为相似子问题的能力，在诸多数学问题的解决上表现出色。以下为你详细介绍除阶乘计算外，常见的可用递归函数解决的数学问题：
斐波那契数列
斐波那契数列是一个经典的数列，它的特点是从第三项开始，每一项都等于前两项之和，即F(n) = F(n-1) + F(n-2)，其中F(0) = 0，F(1) = 1。下面是使用 JavaScript 实现的代码：
function fibonacci(n) {
// 递归终止条件：当 n 为 0 时，返回 0
if (n === 0) {
return 0;
}
// 递归终止条件：当 n 为 1 时，返回 1
if (n === 1) {
return 1;
}
// 递归调用：返回前两项之和
return fibonacci(n - 1) + fibonacci(n - 2);
}
// 调用函数计算斐波那契数列的第 6 项
let result = fibonacci(6);
console.log(result);
最大公约数
最大公约数是指两个或多个整数共有约数中最大的一个。可以使用欧几里得算法（辗转相除法）来递归地计算两个数的最大公约数，原理是gcd(a, b) = gcd(b, a % b)，当b为 0 时，a就是最大公约数。以下是实现代码：
function gcd(a, b) {
// 递归终止条件：当 b 为 0 时，返回 a
if (b === 0) {
return a;
}
// 递归调用：继续计算 b 和 a % b 的最大公约数
return gcd(b, a % b);
}
// 调用函数计算 24 和 18 的最大公约数
let result = gcd(24, 18);
console.log(result);
幂运算
幂运算即计算一个数的指定次幂，例如a^n。可以使用递归的方式来实现，当n为 0 时，结果为 1；当n为偶数时，a^n = (a^(n/2))^2；当n为奇数时，a^n = a * a^(n - 1)。代码如下：
function power(a, n) {
// 递归终止条件：当 n 为 0 时，返回 1
if (n === 0) {
return 1;
}
// 如果 n 为偶数
if (n % 2 === 0) {
let temp = power(a, n / 2);
return temp * temp;
}
// 如果 n 为奇数
return a * power(a, n - 1);
}
// 调用函数计算 2 的 5 次幂
let result = power(2, 5);
console.log(result);
这些递归函数的实现都有一个共同点，就是先确定递归的终止条件，然后将大问题逐步分解为相似的小问题，通过不断调用自身来解决这些小问题，最终得到大问题的答案。
递归算法的优缺点有哪些？
JavaScript 中的递归算法有其独特的优势和不足，以下为你详细阐述：
优点
1. 代码简洁易读
对于具有递归性质的问题，递归算法能让代码结构更加简洁清晰，和数学定义紧密贴合，便于理解。比如计算阶乘，阶乘的数学定义是n! = n * (n - 1)!（n > 0），0! = 1 ，用 JavaScript 递归实现的代码如下：
function factorial(n) {
if (n === 0) {
return 1;
}
return n * factorial(n - 1);
}
代码直接体现了阶乘的数学定义，易于理解和编写。
2. 实现复杂逻辑方便
在处理复杂的嵌套结构数据时，递归算法能轻松应对。例如遍历树形结构数据，像 HTML 文档对象模型（DOM），递归可以很自然地遍历每个节点。以下是一个简单的 DOM 节点遍历示例：
function traverseDOM(node) {
console.log(node.nodeName);
const children = node.childNodes;
for (let i = 0; i < children.length; i++) {
traverseDOM(children[i]);
}
}
// 假设 root 是 DOM 树的根节点
// traverseDOM(root);
3. 契合分治思想
分治算法的核心是将大问题分解成小问题，递归在实现分治思想时非常合适。以快速排序算法为例，它把数组分成两部分，分别对这两部分进行排序，然后合并结果。以下是简单的快速排序递归实现：
function quickSort(arr) {
if (arr.length <= 1) {
return arr;
}
const pivot = arr[0];
const left = [];
const right = [];
for (let i = 1; i < arr.length; i++) {
if (arr[i] < pivot) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
return [...quickSort(left), pivot, ...quickSort(right)];
}
缺点
1. 性能欠佳
递归调用会带来额外的开销，每次调用函数都要在调用栈上分配新的内存空间来保存局部变量和返回地址等信息。当递归深度很大时，会消耗大量内存，甚至可能导致栈溢出错误。例如，计算斐波那契数列时，递归实现会重复计算很多子问题：
function fibonacci(n) {
if (n <= 1) {
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
计算fibonacci(50)会非常慢，因为有大量的重复计算。
2. 调试难度大
由于递归函数会多次调用自身，函数的执行流程复杂，调试时难以跟踪每一次递归调用的状态和变量值。当出现错误时，很难定位问题出在哪一次递归调用中。
3. 可读性局限
虽然递归代码在处理某些问题时简洁易懂，但如果递归逻辑复杂，或者递归深度较大，代码的可读性会变差。对于不熟悉递归思想的开发者来说，理解和维护代码会有一定难度。
在使用 JavaScript 递归算法时，需要综合考虑问题的特点和需求，权衡其优缺点后再做选择。