Une boucle consiste à faire une chose de manière répétée.Au cours du processus d'écriture du code, nous rencontrons souvent des opérations qui doivent être effectuées de manière répétée, comme parcourir certaines données, afficher de manière répétée une certaine chaîne, etc. Il serait trop difficile d'écrire une ligne. par ligne. , pour ce genre d'opération répétée, il faut choisir d'utiliser une boucle pour la compléter.
Le but d'une boucle est d'exécuter à plusieurs reprises un certain morceau de code. L'utilisation de boucles peut réduire la pression de programmation, éviter la redondance du code, améliorer l'efficacité du développement et faciliter la maintenance ultérieure. La boucle while est l'instruction de boucle la plus simple fournie en JavaScript. Découvrons l'utilisation des boucles while et des boucles do-while.
L'instruction de boucle while est un当型instruction de boucle. La condition de boucle est d'abord jugée lorsque la condition est satisfaite, et si elle n'est pas satisfaite, elle s'arrête.
Fonction : Répétez une opération jusqu'à ce que la condition spécifiée ne soit pas remplie.
Caractéristiques : jugez d'abord l'expression et exécutez l'instruction correspondante lorsque le résultat de l'expression est vrai.
1. Syntaxe de la boucle JS
while while (expression) { // L'expression est la condition de la boucle // Code à exécuter} Analyse de l'instruction :
calculez d'abord la valeur de "expression", lorsque la valeur est vraie, exécutez "PHP" dans la boucle body Statement block";
Description : Le résultat du calcul de "expression" est de type booléen (TRUE ou FALSE). S'il s'agit d'une valeur d'autres types, elle sera automatiquement convertie en valeur de type booléen (car PHP est un langage faible type et sera converti en fonction de la valeur de la variable, convertissant automatiquement la variable au type de données correct).
Un "bloc d'instructions" est une collection d'une ou plusieurs instructions entourées de
{ }; s'il n'y a qu'une seule instruction dans le bloc d'instructions,{ }peut également être omis.
Une fois l'exécution terminée, revenez à l'expression et calculez à nouveau la valeur de l'expression pour jugement. Lorsque la valeur de l'expression est vraie, continuez à exécuter le "bloc d'instructions"... Ce processus sera répété
jusqu'à la valeur de l'expression. est faux avant de sortir de la boucle, exécutez l'instruction ci-dessous while.
L'organigramme de l'instruction while est le suivant :
Habituellement, « expression » est une valeur calculée à l'aide d'opérateurs de comparaison ou d'opérateurs logiques.
L'exemple de code est le suivant :
<script>.
var je = 1;
tandis que( je <= 5) {
document.write(i+", ");
je++;
}
</script> 
Remarque :
lors de l'écriture d'une instruction de boucle, vous devez vous assurer que le résultat de l'expression conditionnelle peut être faux (c'est-à-dire que la valeur booléenne est fausse), car tant que le résultat de l'expression est vrai, la boucle continuera et ne se poursuivra pas. s'arrêter automatiquement. Pour ce type de panne Une boucle qui s'arrête automatiquement est généralement appelée « boucle infinie » ou « boucle infinie ».
Si vous créez accidentellement une boucle infinie, cela peut provoquer le blocage du navigateur ou de l'ordinateur.
Si l'expression est toujours vraie et que la condition de la boucle est toujours vraie, la boucle while continuera à s'exécuter et ne se terminera jamais, devenant une "boucle infinie"
var i = 1 ;
pendant que(je){
console.log(i);
} Après avoir exécuté le programme, la valeur de la variable i sera affichée jusqu'à ce que l'utilisateur force sa fermeture.
Exemple de boucle while JS
[Exemple 1] Utilisez la boucle while pour calculer la somme de tous les entiers compris entre 1 et 100 :
<script>
var je = 1;
var somme = 0 ;
pendant que(i<=100){
somme+=i;
je++;
}
console.log("La valeur de 1 ajoutée à 100 est : "+sum);
</script> Résultats de sortie :
[Exemple 2] Recherchez toutes les années bissextiles entre 1900 et 2020 et affichez-les sous forme de 6 par ligne :
<script>
var je = 1900 ;
var count = 0; //Compte le nombre d'années bissextiles while (i <= 2020) {
//Déterminer s'il s'agit d'une année bissextile if (i % 4 == 0 && i % 100 != 0 || i % 400 == 0) {
document.write(i + " ");
compte++;
si (compte % 6 == 0) {
document.write("<br/>");
}
}
je++;
}
</script> 
2. La structure imbriquée de la boucle while JS
peut également obtenir l'effet d'imbrication, c'est-à-dire qu'une ou plusieurs boucles while sont imbriquées à l'intérieur de la boucle while.
Format de syntaxe :
while(condition 1){
// Code exécuté lorsque la condition 1 est vraie while(condition 2){
// Code exécuté lorsque la condition 2 est vraie...
}
} Résumé : L'imbrication signifie l'inclusion. Ce qu'on appelle l'imbrication de la boucle while est un while imbriqué dans un while. Chaque while est la même que la syntaxe de base précédente.
Ici, nous définissons l'imbrication de deux boucles while. Bien entendu, nous pouvons imbriquer autant de boucles while que nous le souhaitons.
Comprendre le processus d'exécution de la boucle while.Une
fois l'exécution de la boucle interne terminée, le jugement de condition de la boucle externe suivante est exécuté.
Exemple 1 : à l'aide de boucles imbriquées, imprimez le compteur
<script type="text/javascript">
var je = 0;
tandis que(i < 2){
console.log("i =", i);
var j = 0 ;
tandis que(j < 2){
console.log("tj =", j);
j + = 1 ;
}
je++;
}
console.log("Terminé");
</script> 
Tout d'abord, nous définissons un nid de boucle while le plus externe. La variable de compteur i commence à 0 et la condition de fin est i < 2. Chaque fois que la boucle est exécutée, la valeur de i sera augmentée de 1 et la valeur actuelle de i sera imprimé.
À l'intérieur de la boucle la plus externe, une boucle interne est également définie. La variable de compteur j commence à 0 et la condition de fin est i < 2. Chaque fois que la boucle est exécutée, la valeur de j est augmentée de 1 et la valeur actuelle de j est imprimé.
Résumé de l'imbrication des boucles while
La boucle while de JavaScript peut également obtenir un effet imbriqué, c'est-à-dire qu'une ou plusieurs boucles while sont imbriquées dans une boucle while.
Exemple 2 :
<script>
/*
1. Imprimez belle-fille 3 fois en boucle, j'avais tort 2. Laver la vaisselle 3. Ce qui précède est un ensemble de punitions, cet ensemble de punitions est répété pendant 3 jours - un ensemble de punitions doit être répété - mets-le dans une boucle while */
var j = 0
tandis que(j < 3){
var je = 0
tandis que(i < 3){
document.write('Belle-fille, j'avais tort<br>')
je += 1 ;
}
document.write('faire la vaisselle<br>')
document.write('Une série de punitions est terminée !!!!!!!!!!!!<br>')
j + = 1 ;
}
</script> 
En plus de la boucle while, il existe également une boucle do-while.
L'instruction de boucle do-while est une instruction de boucle "直到型". Elle exécute d'abord une fois le " bloc d'instructions " dans le corps de la boucle, puis juge la condition de la boucle si elle est vraie, elle continuera à boucler si elle est fausse. , , la boucle est terminée.
Par conséquent : quel que soit le résultat de l'expression, l'instruction de boucle do-while exécutera le "bloc d'instructions" au moins une fois.
Les caractéristiques de l'instruction de boucle do-while : exécutez d'abord le corps de la boucle, puis déterminez si la condition de la boucle est vraie.
1. Syntaxe de boucle JS do-while
do{
bloc d'instructions ;
}while(expression);//L'expression est analysée comme une instruction conditionnelle de boucle :
Exécutez d'abord le "bloc d'instructions" dans le corps de la boucle, puis déterminez la valeur de "l'expression". Lorsque la valeur de "l'expression" est vraie, revenez pour réexécuter le bloc d'instructions dans le corps de la boucle... Ce processus sera répété
jusqu'à ce que l'expression Lorsque la valeur de la formule est fausse, sorte de la boucle. À ce moment, la boucle se termine et les instructions suivantes sont exécutées.
Remarque :
comme pour la boucle while, le résultat du calcul de "l'expression" dans la boucle do-while doit être booléen VRAI ou FAUX. S'il s'agit d'une valeur d'un autre type, elle sera automatiquement convertie en valeur booléenne.
Le point-virgule à la fin de l'instruction do-while ne peut pas être omis (il doit être présent) ; Il fait partie de la syntaxe de la boucle do while.
L'organigramme de l'instruction de boucle do-while est le suivant :
Exemple de boucle do-while JS
[Exemple 1] Utilisez do-while pour afficher les nombres 1 à 5 :
<script>
var je = 1;
faire {
document.write(i+", ");
je++;
}tandis que( je <= 5);
</script> 
[Exemple 2] Utilisez une boucle while pour calculer la somme de tous les entiers compris entre 1 et 100 :
<script>
var je = 1;
var somme = 0 ;
faire{
somme+=i;
je++;
}tandis que(i<=100);
console.log("1 + 2 + 3 + ... + 98 + 99 + 100 = "+somme);
</script> 
[Exemple 3] Trouvez toutes les années bissextiles entre 1900 et 2020
<script>
var je = 1900 ;
var count = 0; //Compte le nombre d'années bissextiles do {
//Déterminer s'il s'agit d'une année bissextile if (i % 4 == 0 && i % 100 != 0 || i % 400 == 0) {
console.log(i);
}
je++;
}pendant que (i <= 2020) ;
</script> 
2. La structure imbriquée de la boucle do-while de JS
do while loop peut également obtenir l'effet d'imbrication, c'est-à-dire qu'une ou plusieurs boucles do while sont imbriquées à l'intérieur de la boucle do while. Cette façon d’écrire est similaire à l’imbrication des boucles while.
Syntaxe :
faire{
// Bloc d'instructions 1 ;
faire{
// Bloc d'instructions 2 ;
faire{
// Bloc d'instructions 2 ;
...
} while (condition 3);
} while (condition 2);
}while(Condition 1); Ici, nous avons défini trois nids de boucles do while. Bien sûr, nous pouvons imbriquer autant de boucles do while que nous le souhaitons.
Cas : Utiliser l'imbrication de boucles pour imprimer le compteur
<script type="text/javascript">
var je = 0;
faire{
console.log("i =", i);
var j = 0 ;
faire{
console.log("tj =", j);
j + = 1 ;
}tandis que(j < 2);
je++;
}tandis que(i < 2);
console.log("Terminé");
</script> 
Tout d’abord, nous définissons un nid de boucle do while le plus externe. La variable de compteur i commence à 0 et la condition de fin est i < 2. Chaque fois que la boucle est exécutée, la valeur de i sera augmentée de 1 et la valeur actuelle de je serai imprimé.
À l'intérieur de la boucle la plus externe, une boucle interne est également définie. La variable de compteur j commence à 0 et la condition de fin est i < 2. Chaque fois que la boucle est exécutée, la valeur de j est augmentée de 1 et la valeur actuelle de j est imprimé.
Résumé de l'imbrication des boucles do while
La boucle do while de JavaScript peut également obtenir un effet imbriqué, c'est-à-dire qu'une ou plusieurs boucles do while sont imbriquées dans une boucle do while.
[Apprentissage recommandé : tutoriel avancé JavaScript]
Ce qui précède est le contenu détaillé de l'apprentissage de la boucle JS : l'utilisation des instructions de boucle while (exemples détaillés). Pour plus d'informations, veuillez prêter attention aux autres articles connexes sur le site Web PHP chinois !
