Javascript while, do-while et for boucles. Cycles

Boucles JavaScript fournir une exécution répétée de calculs répétitifs. Ils optimisent le processus de codage en exécutant la même instruction ou le même bloc d'instructions qui forment le corps d'une boucle un nombre de fois spécifié (à l'aide d'une variable de compteur) ou lorsqu'une condition spécifiée est vraie. Les boucles parcourent une séquence de valeurs. Exécuter une boucle une fois est appelé itération.

Les performances d'une boucle sont affectées par le nombre d'itérations et le nombre d'opérations effectuées dans le corps de la boucle de chaque itération.

Les opérateurs de boucle suivants existent en JavaScript :

1) for est utilisé lorsque vous savez à l'avance combien de fois vous devez faire quelque chose ;
2) for...in est utilisé pour parcourir les propriétés des objets ;
3) while est utilisé lorsque vous ne savez pas combien de fois vous devez faire quelque chose ;
4) do... while fonctionne de la même manière que l'instruction while. La différence est que do... while exécute toujours l'expression entre les accolades au moins une fois, même si le test de condition renvoie false .

Types de boucles en JavaScript, contrôle de boucle

1. Pour la boucle

La boucle for est utilisée pour parcourir les éléments de tableaux ou d'objets de type tableau tels que les arguments et HTMLCollection. La condition est vérifiée avant chaque itération de la boucle. Si la vérification réussit, le code à l'intérieur de la boucle est exécuté, sinon le code à l'intérieur de la boucle n'est pas exécuté et le programme continue à partir de la première ligne suivant immédiatement la boucle.

La boucle suivante imprimera la ligne Hello, JavaScript ! cinq fois.

Pour (var je = 0; je< 5; i++) { console.log(i + ": Hello, JavaScript!"); }
Riz. 1. Résultat de l'exécution d'une boucle for sur la console

1.1. Comment fonctionne la boucle for

La boucle for se compose de trois opérations différentes :

Étape 1. initialisation var je = 0; — déclaration d'une variable compteur qui sera vérifiée lors de l'exécution de la boucle. Cette variable est initialisée avec la valeur 0. Le plus souvent, les variables nommées i, j et k agissent comme des compteurs de boucles.

Étape 2. vérification de l'état je< 5; — условное выражение, если оно возвращает true , тело цикла (инструкция в фигурных скобках) будет выполнено. В данном примере проверка условия идёт до тех пор, пока значение счётчика меньше 5 .

Étape 3. opération finale i++ - opération d'incrémentation du compteur, augmente la valeur de la variable var i de un. Au lieu de l’opération d’incrémentation, l’opération de décrémentation peut également être utilisée.

A la fin de la boucle, la variable var i est stockée à 1. L'itération suivante de la boucle est exécutée pour (var i = 1; i< 5; i++) { } . Условное выражение вычисляется снова, чтобы проверить, является ли значение счётчика i всё ещё меньше 5 . Если это так, операторы в теле цикла выполняются ещё раз. Завершающая операция снова увеличивает значение переменной на единицу. Шаги 2 и 3 повторяются до тех пор, пока условие i < 5; возвращает true .

1.2. Impression des valeurs du tableau

Pour imprimer les valeurs d'un tableau à l'aide d'une boucle for, vous devez utiliser la propriété length du tableau. Cela vous aidera à déterminer le nombre d'éléments dans le tableau et à boucler le même nombre de fois.

Le script ci-dessous affichera cinq messages avec les noms des couleurs :

Fleurs du Var = ["Rose", "Lis", "Tulipe", "Jasmin", "Orchidée"]; pour (var je = 0; je< flowers.length; i++){ alert(flowers[i] + " - это цветок."); }

Si la valeur de la propriété length ne change pas pendant la boucle, vous pouvez la stocker dans une variable locale, puis utiliser cette variable dans une expression conditionnelle. De cette façon, vous pouvez augmenter la vitesse de la boucle, puisque la valeur de la propriété length ne sera récupérée qu'une seule fois pendant toute la durée de la boucle.

Var flowers = ["Rose", "Lis", "Tulipe", "Jasmin", "Orchidée"], len = flowers.length; pour (var je = 0; je

2. Boucle pour...in

Les boucles For...in sont utilisées pour parcourir les propriétés des objets non-tableaux. Ce contournement est également appelé transfert. Lors du parcours, il est recommandé d'utiliser la méthode hasOwnProperty() pour filtrer les propriétés héritées du prototype.

Par exemple, créons un objet en utilisant un littéral d'objet.

Var user = ( nom : "Alice", âge : 25, pays : "Russie" ); for (var prop in user) ( console.log(prop + ": " + user); )
Riz. 2. Résultat de l'exécution de la boucle for...in sur la console

Supposons que dans un scénario avant ou après la création de l'objet utilisateur, le prototype de l'objet Object ait été étendu avec une méthode clone() supplémentaire.

Si (type d'Object.prototype.clone === "indéfini") ( Object.prototype.clone = function () (); )

Étant donné que la chaîne d'héritage du prototype est constamment vérifiée par l'interpréteur, tous les objets ont automatiquement accès à la nouvelle méthode.

Riz. 3. Résultat de la répétition de la boucle for...in sur la console

Pour éviter la détection de cette méthode lors de l'énumération des propriétés de l'objet utilisateur, la méthode hasOwnProperty() est utilisée, qui filtrera les propriétés du prototype.

Var user = ( nom : "Alice", âge : 25, pays : "Russie" ); if (typeof Object.prototype.clone === "indéfini") ( Object.prototype.clone = function () (); ) for (var prop in user) ( if (user.hasOwnProperty(prop)) ( console.log (prop + ": " + utilisateur);
Riz. 4. Le résultat de la liste des propriétés d'un objet à l'aide de la méthode hasOwnProperty()

3. Boucle while

La boucle while est une boucle avec une vérification préliminaire d'une expression conditionnelle. L'instruction à l'intérieur de la boucle (bloc de code entre accolades) sera exécutée si l'expression conditionnelle est évaluée à true . Si la première vérification renvoie false , le bloc d'instructions ne sera pas exécuté une seule fois.

Une fois l'itération de la boucle terminée, la vérité de l'expression conditionnelle est à nouveau testée et le processus est répété jusqu'à ce que l'expression soit évaluée comme false . Dans ce cas, le programme continuera à partir de la première ligne immédiatement après la boucle (s'il y en a une).

Cette boucle affichera la table de multiplication du nombre 3 :

Var je = 1 ; var msg = ""; pendant que (je< 10) { msg+= i + " x 3 = " + (i * 3) + "
"; i++; ) document.write(msg);
Riz. 5. Résultat de l'exécution de la boucle while

4. Faites... while en boucle

Boucle faire... while; vérifie la condition de continuation après l'exécution de la boucle. Contrairement à la boucle while, dans do... while; Le corps de la boucle est exécuté au moins une fois, puisque la condition est vérifiée à la fin de la boucle, et non au début. Cette boucle est utilisée moins fréquemment que while , car en pratique, une situation où au moins une exécution de boucle est requise est rare.

Var résultat = "" ; var je = 0; faire ( je += 1; résultat += je + " "; ) tandis que (je< 5); document.write(result);
Riz. 6. Résultat de l'exécution de la boucle do...while

Dans l'exemple suivant, les instructions d'une boucle sont exécutées une fois, même si la condition n'est pas vraie.

Var je = 10 ; faire ( document.write(i + " "); i++; ) tandis que (i< 10);

5. Boucles infinies

Lorsque vous créez une boucle, vous pouvez créer une boucle infinie qui ne finira jamais. Une telle boucle pourrait potentiellement continuer à s'exécuter tant que l'ordinateur de l'utilisateur est en marche. La plupart des navigateurs modernes peuvent le détecter et inviter l'utilisateur à arrêter d'exécuter le script. Pour éviter de créer une boucle infinie, vous devez être sûr que la condition donnée renverra false à un moment donné. Par exemple, la boucle suivante définit une condition qui ne renvoie jamais false car i ne sera jamais inférieur à 10 :

Pour (var i = 25; i > 10; i++) ( document.write("Cette phrase s'exécutera pour toujours...
"); }

6. Boucles imbriquées

Une boucle à l’intérieur d’une autre boucle s’appelle imbriqué. A chaque itération de la boucle, la boucle imbriquée est exécutée complètement. Des boucles imbriquées peuvent être créées à l’aide d’une boucle for et d’une boucle while.

Pour (var count = 1; count< 3; count++) { document.write(count + ". Строка цикла
" ); pour (var nombre de nids = 1 ; nombre de nids< 3; nestcount++) { document.write("Строка вложенного цикла
"); } }
Riz. 7. Résultat de l'exécution d'une boucle for imbriquée

7. Gestion des cycles

La boucle peut être contrôlée à l'aide d'instructions break ; et continuez; .

7.1. Pause opérateur ;

Pause opérateur ; termine l'exécution de la boucle en cours. Il est utilisé dans des cas exceptionnels lorsque la boucle ne peut pas s'exécuter pour une raison quelconque, par exemple si l'application rencontre une erreur. Le plus souvent l'opérateur de pause ; fait partie de la construction if.

Lorsque la déclaration est interrompue ; utilisé sans étiquette, il vous permet de quitter une instruction loop ou switch. L'exemple suivant crée un compteur dont les valeurs doivent être comprises entre 1 et 99, mais l'instruction break rompt la boucle après 14 itérations.

Pour (var je = 1; je< 100; i++) { if (i == 15) { break; } document.write(i); document.write("
"); }
Riz. 8. Le résultat de l'opérateur break dans la boucle for

Pour les boucles imbriquées, l'instruction break ; utilisé avec une étiquette qui termine l'instruction nommée. Une étiquette vous permet de quitter n’importe quel bloc de code. Une instruction nommée peut être n’importe quelle instruction externe à une instruction break ; . L'étiquette peut être le nom d'une instruction if ou le nom d'un bloc d'instructions entouré d'accolades juste pour attribuer une étiquette à ce bloc. Entre le mot-clé break ; et le nom de l'étiquette n'autorise pas de nouvelle ligne.

Boucle extérieure : pour (var je = 0 ; je< 10; i++) { innerloop: for(var j = 0; j < 10; j++) { if (j >3) pause ; // Quitte la boucle la plus interne if (i == 2) break innerloop; // Même chose si (i == 4) break externalloop ; // Quitte la boucle externe document.write("i = " + i + " j = " + j + "
"); ) ) document.write("FINAL i = " + i + " j = " + j + "
");

7.2. L'opérateur continue ;

L'opérateur continue ; arrête l'itération en cours de la boucle et démarre une nouvelle itération. Dans ce cas, la boucle while revient directement à sa condition et la boucle for évalue d'abord l'expression d'incrémentation puis revient à la condition.

Cet exemple affichera tous les nombres pairs :

Var je;<= 10; i++) { if (i % 2 !== 0) { continue; } document.write("
pour (je = 1; je nombre pair
= " + je); )

Riz. 9. Le résultat de l'opérateur continue dans la boucle for

L'opérateur continue ; peut également être utilisé dans des boucles imbriquées avec une étiquette.
");
Boucle extérieure : pour (var i = 0; i "); pour (var j = 0; j ");

) ) document.write("Toutes les boucles terminées"+" Riz. 10. Le résultat de l'opérateur continue avec une étiquette

Cycles sont des expressions spéciales qui permettent d’exécuter plusieurs fois le même bloc de code. L'exécution du code est interrompue lorsqu'une certaine condition se produit. JavaScript offre aux programmeurs plusieurs variétés

cycles

. Regardons-les de plus près. Boucle avec compteur

Faire du vélo

avec un compteur est pratique si un code doit être exécuté un nombre de fois strictement défini. C’est probablement le type de cycle le plus courant.<выражение инициализации>; <условие>; <приращение>)
<тело цикла>

Le mot-clé for est utilisé ici. Par conséquent, ces boucles sont souvent appelées « boucles for ».

L'expression d'initialisation est exécutée en premier et une seule fois. Il attribue une variable spéciale appelée compteur de boucles à une valeur initiale (généralement 1). Le compteur de boucles compte combien de fois le corps de la boucle (le code réel qui doit être exécuté un certain nombre de fois) a été exécuté.

L'étape suivante consiste à vérifier l'état. Il détermine le moment où l'exécution de la boucle sera interrompue et le code suivant commencera à être exécuté. En règle générale, la condition compare la valeur du compteur de boucles avec sa valeur liée. Si la condition renvoie vrai, le corps de la boucle est exécuté, sinon la boucle se termine et le code qui suit la boucle commence son exécution.

Après avoir passé le corps faire du vélo L'expression d'incrémentation est exécutée, modifiant la valeur du compteur. Cette expression incrémente généralement le compteur (augmente sa valeur de un). Ensuite, la condition est à nouveau vérifiée, le corps de la boucle est exécuté, l'incrément est exécuté, etc., jusqu'à ce que la condition devienne fausse.

Exemple de boucle avec un compteur :

pour (i = 1; je< 11; i++) {
une += 3 ;
b = je * 2 + 1 ;
}

Cette boucle sera exécutée 10 fois. Nous attribuons au compteur i une valeur initiale de 1 et après chaque exécution du corps de la boucle nous l'incrémentons de un. La boucle cessera de s'exécuter lorsque le compteur passera à 11 et que la condition de boucle deviendra fausse.

Le compteur de boucle peut être écrit dans l’une des expressions du corps de boucle, comme nous l’avons fait. Dans notre cas, le compteur je contiendra des valeurs croissantes séquentiellement de 1 à 10, qui sont utilisées dans les calculs.

Voici deux autres exemples de boucle avec un compteur :

pour (i = 10; i > 0; i--) (
une += 3 ;
b = je * 2 + 1 ;
}

Ici, la valeur du compteur est décrémentée. Sa valeur initiale est 10. La boucle sera exécutée 10 fois et se terminera lorsque le compteur i contiendra 0 ; dans ce cas, les valeurs de ces dernières diminueront successivement de 10 à 1.

pour (i = 2; je< 21; i += 2) b = i * 2 + 1;

Et dans cet exemple, la valeur initiale du compteur est 2 et la valeur finale est 21, mais la boucle sera exécutée encore une fois 10 fois. Et tout cela parce que la valeur du compteur augmente de 2 et prend successivement les valeurs 2, 4, 6... 20.

Boucle avec postcondition

Une boucle de postcondition ressemble beaucoup à une boucle de compteur : elle s'exécute tant que la condition de boucle reste vraie. De plus, la condition n'est pas vérifiée avant, mais après l'exécution du corps de la boucle, c'est pourquoi la boucle avec une postcondition tire son nom. Une telle boucle sera exécutée au moins une fois, même si sa condition est fausse dès le début.

Format de boucle avec postcondition :

faire
<тело цикла>
alors que (<условие>);

Pour définir une boucle avec une postcondition, les mots-clés do et while sont fournis, c'est pourquoi ces boucles sont souvent appelées « boucles do-while ».

Voici un exemple de boucle avec une postcondition :

faire (
une = une * je + 2 ;
++je;
) tandis que (un< 100);

Voici un autre exemple :

var une = 0, je = 1;
faire (
une = une * je + 2 ;
++je;
) tandis que (je< 20);

Bien qu'ici, il serait plus pratique d'utiliser une boucle avec un compteur qui nous est déjà familier et spécialement conçue pour de tels cas.

Boucle avec précondition

. Regardons-les de plus près. avec une précondition diffère d'une boucle avec une postcondition en ce sens que la condition est vérifiée avant d'exécuter le corps de la boucle. Ainsi, si la condition est initialement fausse, la boucle ne sera pas exécutée une seule fois :

alors que (<условие>)
<тело цикла>

Pour créer une boucle avec une postcondition, le mot clé while est fourni. Par conséquent, ces boucles sont également appelées « boucles while » (à ne pas confondre avec les « boucles do while » !).

Exemple de boucle avec une précondition :

tandis que (un< 100) {
une = une * je + 2 ;
++je;
}

Interrompre et redémarrer un cycle

Il est parfois nécessaire d'interrompre l'exécution d'une boucle. Pour y parvenir, JavaScript fournit aux programmeurs Web des instructions break et continue.

L'opérateur break permet d'interrompre l'exécution d'une boucle et de passer à l'expression suivante :

tandis que (un< 100) {
une = une * je + 2 ;
si (a > 50) pause ;
++je;
}

Dans cet exemple, on rompt la boucle si la valeur de la variable un dépassera 50.

L'instruction continue restart vous permet de redémarrer faire du vélo, c'est-à-dire laisser toutes les expressions suivantes incluses dans le corps de la boucle non exécutées et commencer à exécuter la boucle depuis le tout début : vérifier la condition, exécuter l'incrément et le corps, etc.

Exemple:

tandis que (un< 100) {
je = ++je;
si (je > 9 && je< 11) continue;
une = une * je + 2 ;
}

Ici, nous sautons l'expression qui évalue un, pour toutes les valeurs je de 10 à 20.

L'objectif principal du while de JavaScript est d'exécuter de manière répétée un morceau de code spécifique, encore et encore. C'est très similaire à une boucle for avec une différence importante. Permettez-moi de prendre un peu de votre temps pour vous expliquer la différence entre ces deux types de cycles.

Quelle est la différence entre les boucles while et for ?

La différence entre ces boucles réside dans la manière dont elles arrêtent d’exécuter un morceau de code.

La boucle for exécute un nombre défini d'itérations. On sait exactement combien de fois la boucle exécutera le fragment de code contenu dans son corps.

Au fil du temps, tout se passe différemment. Une boucle while JavaScript s'exécute tant qu'une certaine condition est vraie. Une fois que la condition est évaluée comme fausse, la boucle while se termine.

La raison pour laquelle ces boucles sont différentes est que nous ne pouvons pas nécessairement savoir à l’avance quand une condition donnée ne sera plus vraie. Par conséquent, nous ne pouvons pas prédire combien d’itérations de la boucle while seront terminées avant qu’elle ne se rompe.

Avantages et inconvénients de la boucle while

Permettez-moi de commencer par examiner le seul inconvénient majeur de la boucle while. Cela peut fonctionner pour toujours !

Si vous vous trouvez dans une situation où la boucle while continue de s'exécuter indéfiniment, votre programme restera bloqué (ou se figera). Ensuite, vous devez fermer le navigateur pour interrompre l'exécution du code JavaScript.

Je dois noter que la boucle while non gérée de JavaScript ne s'exécute généralement pas éternellement. Parce qu'en tant que programmeurs, nous avons toujours la responsabilité de nous assurer qu'à un moment donné, la condition de notre boucle while devient fausse .

Maintenant, en ce qui concerne les « avantages », ils sont très évidents. While s'exécutera en continu tant que la condition est remplie. Un exemple d'utilisation d'une boucle while consiste à demander à l'utilisateur de saisir des données. La boucle vous demandera de saisir des données encore et encore jusqu'à ce que l'utilisateur saisisse les données correctes.

Syntaxe de la boucle While

La syntaxe des boucles for et while est très similaire.

Vous devez utiliser le mot-clé while et également définir une condition sous laquelle la boucle sera exécutée. Comme les autres structures de contrôle, la boucle while définit sa portée.

Voici à quoi devrait ressembler le code :

while () ( // insère ici le code qui doit être exécuté en boucle)

Le plus difficile est de déterminer quelle ou quelles conditions doivent être placées dans la boucle pour qu’elle fonctionne correctement.

N'oubliez pas que tant que la condition est vraie, la boucle continuera à s'exécuter. Regardons un exemple d'utilisation de while en JavaScript.

Exemple de boucle while

Disons que nous voulons demander à l'utilisateur de saisir un nombre compris entre 1 et 10. Mais que se passe-t-il s'il saisit un mauvais nombre ?

Dans ce cas, il faut lui demander de saisir à nouveau la valeur, et vérifier si la condition est remplie ( si un nombre de 1 à 10 est saisi).

C'est un cas où une boucle for échouerait lamentablement. Parce que nous ne pouvons pas savoir à l’avance combien de fois nous devrons demander à l’utilisateur de saisir le bon numéro. Dans ce cas, la boucle while nous vient en aide.

Voici à quoi pourrait ressembler notre code :

var theNumber = prompt("Veuillez entrer un nombre entre 1 et 10."); tandis que (le nombre< 1 || theNumber >10 || isNaN(theNumber)) ( theNumber = prompt("Valeur saisie non valide, veuillez saisir un nombre compris entre 1 et 10!"); ) alert("Excellent ! Vous avez entré un nombre : " + theNumber);

Il convient de noter que dans l'exemple ci-dessus, nous avons trois conditions distinctes dans une boucle while JavaScript.

Voici les trois conditions : le numéro 10 || estNaN(leNombre). Ils indiquent ce qui suit :

• SI le Nombre est inférieur à 1, OU ;
• SI le Nombre est supérieur à 10, OU ;
• SI le numéro n'est PAS un nombre, continuez la boucle.

Puisque nous utilisons l'opérateur OR (||) entre toutes les conditions, cela signifie que si l'une des conditions est vraie, alors la condition globale de la boucle while sera évaluée comme vraie et la boucle continuera à s'exécuter.

Ce n'est que si les trois conditions sont évaluées à false que la condition globale de la boucle while sera évaluée à false et qu'elle s'arrêtera.

Conclusion

La boucle while JavaScript est la seule véritable boucle dans les langages de programmation. for est juste une variante spéciale de la boucle while.

Il s'agit d'un cas où vous pouvez recréer vous-même une boucle for en utilisant la syntaxe de la boucle while, regarder et apprendre :

compteur var = 0 ; tandis que (compteur< 10) { counter = counter + 1; console.log("The counter is currently at: " + counter); }

Le code sera répété exactement 10 fois, ni plus ni moins. C'est exactement ainsi que fonctionne la boucle for.

Il n'y a pas lieu d'avoir peur d'utiliser JavaScript pendant que . Car sans cela, de nombreuses applications ne fonctionneraient tout simplement pas correctement !

J'espère que vous avez apprécié cet article.

La traduction de l’article « While Loop in JavaScript » a été préparée par l’équipe sympathique du projet.

Bon Mauvais

Cycles

Pour comprendre l’effet des instructions conditionnelles, nous avons suggéré de les imaginer comme des bifurcations sur la route le long desquelles se déplace l’interpréteur JavaScript. Les boucles peuvent être considérées comme un demi-tour sur la route qui vous ramène, obligeant l’interprète à parcourir encore et encore le même morceau de code.

JavaScript comporte quatre boucles : while, do/while, for et for/in. Une des sous-sections suivantes est consacrée à chacun d’eux. Une utilisation courante des boucles consiste à parcourir les éléments d’un tableau.

boucle while

L'instruction if est l'instruction conditionnelle de base en JavaScript, et la boucle de base pour JavaScript est la boucle while. Il a la syntaxe suivante :

while (expression) (instruction)

La boucle while commence par évaluer une expression. Si cette expression est évaluée comme fausse, l'interpréteur ignore l'instruction qui constitue le corps de la boucle et passe à l'instruction suivante du programme. Si l'expression est évaluée comme vraie, alors l'instruction qui forme le corps de la boucle est exécutée, puis le contrôle est transféré au début de la boucle et l'expression est à nouveau évaluée. En d’autres termes, l’interpréteur exécute l’instruction du corps de la boucle encore et encore tant que la valeur de l’expression reste vraie. Veuillez noter qu'il est possible de créer une boucle infinie en utilisant la syntaxe while(true).

En règle générale, vous ne souhaitez pas que l'interpréteur JavaScript effectue la même opération encore et encore. Dans presque chaque boucle, à chaque itération de la boucle, une ou plusieurs variables changent de valeur. Étant donné que la variable change, ce que fait l’instruction peut différer à chaque fois qu’elle traverse le corps de la boucle.

De plus, si la ou les variables en cours de modification sont présentes dans l'expression, la valeur de l'expression peut changer à chaque passage de la boucle. C'est important parce que sinon l'expression dont la valeur était vraie ne changera jamais et la boucle ne se terminera jamais ! Vous trouverez ci-dessous un exemple de boucle while qui imprime les nombres de 0 à 9 :

Nombre de variables = 0 ; tandis que (compter

Comme vous pouvez le voir, la variable count est définie sur 0 au début, puis sa valeur est incrémentée à chaque fois que le corps de la boucle est exécuté. Une fois la boucle exécutée 10 fois, l'expression retournera false (c'est-à-dire que la variable count n'est plus inférieure à 10), l'instruction while se terminera et l'interpréteur passera à l'instruction suivante du programme. La plupart des boucles ont des variables de compteur similaires à count. Le plus souvent, les variables nommées i, j et k agissent comme des compteurs de boucles, bien que pour rendre le code du programme plus compréhensible, vous devez donner aux compteurs des noms plus descriptifs.

faire/pendant la boucle

Une boucle do/while est similaire à bien des égards à une boucle while, sauf que l'expression de la boucle est testée à la fin plutôt qu'au début. Cela signifie que le corps de la boucle est toujours exécuté au moins une fois. Cette instruction a la syntaxe suivante :

faire (déclaration) while (expression);

La boucle do/while est utilisée moins fréquemment que sa sœur while. Le fait est qu'en pratique, la situation dans laquelle vous êtes sûr à l'avance de devoir exécuter le corps de la boucle au moins une fois est quelque peu inhabituelle. Vous trouverez ci-dessous un exemple d'utilisation d'une boucle do/while :

Fonction printArray(a) ( var len = a.length, i = 0; if (len == 0) console.log("Empty array"); else ( do ( console.log(a[i]); ) while (++je

Il existe deux différences entre une boucle do/while et une boucle while normale. Premièrement, une boucle do nécessite à la fois le mot-clé do (pour marquer le début de la boucle) et le mot-clé while (pour marquer la fin de la boucle et spécifier une condition). Deuxièmement, contrairement à une boucle while, une boucle do se termine par un point-virgule. Une boucle while n'a pas besoin de se terminer par un point-virgule si le corps de la boucle est entouré d'accolades.

pour la boucle

Une boucle for est une construction de boucle qui est souvent plus pratique qu’une boucle while. La boucle for facilite la construction de boucles qui suivent un modèle commun à la plupart des boucles. La plupart des boucles ont une sorte de variable compteur. Cette variable est initialisée avant le démarrage de la boucle et est vérifiée avant chaque itération. Enfin, la variable compteur est incrémentée ou autrement modifiée à la fin du corps de la boucle, juste avant que la variable ne soit à nouveau vérifiée. L'initialisation, la vérification et la mise à jour sont les trois opérations clés effectuées sur une variable de boucle. L'instruction for rend ces trois étapes explicites dans la syntaxe de la boucle :

pour (initialisation; vérification; incrément) (instruction)

Initialiser, vérifier et incrémenter sont trois expressions (séparées par des points-virgules) responsables de l'initialisation, de la vérification et de l'incrémentation d'une variable de boucle. Les placer sur la première ligne de la boucle permet de mieux comprendre ce que fait la boucle for et vous évite d'oublier d'initialiser ou d'incrémenter une variable de boucle.

La façon la plus simple d'expliquer la boucle for est d'afficher la boucle while équivalente :

initialisation ; while(check) ( instruction; incrément; )

En d’autres termes, l’expression d’initialisation est évaluée une fois avant le début de la boucle. Cette expression est généralement une expression avec des effets secondaires (généralement une affectation). JavaScript permet également à l'expression d'initialisation d'être une instruction de déclaration de variable var, il est donc possible de déclarer et d'initialiser un compteur de boucles en même temps.

L'expression de test est évaluée avant chaque itération et détermine si le corps de la boucle sera exécuté. Si le résultat du test est vrai, l'instruction qui constitue le corps de la boucle est exécutée. A la fin de la boucle, l'expression d'incrément est évaluée. Pour que cette expression ait un sens, il faut qu’elle ait des effets secondaires. Il s'agit généralement soit d'une expression d'affectation, soit d'une expression utilisant l'opérateur ++ ou --.

Vous pouvez également imprimer les nombres de 0 à 9 à l'aide d'une boucle for, comme indiqué ci-dessous, par opposition à la boucle while équivalente présentée dans l'exemple précédent :

Pour (var count = 0; count

Bien entendu, les boucles peuvent être beaucoup plus complexes que ces exemples simples, et parfois plusieurs variables changent à chaque itération de la boucle. Cette situation est la seule fois en JavaScript où l'opérateur virgule est souvent utilisé - il vous permet de combiner plusieurs expressions d'initialisation et d'incrémentation en une seule expression pouvant être utilisée dans une boucle for :

Var je,j; pour (i = 0, j = 0; je

boucle for/in

La boucle for/in utilise le mot-clé for, mais elle est complètement différente d'une boucle for classique. La boucle for/in a la syntaxe suivante :

pour (variable dans l'objet) (instruction)

La variable ici est généralement le nom de la variable, mais vous pouvez également utiliser l'instruction var, qui déclare une seule variable. Le paramètre objet est une expression qui renvoie un objet. Et comme d’habitude, une instruction est une instruction ou un bloc d’instructions qui forme le corps d’une boucle.

Pour parcourir les éléments d’un tableau, il est naturel d’utiliser une boucle for régulière :

Var arr = ; pour (var je = 0; je

L'instruction for/in permet aussi naturellement de parcourir les propriétés d'un objet :

// Crée un nouvel objet var obj = (name:"Alex", password:"12345" ); for (var i in obj) ( // Imprimer la valeur de chaque propriété d'objet console.log(obj[i]); )

Pour exécuter une instruction for/in, l'interpréteur JavaScript évalue d'abord l'objet expression. S'il renvoie null ou undefined, l'interpréteur saute la boucle et passe à l'instruction suivante. Si l'expression renvoie une valeur simple, elle est convertie en un objet wrapper équivalent. Sinon, l'expression renvoie un objet. L'interpréteur exécute ensuite une itération de la boucle pour chaque propriété énumérable de l'objet. Avant chaque itération, l'interpréteur évalue la valeur de l'expression, la stocke dans une variable et lui attribue un nom de propriété (une valeur de chaîne).

Les boucles sont l’un des outils les plus importants en programmation. Ils sont utiles dans les cas où vous devez faire quelque chose un certain nombre de fois.

S'il existe une telle tâche, par exemple, afficher la ligne « bonjour à tous » 1000 fois. Ensuite, sans utiliser de boucle, d’une part cela prendra beaucoup de temps et d’autre part, cela n’aura pas l’air très joli. C'est pourquoi il faut parfaitement connaître les cycles car ils sont utilisés très, très souvent.

Il y a quatre boucles dans la programmation, ce sont pendant, pendant que, pour et pour chaque. Chacun d'eux a sa propre syntaxe et chacun est utilisé dans certains cas.

Les boucles les plus couramment utilisées sont for et foreach, suivies de while, et la boucle do while est très rare.

Et nous allons commencer par la boucle while.

La syntaxe de la boucle while est la suivante :

Tout d’abord, nous déclarons la variable i, qui est un compteur, et à l’intérieur de la boucle nous incrémentons ce compteur. Entre parenthèses, nous écrivons la condition d’entrée/sortie de la boucle.

Commentaire! Écrivez correctement la condition de sortie, sinon cela peut arriver une boucle infinie et ensuite le script se figera. Un tel cycle peut se produire si, par exemple, nous écrivons simplement true dans la condition de sortie.

Par exemple, imprimons la chaîne « Bonjour à tous ! » 10 fois.

Var je = 0 ; pendant que(i "); i++; )

La variable i peut commencer à partir de 0 ou 1 ou de tout autre nombre.

La condition de sortie est en même temps la condition d’entrée. La boucle fonctionne comme suit : tout d'abord, elle vérifie si la variable i est inférieure à 10, et si la condition est vraie, alors nous entrons dans la boucle, sinon non. Dans ce cas, si la variable i est égale à 30, par exemple, alors la boucle ne s'exécutera pas, car 30 n'est pas inférieur à 10.

Nous sommes entrés dans le cycle, avons imprimé la ligne "Bonjour à tous", incrémenté le compteur et revenons à la condition, où nous vérifions à nouveau si la valeur de la variable i est inférieure à 10, puis nous entrons dans le cycle, sinon nous en sortons. Et cela se produit jusqu'au moment où la condition d'entrée devient fausse, c'est-à-dire que la valeur de la variable i sera 10. 10 n'est pas inférieur à 10, donc on n'entre plus dans la boucle, mais on passe à autre chose.

Commentaire! N'oubliez pas d'incrémenter le compteur (i++), sinon vous vous retrouverez avec une boucle infinie.

Nous avons traité de la boucle while, passons maintenant à la boucle do-while.

La syntaxe de la boucle do-while est la suivante :

La différence entre une boucle while et une boucle do-while est qu'une boucle do-while peut être exécutée au moins une fois, quelle que soit la condition, alors qu'une boucle while ne sera pas exécutée du tout si la condition est fausse.

Commentaire! Tout comme pour la boucle while, n'oubliez pas d'incrémenter le compteur i.

Passons à la pratique. Par exemple, calculons le produit de nombres de 1 à 10.

Var je = 1 ; production var = 1 ; faire( production *= i; i++; )tandis que(i

Le résultat sera le numéro 3628800. Dans la première étape, nous sommes immédiatement entrés dans la boucle, malgré son état, où l'opération production *= i a été effectuée (c'est la même chose que production = production * 1). Ensuite, nous incrémentons le compteur. Après incrémentation, il a une valeur de 2. Et à la fin on vérifie la condition, si la valeur du compteur est inférieure ou égale à 10, alors on passe à l'itération suivante de la boucle, sinon on sort de la boucle et on passe à autre chose .

pour la boucle

Comme je l'ai écrit ci-dessus, la boucle for se produit assez souvent, vous devez donc très bien la connaître.

pour la syntaxe de la boucle suivant:

Pour une meilleure compréhension, résolvons un problème simple. Disons que nous devons calculer la somme des nombres de 1 à 1000 à l'aide d'une boucle for.

Somme var = 0 ; pour(var je = 1; je

Nous enregistrons le document, l'ouvrons dans le navigateur et voyons que le résultat est 500500.

Commentaire! S’il n’y a qu’une seule instruction dans une boucle, les accolades ne sont pas nécessaires.

Pour démontrer, affichons 5 fois une chaîne à l’écran, par exemple « Bonjour ! »

Pour(var je = 1; je

Commentaire! Une fois la boucle exécutée, la dernière valeur reste dans la variable i.

Résolvons maintenant le problème un peu plus compliqué, par exemple nous devons imprimer la chaîne "Bonjour" 100 fois. Et pour que tout n'apparaisse pas sur une seule ligne, après chaque 10ème itération, nous passons à une nouvelle ligne. Et à la fin nous imprimerons la valeur de la variable i.

Pour(var je = 1; je<= 100; i++){ document.write("привет!"); if(i % 10 == 0)  document.write("
"); ) document.write("

Variable je = " + je + "

"); // je = 101

boucle foreach Généralement utilisé pour parcourir des objets et des tableaux. Par conséquent, j'en parlerai dans l'article décrivant le travail avec des tableaux.

instruction de pause est destiné à sortir de force de la boucle.

Continuer l'opérateur permet d'interrompre l'itération en cours de la boucle et de passer à la suivante.

Pour une meilleure compréhension, nous allons également résoudre un problème simple. Disons que nous voulons calculer la somme des nombres impairs de 1 à 20. Et lorsque nous atteindrons la 15ème itération, nous sortirons de la boucle.

Somme var = 0 ; pour(var je = 1; je<= 20; i++){ //Пропускаем текущею итерацию цикла if(i % 2 == 0) continue; summa += i; //Выходим совсем из цикла. if(i == 15) break; document.write(i + ". Итерация
"); ) document.write("

somme= " + somme + "

"); //somme = 64

Nous enregistrons le document, l'ouvrons dans le navigateur et regardons le résultat.

Pour vous entraîner, essayez de modifier le script écrit pour qu'il calcule la somme des nombres pairs.

Ceci termine cet article. Maintenant tu sais syntaxe des boucles while, do-while, for et comment travailler avec elles. Nous avons également rencontré instructions break et continue.