Le programme suivant exécute-t-il la boucle imbriquée lors de la première itération de la boucle externe?

Si premier doit retourner vrai pour les nombres premiers, faux pour les non-nombres premiers, alors quand vous détectez un non-premier, renvoyez simplement faux. Comme le soulignent les commentaires, vous n'avez pas besoin de deux boucles pour cela. Vous pouvez simplement faire une boucle de 2 à n-1, en essayant de diviser sans reste.

La boucle imbriquée n'est pas exécutée dans la première itération de la boucle externe, c'est-à-dire lorsque i == 2 . Dans la deuxième itération de la boucle externe, nous avons i == 3 , donc la condition de boucle imbriquée lit maintenant j <3 , de sorte qu'elle est évaluée une fois avec la valeur < code> j == 2 . Pour la troisième itération de la boucle externe, nous avons i == 4 , de sorte que la boucle imbriquée est évaluée deux fois pour les valeurs 2 et 3. Et ainsi de suite.

J'espère que ça aide - Carlos

Voici un graphique détaillant le déroulement de votre programme:

+---+---+-------------------------------------------------------------+
| i | j |                            Notes                            |
+---+---+-------------------------------------------------------------+
| 2 | 2 | Nested loop condition is false. Hence, 2 is a prime number. |
| 3 | 2 | 3 is not divisible by 2. Let's keep searching.              |
| 3 | 3 | Nested loop condition is false. Hence, 3 is a prime number. |
| 4 | 2 | 4 is divisible by 2. Hence, it's not a prime number.        |
| 5 | 2 | 5 is not divisible by 2. Let's keep searching.              |
| 5 | 3 | 5 is not divisible by 3. Let's keep searching.              |
| 5 | 4 | 5 is not divisible by 4. Let's keep searching.              |
| 5 | 5 | Nested loop condition is false. Hence, 5 is a prime number. |
| 6 | 2 | 6 is divisible by 2. Hence, it's not a prime number.        |
| 7 | 2 | 7 is not divisible by 2. Let's keep searching.              |
| 7 | 3 | 7 is not divisible by 3. Let's keep searching.              |
| 7 | 4 | 7 is not divisible by 4. Let's keep searching.              |
| 7 | 5 | 7 is not divisible by 5. Let's keep searching.              |
| 7 | 6 | 7 is not divisible by 6. Let's keep searching.              |
| 7 | 7 | Nested loop condition is false. Hence, 7 is a prime number. |
| 8 | 2 | 8 is divisible by 2. Hence, it's not a prime number.        |
| 9 | 2 | 9 is not divisible by 2. Let's keep searching.              |
| 9 | 3 | 9 is divisible by 3. Hence, it's not a prime number.        |
+---+---+-------------------------------------------------------------+

J'espère que cela explique pourquoi le programme fonctionne même si la boucle imbriquée ne s'exécute pas lorsque i = 2 code> et j = 2 .

Ok, expliquons cette boucle imbriquée par étapes:

1. Initialement i = 2 et j = 2 donc la boucle externe s'exécutera mais la boucle imbriquée ne s'exécutera pas . en sautant la boucle interne, il imprime 2 qui est à la fin de la boucle principale console.log(i)

2. Les boucles se terminent et i = 3 . cette fois, j est true donc la boucle imbriquée démarre.

3. Lors de la première boucle imbriquée i = 3 et j = 2

4. le continuer n'exécutera pas i% j n'est pas 0 donc il se termine et j code > augmente. Maintenant i = 3 et j = 3 et la boucle imbriquée sort et imprime 3

5. Désormais, la boucle i = 4 et imbriquée sera exécutée car j = 2 et j . p >

6. La condition i% j est true . Donc cette fois, continue nextPrime sera exécuté et la boucle externe recommencera avec i = 5 .

7. Maintenant i = 5 donc la boucle imbriquée sera exécutée. Les valeurs de j seront 2 3 4 dans des boucles imbriquées. Aucun d'entre eux ne provoquera continuer car 5% 2 5% 3 ou 5% 4 n'est pas 0 .

8. La boucle imbriquée se fermera après que j devienne 5 . Et il imprimera i qui est 5 .
   

   continue nextPrime fait tout. Il vérifiera si i% j == 0 cela signifie que i n'est pas premier. Il reviendra donc à la boucle externe avec i = i + 1 et ne passera pas le dernier à console.log()

showPrimes(6);

function showPrimes(n) {
    nextPrime:
    for (let i = 2; i < n; i++) {
        for (let j = 2; j < i; j++){
            console.log(`i:${i} j:${j}`)
            if (i % j == 0) continue nextPrime;
        }
        console.log(`prime${i}`); // a prime number
    }
}

Pourquoi j est changé encore et encore

Parce que c'est une variable locale et qu'il est toujours initialisé à 2 . Ce n'est pas seulement limité à la boucle intérieure. Lorsque la boucle interne est terminée, elle est détruite et lors de la prochaine boucle, elle est à nouveau initialisée à 2 en raison de for (let j = 2; ... p >