岩石剪刀的递归解法

如果您查看函数findOutCome:

function findOutCome(roundsLeft, result){
    // when you cover all the rounds
    // push to the outcomes
    if (roundsLeft === 0) {
        outcomes.push(result);
        return;
    }
    plays.forEach(function(play){
        //result.push(play);
        //concat returns the entire array
        findOutCome(roundsLeft-1, result.concat(play));
    });
}

你可能会注意到：

if (roundsLeft === 0) {
    outcomes.push(result);
    return;
}

意味着当CCD_ 67到达CCD_。

现在让我们看看plays.forEach:

plays.forEach(function(play){
    //result.push(play);
    //concat returns the entire array
    findOutCome(roundsLeft-1, result.concat(play));
});

其中，对于plays中的每个选项(rock、paper、scissors(，当前计算的结果数组从该选项开始，然后将结果相加：

findOutCome(roundsLeft-1, result.concat(play))

这意味着我们在回顾CCD_ 74时少了一轮。

所以说3最初是传入的：

1) `3 === 0` is `false` so we move on.
2) `plays.forEach` says take each option in `plays` (added to `result` which starts off empty) and pass it in to `findOutCome` with one round less. We pass in `Rock` as `result` and `2` as roundsLeft`:
    A) `2 === 0` is `false` so we move on.
    B) `plays.forEach` says do same as #2. We pass in [`Rock`, `Rock`] as `result` with `1` as `roundsLeft`.
        I) `1 === 0` is `false` so we move on.
        II) `plays.forEach says do same as #B. We pass in [`Rock`, `Rock`, `Rock`] as `result` with `0` as `roundsLeft`.
            Z) `0 === 0` is `true` so this time we add the `result` array we just got to the `outcomes` array.
    Now wait a second, we left off going through each `plays` in #B.  We need to repeat #I, #II, and #Z with the next option (after `rock`) in `plays`. Let's use `paper`. The result should be another array of ['rock', 'rock', `paper`] being pushed to `outcomes`. 

使用最后一个选项scissors(带有步骤#I、#II和#III(应将[rock、rock、scissors]数组添加到outcomes。

等等，我们也在做整个过程的中间，roundsLeft就是2。我们只是为rock做的。让我们对第二个选项paper重复#A和#B。然后在1处重复roundsLeft，其中plays.forEach在[rock，paper处添加所有可能性#I、#II和#Z。这将向outcomes添加另外三个阵列：

[`rock`, `paper`, `rock`]
[`rock`, `paper`, `paper`]
[`rock`, `paper`, `scissors`]

然后我们可以运行第三个选项，其中roundsLeft是2，并向outcomes添加另外三个阵列：

[`rock`, `scissors`, `rock`]
[`rock`, `scissors`, `paper`]
[`rock`, `scissors`, `scissors`]

现在，等待我们处理每个plays并将9可能的数组添加到outcomes。我们从[rock开始。让我们在[paper处添加另一个9，在[scissors.处添加另个9

这为我们提供了我们正在寻找的27可能的组合。

随着roundsLeft开始变得越来越大，我们运行这一切的层就越大，这使我们能够处理所有这些增长的可能性。

要理解递归，必须了解函数范围。为了让事情变得足够简单以便理解，假设定义功能块(主体(的开始和结束的花括号表示其范围，并且该范围可以用一个框来说明。只需想象一个盒子。现在，每当一个函数被声明时，它都以box的形式出现
函数可以使用外部代码或内部代码(递归(调用。因此，如果您在函数本身(或另一个函数(中调用一个函数，该函数将作为位于父框中的子框出现。您可以将参数传递给函数，但参数只知道它传递给它的值。因此，应用于参数的任何更改都不应影响与参数同名的外部变量。话虽如此，让我们回到你的问题，试着用我们的盒子类比来解释结果。

对于以下内容，我们将使用不同颜色的框(红、绿、黄、白(。请记住，这些框说明了各种作用域。"rock"是"r"，"paper"是"p"，"剪刀"是"s"。

在第一次调用"findOutcome"时，会创建一个RED框，其中包含参数roundleft=3。结果=[]。

//RED BOX : roundleft = 3, result =[]
//----for each rock, paper, scissor
//start with rock (r)  -- note : 3 , r means "roundleft, rock"
3 , r  => internal call to findOutcome() creates a GREEN BOX, 
          so that GREEN BOX is inside the RED one,
          with decremented roundleft value 2.
          Keep in mind that parameter only knows about its value
 //GREEN BOX : roundleft = 2, result =[r]
 //-----for each r p s,
 //starts with rock, 
 2 , r  => internal call to findOutcome() creates a YELLOW BOX,
           inside the GREEN BOX which is inside the RED BOX
           with decremented roundleft value 1.
  //YELLOW BOX : roundleft 1, result =[r, r]
  //----- for each r p s, 
  //starts with rock, roundleft =1, result =[r, r]
  1, r  => internal call to findOutcome() creates a WHITE BOX
           with decremented roundleft value 0.
           at this point RED > GREEN > YELLOW > WHITE
    //WHITE BOX: round = 0, result =[r, r, r]
    roundsLeft = 0 => push result to outcomes. 
                      return means exit WHITE BOX. 
                      we are now (back) inside YELLOW BOX 
                      where roundl= 1, res=[r, r] 
                      is there another element to go through? YES : "paper"
  //follow with paper, roundleft =1, result =[r, r]
  1,  paper(p) // internal call creates a WHITE BOX
    //WHITE BOX: round 0, result =[r, r, p]
    0 => push result to outcomes.
         exit white box, back to YELLOW BOX
         is there another element to go through? YES : "scissor"
  //follow with scissor. roundleft =1, result =[r, r]
  1, scissor // internal call creates a WHITE BOX
    //WHITE BOX: roundl 0, result =[r, r, s]
    0 => push result to outcomes.
         exit WHITE BOX, back to YELLOW BOX
         is there another element to go through? NO =>exit YELLOW BOX
         back inside GREEN BOX where roundl 2, result =[r]
 /*------ at this point outcomes length = 3 ---------- */

 //GREEN BOX (is inside RED BOX)
 //is there another element to go through? YES : "paper"
 //follow with paper, roundleft =2, result =[r]
 2, p  // internal call creates a YELLOW BOX
  //----- for each r p s, 
  //starts with rock, roundleft =1, result =[r, p]
  1, r // internal call creates a WHITE BOX
    //WHITE BOX: roundl 0, result =[r, p, r]
    0 => push result to outcomes. 
         exit WHITE BOX  and back inside YELLOW BOX 
         where roundl= 1, res=[r, p] 
         is there another element to go through? YES : "paper"
  //follow with paper, roundleft =1, result =[r, p]
  1, p   // internal call creates a WHITE BOX inside the YELLOW
    //WHITE BOX: roundl 0, result =[r, p, p]
    0 => push result to outcomes.
         exit WHITE BOX, back to YELLOW BOX
         is there another element to go through? YES : "scissor"

  //follow with scissor. roundleft =1, result =[r, p]
  1, s  // internal call creates a WHITE BOX
    //WHITE BOX: roundl 0, result =[r, p, s]
    0 => push result to outcomes.
         exit WHITE BOX, back to YELLOW BOX
         is there another element to go through? NO =>exit YELLOW BOX
         back inside GREEN BOX where roundl 2, result =[r]
 /*------ at this point outcomes length = 6 --------*/

 //GREEN BOX (inside the RED BOX)
 //is there another element to go through? YES : "scissor"
 //follow with scissor, roundleft =2, result =[r]
 2, s
  //----- for each r p s, 
  //starts with rock, roundleft =1, result =[r, s]
  1, r
    //WHITE BOX: roundl 0, result =[r, s, r]
    0 => push result to outcomes. 
         exit WHITE BOX  and back inside YELLOW BOX
         where roundl= 1, res=[r, s] 
         is there another element to go through? YES : "paper"
  //follow with paper, roundleft =1, result =[r, s]
  1, p 
    //WHITE BOX: roundl 0, result =[r, s, p]
    0 => push result to outcomes.
         exit WHITE BOX, back to YELLOW BOX
         is there another element to go through? YES : "scissor"

  //follow with scissor. roundleft =1, result =[r, s]
  1 s // decrement to 0
    //WHITE BOX: roundl 0, result =[r, p, s]
    0 => push result to outcomes.
         exit WHITE BOX, back to YELLOW BOX
         is there another element to go through? NO =>exit YELLOW BOX
         back inside GREEN BOX where roundl 2, result =[r]
 /*------ at this point outcomes length = 9 --------------*/

 //GREEN BOX : is there another element to go through after scissor ? 
 //    NO =>exit GREEN BOX
 //back inside RED BOX where roundl 3, result =[]
// RED BOX
//is there another element to go through after rock? YES : "paper"
//start with paper
3, p  // internal call creates a GREEN BOX
 //GREEN BOX : roundl 2, result =[p] 
 //-----for each r p s,
 //starts with rock, 
 2, r   // internal call creates a YELLOW BOX
  //YELLOW BOX : roundl 1, result = [p, r]
  //----- for each r p s, 
  //starts with rock, roundleft =1, result =[p, r]
  1, r   // internal call creates a WHITE BOX
    //WHITE BOX: roundl 0, result = [p, r, r]
    0 => push result to outcomes. 
         exit WHITE BOX and back inside YELLOW BOX
         where roundl= 1, result = [p, r] 
         is there another element to go through? YES : "paper"
  //follow with paper, roundleft =1, result =[p, r]
  // ... and so on...

以此类推，直到我们再次回到红盒子，结果长度将从9(岩石(到18(纸上(再到27(剪刀(
因此，基本上，在递归中，每次创建新的作用域时，都会在内部调用一个函数。执行相同的代码块，每次都使用只知道其值的参数，因此不会影响范围外的参数(框(。当点击框的底部时，如果没有函数的内部调用，它将返回到父框(向上一级(
我的母语是法语，所以希望我的英语不会那么生疏，这个长方体类比可以帮助你理解递归是如何工作的。