Javascript 我觉得这个递归函数就像一个'；for loop？'；

有人能解释一下这个递归函数是如何产生5*4*3*2*1得到120的吗

var factorial = function(n){
   if (n === 0)
       return 1;
   else
       return n * factorial(n - 1); 
};

factorial(5); // spits out 120

如果我们在示例中使用5 like，那么一旦使用else语句就不会了

return n * factorial(n - 1);

---

转换为“返回5乘以阶乘函数（5-1）；5次…

这个函数说：如果你想计算阶乘（5），那真的只是

5 * factorial(4)

如果你想计算阶乘（4），那实际上就是4*阶乘（3）

关于阶乘（3）的问题是它实际上只是3*阶乘（2）

等等。但是，当您转到阶乘（0）时，函数最终停止（因为n==0时的

情况）并返回1，而没有任何进一步的递归。所以你得到了

5 * 4 * 3 * 2 * 1

returnn*factorial（n-1）
翻译为（在第一次运行时），“return（5*4！）”。它没有做任何事情5次

我觉得这个递归函数就像一个“for循环”是不是错了

不，递归和循环有很多共同点。尤其重要的是，它们都有终止条件。：-）在这种情况下，终止条件是
n===0

理解这一点的最佳方法是在调试器中单步执行代码。你的浏览器有一个，所以你可以把代码放在一个页面中，然后加载并浏览

要开始，请执行以下操作：

您可以调用
阶乘（5）
。由于
n
不是
==0
，
factorial
用
n-1
调用自身（
4
）

现在我们已经递归了一个级别，我们正在运行
factorial（4）
（对
factorial（5）
的调用仍然没有返回，它正在等待我们）。因为
n
不是
==0
，所以我们调用
阶乘（3）
，等待它返回

…冲洗，重复，直到调用
factorial（0）
。由于
n===0
为真（此时，有五个对
factorial
的调用未完成且累加），
factorial（0）
返回
1
，我们可以开始展开累加调用

现在，
factorial（1）
可以通过将它从
factorial（0）
得到的结果乘以它的
n
（
1
）副本并返回它来完成

…这让
阶乘（2）
完成并将其乘以
2

…冲洗重复

或者用另一种方式显示嵌套（递归）：

阶乘（5）
返回5*阶乘（4）
返回4*阶乘（3）
返回3*阶乘（2）
返回2*阶乘（1）
返回1*阶乘（0）
返回1
因为你不能得到足够的图表（或者至少I不能）：

阶乘（5）阶乘（4）阶乘（3）阶乘（2）阶乘（1）阶乘（0）
电话---------------->
电话---------------->
电话---------------->
电话---------------->
电话---------------->
n是0，所以
返回1
|
返回1*1的
n
更改：

5 * factorial(5-1) = 5 * 4 * factorial(4-1) = 5 * 4 * 3 * factorial(3-1) = 5 * 4 * 3 * 2 * factorial(1-1) = 5 * 4 * 3 * 2 * 1

此外，为了使此函数更好，您可以在
n
等于
1
时停止它，因为1的阶乘是1：

var factorial = function(n){
   if (n === 1 || n === 0)
       return 1;
   else
       return n * factorial(n - 1); 
};

如果我们在示例中使用5 like，那么一旦使用else语句就不会了

return n * factorial(n - 1);

返回n*阶乘（n-1）

转换为“返回5乘以阶乘函数（5-1）；5次

否，它将转换为“返回n乘以阶乘函数（n-1）”（5次，因为n从5开始，递减并进入else子句，直到达到0）

第一次输入函数时，n等于5
if子句检查n是否等于0。它不是，所以它是：
else条款。转换为“返回5乘以阶乘函数（你在其中）（5-1）
当您输入阶乘函数时，n现在是4
重复所有这些步骤，直到n等于0。if子句将为true，函数将返回1

因此，从阶乘（0）返回1。阶乘（1）返回1*Factorial（0），因此1*1=1

阶乘（2）返回2*阶乘（1），因此2*1=2

阶乘（3）返回3*阶乘（2），因此3*2=6

阶乘（4）返回4*阶乘（3），因此4*6=24

Factorial（5）返回5*Factorial（4），因此5*24=120。
尝试在调试器中单步执行它。不清楚您在问什么。你是在问递归是如何工作的吗？你最好看看维基百科或教科书，而不是这个网站。如果你尝试
factorial（-1）
，你可能会更好地理解这个循环。我意识到我的答案从来没有真正回答过你标题中的问题，所以我对它进行了更新。我喜欢嵌套，它确实让我明白了这一点。你有没有找到另一个答案？
factorial(5)    factorial(4)    factorial(3)    factorial(2)    factorial(1)    factorial(0)
    calls ---------->
                    calls ---------->
                                    calls ---------->
                                                    calls ---------->
                                                                    calls ----------->
                                                                                     n is 0, so
                                                                                     returns 1
                                                                                             |
                                                                    returns 1 * 1<-----------+
                                                                            = 1
                                                                              |
                                                    returns 2 * 1<------------+
                                                            = 2
                                                              |
                                    returns 3 * 2<------------+
                                            = 6
                                              |
                    returns 4 * 6<------------+
                            = 24
                              |
    returns 5 * 24<-----------+
            = 120

Result: 120
5 * factorial(5-1) = 5 * 4 * factorial(4-1) = 5 * 4 * 3 * factorial(3-1) = 5 * 4 * 3 * 2 * factorial(1-1) = 5 * 4 * 3 * 2 * 1

var factorial = function(n){
   if (n === 1 || n === 0)
       return 1;
   else
       return n * factorial(n - 1); 
};