我认为这个非常简单的方法可以帮助你理解递归。该方法将调用自身，直到某个条件为真，然后返回:

function writeNumbers( aNumber ){
 write(aNumber);
 if( aNumber > 0 ){
  writeNumbers( aNumber - 1 );
 }
 else{
  return;
 }
}

这个函数将输出从你输入的第一个数字到0的所有数字。因此:

writeNumbers( 10 );
//This wil write: 10 9 8 7 6 5 4 3 2 1 0
//and then stop because aNumber is no longer larger then 0

基本上发生的情况是writeNumbers(10)将写入10，然后调用writeNumbers(9)，后者将写入9，然后调用writeNumber(8)等。直到writeNumbers(1)写入1，然后调用writeNumbers(0)，这将写入0 butt将不会调用writeNumbers(-1);

这段代码本质上与以下代码相同:

for(i=10; i>0; i--){
 write(i);
}

你可能会问为什么要用递归，如果for循环本质上是一样的。当你需要嵌套for循环但不知道它们嵌套的深度时，你通常会使用递归。例如，当从嵌套数组中打印项目时:

var nestedArray = Array('Im a string', 
                        Array('Im a string nested in an array', 'me too!'),
                        'Im a string again',
                        Array('More nesting!',
                              Array('nested even more!')
                              ),
                        'Im the last string');
function printArrayItems( stringOrArray ){
 if(typeof stringOrArray === 'Array'){
   for(i=0; i<stringOrArray.length; i++){ 
     printArrayItems( stringOrArray[i] );
   }
 }
 else{
   write( stringOrArray );
 }
}

printArrayItems( stringOrArray );
//this will write:
//'Im a string' 'Im a string nested in an array' 'me too' 'Im a string again'
//'More nesting' 'Nested even more' 'Im the last string'

这个函数可以接受一个可以嵌套到100层的数组，而你写一个for循环就需要你嵌套它100次:

for(i=0; i<nestedArray.length; i++){
 if(typeof nestedArray[i] == 'Array'){
  for(a=0; i<nestedArray[i].length; a++){
   if(typeof nestedArray[i][a] == 'Array'){
    for(b=0; b<nestedArray[i][a].length; b++){
     //This would be enough for the nestedAaray we have now, but you would have
     //to nest the for loops even more if you would nest the array another level
     write( nestedArray[i][a][b] );
    }//end for b
   }//endif typeod nestedArray[i][a] == 'Array'
   else{ write( nestedArray[i][a] ); }
  }//end for a
 }//endif typeod nestedArray[i] == 'Array'
 else{ write( nestedArray[i] ); }
}//end for i

如你所见，递归方法要好得多。

你的大脑爆炸是因为它进入了无限递归。这是初学者常犯的错误。

信不信由你，你已经理解了递归，你只是被一个常见的，但错误的函数比喻拖了下来:一个小盒子，里面有东西进进出出。

而不是考虑一个任务或过程，比如“在网上找到更多关于递归的知识”。这是递归的，没有问题。要完成这个任务，你可以:

a) Read a Google's result page for "recursion"
b) Once you've read it, follow the first link on it and...
a.1)Read that new page about recursion 
b.1)Once you've read it, follow the first link on it and...
a.2)Read that new page about recursion 
b.2)Once you've read it, follow the first link on it and...

如您所见，您已经做了很长一段时间的递归工作，没有出现任何问题。

你会坚持做这个任务多久?永远，直到你的大脑爆炸?当然不是，只要你相信你已经完成了任务，你就会停在一个给定的点上。

当要求你“在网上找到更多关于递归的知识”时，没有必要指定这一点，因为你是一个人，你可以自己推断。

计算机无法推断任何东西，所以你必须包含一个明确的结尾:“在网上找到更多关于递归的知识，直到你理解它或你阅读了最多10页”。

您还推断应该从谷歌的结果页面开始进行“递归”，这也是计算机无法做到的。递归任务的完整描述还必须包括一个显式的起点:

“在网上找到更多关于递归的知识，直到你理解它，或者你已经阅读了最多10页，并从www.google.com/search?q=recursion开始”

要想全面了解，我建议你试试下面这些书:

普通Lisp:符号计算的简单介绍。这是对递归最可爱的非数学解释。 小阴谋家。

要理解递归，你只需要看看洗发水瓶上的标签:

function repeat()
{
   rinse();
   lather();
   repeat();
}

这样做的问题是没有终止条件，递归将无限重复，或者直到洗发水或热水用完为止(外部终止条件，类似于吹你的堆栈)。

这与其说是一个问题，不如说是一个抱怨。关于递归你有更具体的问题吗?就像乘法一样，人们不会写很多关于它的东西。

说到乘法，想想这个。

问题:

* b是什么?

答:

如果b = 1，就是a。 否则就是a+a*(b-1)

* (b - 1)是什么?请参考上面的问题来解决这个问题。

子函数隐式地使用递归，例如:

去迪士尼乐园自驾游

我们到了吗?(没有) 我们到了吗?(很快) 我们到了吗?(快了……) 我们到了吗? 我们到了吗?(!!!!!)

这时孩子就睡着了……

这个倒数函数是一个简单的例子:

倒计时()函数 ｛ 返回(参数[0]> 0 ? （ Console.log(参数[0])，倒计时(参数[0]- 1)): “完成” ）; ｝ 倒计时(10);

霍夫施塔特定律也适用于软件项目。

The essence of human language is, according to Chomsky, the ability of finite brains to produce what he considers to be infinite grammars. By this he means not only that there is no upper limit on what we can say, but that there is no upper limit on the number of sentences our language has, there's no upper limit on the size of any particular sentence. Chomsky has claimed that the fundamental tool that underlies all of this creativity of human language is recursion: the ability for one phrase to reoccur inside another phrase of the same type. If I say "John's brother's house", I have a noun, "house", which occurs in a noun phrase, "brother's house", and that noun phrase occurs in another noun phrase, "John's brother's house". This makes a lot of sense, and it's an interesting property of human language.

参考文献

递归与人类思想

当使用递归解时，我总是尝试:

首先建立基本情况，即。 当n = 1的阶乘 试着想出一个一般的规则 对于其他情况

还有不同类型的递归解，分而治之的方法对分形和其他方法很有用。

如果你能先解决一些简单的问题，只是为了掌握窍门，这也会有帮助。一些例子是求解阶乘和生成第n个斐波那契数。

作为参考，我强烈推荐Robert Sedgewick的算法。

希望这能有所帮助。祝你好运。