aider à comprendre la récursivité et les exposants - JavaScript

Question

Je suis nouveau et j'ai travaillé pour essayer de rationaliser cela dans mon cerveau mais je n'arrive pas à le comprendre. D'abord la manière que beaucoup reconnaîtront l'aide d'un simple « pour » boucle:

function power(base, exponent){ 
var result = 1; 
    for(var i = 0; i < exponent; i++){ 
    if(exponent == 0) 
    return 1; 
    else 
    result *= base; 
}; 
return result; 
} 

Dans cette section, je lis à propos de récursivité et de parler de la façon dont une fonction peut s'appeler aussi longtemps qu'il ne provoque pas un débordement de pile . Le code est le suivant:

function power(base, exponent) { 
    if (exponent == 0) 
return 1; 
    else 
return base * power(base, exponent - 1); 
} 

console.log(power(2, 3)); 

Ce que je vais avoir un problème est de comprendre comment cela fonctionne en fait, ce que je pense qui se passe:

Après il passe devant le premier « si » il se déplace vers le "else" et s'appelle lui-même pour revenir en haut de l'instruction if, moins 1, à chaque fois jusqu'à ce qu'il atteigne 0 quand il retournera simplement le "résultat". Est-ce correct? Ou est-ce que je manque quelque chose entièrement?

Answer 1

ok, permet de regarder dans les étapes:

vous appelez pow(2, 3)

d'abord, il exécute ce code:

function power(base, exponent) { 
    if (exponent == 0) 
    return 1; 
    else 
    return base * power(base, exponent - 1); 
} 

en remplaçant les valeurs:

function power(base /* 2 */, exponent /* 3 */) { 
    if (3 == 0) 
    return 1; 
    else 
    return 2 * power(2, 2); 
} 

à accélérer cette réponse, je vais le présenter dans un tableau à partir de maintenant:

premier appel a pour

1) 2 * power(2, 2);

2) 2 * (2 * power(2, 1))

3) 2 * (2 * (2))

(sur ce dernier, exposant est un, de sorte qu'il retourne base ou 2)

chaque fois qu'il boucle, il répond par la base essentiellement

comme la boucle, dans l'exemple,

2 * (2 * (2)) === 8, si power(2, 3) === 8

Answer 2

récursivité est pas itérative, il ne fait pas la fonction revenir partout, il fait la fonction lancer une autre instance de lui-même pour résoudre davantage son résultat.

Considérons un exemple encore plus simple. Cette fonction compte à rebours du nombre donné à 0 et crie « cinq » et le nombre actuel à chaque fois qu'il est divisible par 5:

function foo(anumber) 
{ 
    if(anumber <= 0) 
    { 
     console.log("Reached 0, done."); 
    } 
    else 
    { 
     if(anumber % 5 == 0) 
     { 
      console.log("FIVE - " + anumber); 
     } 
     foo(anumber - 1); 
    } 
} 

foo vérifie si le nombre est égal ou inférieur à zéro, et sinon, vérifie si son divisible par 5, si oui, il crie, et indépendamment il lance un autre foo pour vérifier un nombre inférieur d'un. Lorsqu'une instance de foo atteint finalement 0, la chaîne ne continue pas et la pile s'effondre.

Cette utilisation simple de la récursivité est utilisée seulement dans la programmation fonctionnelle, ce qui dicte que les boucles variables et itératives sont mauvaises pour le code et causent un désordre. Généralement, il est plus simple et généralement beaucoup plus efficace en RAM d'utiliser une boucle.

La récursivité n'atteint son potentiel qu'avec des exemples plus compliqués, mais je suis sûr qu'avec les bases expliquées, comprendre cela ne sera pas un problème.