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é, en sinon le code à l'intérieur de la boucle n'est pas exécuté et le programme continue à partir de la première ligne immédiatement après 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 , тело цикла (инструкция в фигурных скобках) будет выполнено. В dans cet exemple La condition est vérifiée tant que la valeur du compteur est inférieure à 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 méthode supplémentaire clone() .

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

Boucle while - boucle avec pré-vérification 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 = ""; alors que je< 10) { msg+= i + " x 3 = " + (i * 3) + "
"; i++; ) document.write(msg);
Riz. 5. Résultat de l'exécution 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. Majorité navigateurs modernes peut le détecter et inviter l'utilisateur à arrêter d'exécuter le script. Pour éviter de créer boucle sans fin, vous devez être sûr que la condition donnée renverra false à un moment donné. Par exemple, la boucle suivante spécifie 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 continue; .

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é de croisillons uniquement pour attribuer une étiquette à ce bloc. Entre mot-clé casser; 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; pour (je = 1; je<= 10; i++) { if (i % 2 !== 0) { continue; } document.write("
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

faire des boucles while et foreach

faire une boucle . . alors que

faire...en boucle en C#, il s'agit d'une version de while avec une vérification post-condition. Cela signifie que la condition de la boucle est vérifiée après l'exécution du corps de la boucle. Par conséquent, les boucles do...while sont utiles dans les situations où un bloc d'instructions doit être exécuté au moins une fois. Voici la forme générale d'une instruction de boucle do-while :

do (opérateurs; ) while (condition);

S’il n’y a qu’un seul opérateur, les accolades dans cette forme de notation sont facultatives. Cependant, ils sont souvent utilisés pour rendre la construction do-while plus lisible et à ne pas confondre avec la construction de la boucle while. La boucle do-while s'exécute tant que l'expression conditionnelle est vraie. Un exemple d'utilisation d'une boucle do-while est le programme suivant, qui calcule la factorielle d'un nombre :

Utilisation du système ; en utilisant System.Collections.Generic ; en utilisant System.Linq ; en utilisant System.Text ; espace de noms ConsoleApplication1 ( class Program ( static void Main(string args) ( try ( // Calculer la factorielle d'un nombre int i, result = 1, num = 1; Console.WriteLine("Entrez un nombre :"); i = int .Parse(Console .ReadLine()); Console.Write("\n\nFactorial (0) = ", i); do ( result *= num; num++; ) while (num

boucle foreach

boucle foreach sert à l'accès cyclique aux éléments d'une collection, qui est un groupe d'objets. C# définit plusieurs types de collections, chacune étant un tableau. Voici la forme générale de l'instruction de boucle foreach :

instruction foreach (tapez loop_variable_name dans la collection) ;

Ici tapez nom_variable_boucle désigne le type et le nom de la variable de contrôle de boucle qui reçoit la valeur de l'élément suivant de la collection à chaque étape de la boucle foreach. Et collection désigne une collection interrogée cycliquement, qui représente ci-après un tableau. Par conséquent, le type de la variable de boucle doit correspondre au type de l’élément du tableau. De plus, un type peut être désigné par le mot-clé var. Dans ce cas, le compilateur détermine le type de la variable de boucle en fonction du type de l'élément du tableau. Cela peut être utile pour travailler avec certains types de requêtes. Mais en règle générale, le type est spécifié explicitement.

L'instruction de boucle foreach fonctionne comme suit. Lorsque la boucle démarre, le premier élément du tableau est sélectionné et affecté à la variable de boucle. À chaque étape d'itération suivante, l'élément suivant du tableau est sélectionné et stocké dans une variable de boucle. La boucle se termine lorsque tous les éléments du tableau sont sélectionnés.

Une boucle foreach vous permet de parcourir chaque élément d'une collection (un objet qui représente une liste d'autres objets). Techniquement, pour qu'un élément soit considéré comme une collection, il doit prendre en charge l'interface IEnumerable. Des exemples de collections incluent des tableaux C#, des classes de collection de l'espace de noms System.Collection et des classes de collection personnalisées.

Les boucles sont utilisées pour répéter des morceaux de code encore et encore. La capacité de répéter certains fragments de code est l'une des tâches principales et en même temps importantes qu'un programmeur doit résoudre. La plupart des programmes ou sites Web utilisent des boucles, par exemple, pour afficher des informations d'actualité ou des annonces. Autrement dit, dans de telles tâches, il est nécessaire d'effectuer en permanence des opérations de lecture et d'écriture, et afin de ne pas dupliquer le même code, les boucles viennent à la rescousse. Les boucles sont assez simples à déclarer dans le code, mais elles accomplissent des tâches complexes avec une simple répétition.

Pour commencer à découvrir les boucles, assurez-vous d’avoir une bonne compréhension du concept du langage de programmation C. Parce que cela sera vital dans l'utilisation des cycles, car dans les cycles, tout comme dans les cycles, il y a des expressions conditionnelles. Il existe trois types de boucles en langage C : for, while, do while. Chacun d’eux a ses propres applications spécifiques. Tous sont décrits ci-dessous.

La boucle la plus couramment utilisée est la boucle for, sa structure est présentée ci-dessous :

Pour (/*initialiser une variable; condition; changer la valeur d'une variable*/) ( // corps de la boucle (voici le code qui sera répété) )

L'initialisation de variable vous permet soit de déclarer une variable et de lui attribuer une valeur, soit d'attribuer une valeur à une variable existante. Deuxièmement, la valeur de cette variable indique au programme si la condition de boucle est vraie ou fausse. Et tant que la condition de boucle est vraie, la boucle doit continuer à se répéter. La variable de contrôle doit être modifiée d'une manière ou d'une autre, sinon la boucle sera sans fin, par exemple, vous pouvez la mettre à jour comme ceci : i++ , i = i + 2 ou même i = random(5) . Veuillez noter que chaque section de l'en-tête de la boucle est séparée par un point-virgule, ce qui est très important. Notez également que chacune des sections peut être vide, même si les points-virgules doivent toujours être là. Si la condition n'est pas vide, alors elle est évaluée à vrai et la boucle sera exécutée jusqu'à ce que quelque chose rende la condition de boucle fausse. Regardons un exemple simple d'utilisation d'une boucle for.

#inclure int main() ( int i; /* La boucle s'exécutera jusqu'à ce que je< 10, при этом после каждой итерации переменная i будет инкрементироваться(увеличиваться на 1)*/ for (i = 0; i < 10; i++) { /* Имейте ввиду что условие проверяется перед каждым повторением, то есть работа цикла остановится когда переменная i будет равна 10*/ printf("%d\n", i); } getchar(); }

En fait, le résultat du programme :

0 1 2 3 4 5 6 7 8 9

Ce programme est un exemple très simple d'utilisation d'une boucle. la variable i reçoit zéro, et tant que i est inférieur à 10, la valeur de la variable i est imprimée à l'écran, après quoi une est ajoutée à la variable i et tout est répété à nouveau jusqu'à ce que la condition devienne fausse. Gardez à l’esprit que la valeur de la variable i est incrémentée après la première exécution du code dans le corps de la boucle.

La boucle while est une boucle très simple, voici sa structure :

While (/*condition*/) ( // corps de la boucle - voici le code qui doit être répété)

Le corps de la boucle commence à s'exécuter si la condition de la boucle est vraie. La condition est une expression booléenne, telle que x == 1 ou x ! = 7 (x n'est pas égal à 7). Autrement dit, la condition peut être absolument n’importe quoi – n’importe quelle combinaison d’expressions logiques. Voici un exemple de condition composée - x == 3 || x > 10 , cette condition sera vraie si x est égal à trois ou x est supérieur à 10. Notez que bien qu'il ait une section d'initialisation ou une section de modification de variable contrôlée, donc avant d'utiliser cette boucle, vous devez d'abord déclarer la variable qui sera testé dans la boucle de condition et dans le corps de la boucle changera la valeur de cette variable. En fait, regardons un exemple simple utilisant une boucle while :

#inclure int main() ( int var = 0; /* assurez-vous de déclarer d'abord la variable */ while (var< 10) { /* пока значение переменной var меньше 10 */ printf("%d\n", var); var++; /* обновляем значение в переменной var(если этого не делать, то условие цикла всегда будет истинным, тогда цикл будет - бесконечным) */ } getchar(); }

Nous avons donc regardé un autre exemple d'utilisation de boucles, et comme vous pouvez le constater, il n'y a rien de compliqué dans cet exemple. Imaginez simplement que la boucle commence toujours à répéter le code qui se trouve dans le corps de la boucle. Dès que la dernière instruction du corps de la boucle est exécutée, la condition de la boucle est vérifiée. Si la condition est toujours vraie, alors la boucle continue de fonctionner, et si la condition est fausse, alors la boucle est quittée.

Il existe un autre type de boucle : faites while. Cette boucle est utile lorsque vous devez exécuter le code au moins 1 fois. Regardons sa structure :

Do ( // corps de la boucle ) while (/*condition*/);

La structure est très simple, comme vous pouvez le voir, la condition est à la fin de la boucle, et par conséquent, la condition sera vérifiée après l'exécution du code dans le corps de la boucle. Notez que la condition est testée à la fin de la boucle, pas au début, donc le bloc de code dans le corps de la boucle sera exécuté au moins une fois. Si la condition est vraie, la boucle revient au début et l'exécute à nouveau. Une boucle do while est presque la même chose qu'une boucle while, sauf que le corps de la boucle est garanti d'être exécuté au moins une fois. La boucle while vérifie d'abord la condition puis exécute le bloc de code dans le corps, si la condition est vraie bien sûr, tandis que la boucle do while exécute d'abord le code dans le corps de la boucle puis vérifie la condition, et si elle est vrai, alors il continue de fonctionner. Un exemple de la boucle do while est présenté ci-dessous :

#inclure int main() ( int i = 0; do ( /* Imprime un message et quitte */ printf("Salut ! Je fais une boucle while\n"); ) while (i != 0); getchar() ; )

Notez le point-virgule à la fin de la boucle, vous devez toujours placer ce point-virgule comme dans l'exemple ci-dessus. Très souvent, ce point-virgule n'est pas inclus, ce qui entraîne une erreur de compilation. Seul ce cycle se termine par un point-virgule ; les autres cycles n'ont rien à la fin sauf la parenthèse fermante. Notez que dans l'exemple ci-dessus, cette boucle sera exécutée une fois car le message est imprimé en premier puis la condition de la boucle est vérifiée.

Pour commencer à utiliser les boucles, vous devez savoir ce qu'elles sont, ce qu'elles peuvent faire et pourquoi elles sont nécessaires dans les scripts. Une boucle est un bloc de code qui permet de répéter certaines actions (instructions) une certaine quantité de une fois. Chaque exécution individuelle (une ou plusieurs répétitions) d'une séquence d'instructions dans une boucle est appelée une itération.

Chaque cycle se compose de deux parties principales. Le premier détermine quand l’exécution de la boucle doit être arrêtée. Le second est le fragment réel du code du programme qui exécute actions nécessaires, qui peut consister en une seule instruction ou en plusieurs instructions entourées d'accolades.

Code du programme La boucle s'exécute jusqu'à ce que l'expression conditionnelle de la boucle renvoie TRUE. Pour éviter une boucle infinie qui tournera indéfiniment, le code dans le corps de la boucle doit faire en sorte que l'expression conditionnelle renvoie FALSE à un moment donné. Lorsque cela se produit, la boucle cessera de s'exécuter et l'exécution continuera à partir de la ligne de code immédiatement après la boucle.

boucle while

La boucle while est le type de boucle le plus simple en PHP. Sa syntaxe est :

Ci-dessous un exemple de boucle while dont le corps est exécuté 10 fois :

\n"; $num++; ) ?>

Avant le début de la boucle, la valeur de la variable $num est définie sur 1 (la valeur peut être n'importe laquelle). C'est ce qu'on appelle l'initialisation d'une variable compteur. Chaque fois que le corps de la boucle est exécuté, la valeur de la variable $num est augmentée de un à l'aide de l'incrément $num++. Valeur de l'expression ($num<= 10) проверяется каждый раз перед итерацией цикла. После десяти итераций условное выражение вернет значение FALSE (так как значение переменной $num уже будет не меньше или равно 10) и работа цикла прекратится. В том случае, если условное выражение while будет равно FALSE с самого начала, тело цикла ни разу не будут выполнено.

La plupart des boucles ont des variables de compteur similaires à $num . 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 une boucle while

Une boucle do while est très similaire à une boucle while, sauf que l'expression conditionnelle est testée à la fin de l'itération plutôt qu'au début. La syntaxe de cette boucle est la suivante :

Il existe deux différences entre une boucle do while et une boucle while normale. Premièrement, une boucle do while 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 while se termine par un point-virgule. Ce type de boucle est utile lorsque le corps de la boucle doit être exécuté au moins une fois, quelle que soit la valeur de l'expression conditionnelle.

Essayons d'effectuer les mêmes actions que dans l'exemple précédent :

\n"; $num++; ) tandis que ($num<= 10); ?>

Souvent, lors de la programmation de tâches, il est nécessaire d’exécuter plusieurs fois la même séquence de commandes. Ce processus est appelé cyclique. Un algorithme dans lequel une certaine séquence de commandes est répétée plusieurs fois avec de nouvelles données d'entrée est appelé cyclique.

Pour la mise en œuvre processus cyclique, les langages de programmation utilisent des boucles. Le langage de programmation C/C++ possède des opérateurs de boucle faciles à utiliser.

2. Types d'opérateurs de boucle en C++

Il existe 3 types d'opérateurs de boucle en C++ :

• pour la boucle ;
• boucle while avec condition préalable ;
• faire... while boucle avec postcondition.

Chacun des opérateurs de boucle possède ses propres fonctionnalités d'application. N'importe laquelle des instructions de boucle ci-dessus peut être remplacée par une autre.

3. Pour la boucle. Forme générale de l'instruction de boucle for

En C++, la boucle for peut avoir une implémentation et une application très larges. Une boucle for est également appelée boucle avec un paramètre.

La forme générale de l'instruction de boucle for est :

pour ( initialisation ; expression ; croissance ) { // ... }

• initialisation – une opération d'affectation dans laquelle la valeur initiale d'une variable de boucle est définie. Cette variable est un compteur qui contrôle le fonctionnement de la boucle. Nombre de variables contrôlant pour la boucle, peut-être deux ou plus ;
• expression– une expression conditionnelle qui vérifie la valeur d'une variable de boucle. À ce stade, la suite de l'exécution du cycle est déterminée ;
• croissance– détermine comment la valeur de la variable de boucle changera après chaque itération.

La boucle for s'exécute jusqu'à la valeur expression est égal à vrai. Dès que la valeur de expression devient fausse, la boucle arrête son exécution et l'instruction qui suit la boucle for est exécutée.

4. Exemples d'utilisation de l'opérateur de boucle for

Exemple 1. Trouvez la somme de tous les entiers de 100 à 300.

// somme de nombres de 100 à 300 somme entière ; int je; somme = 0 ; pour (i = 100; je<=300; i++) sum = sum + i; // sum = 40200

Exemple 2.Étant donné un nombre naturel n. Calculez le montant :

Un fragment de code qui résout ce problème.

// s = 1 + 1/2 + 1/3 + ... + 1/n entier n; flotteur s = 0 ; int je; // entrez la valeur n n = 4 ; pour (i = 1; je<=n; i++) s = s + 1.0/i; // s = 2.08333

Dans cet exemple, pour obtenir une valeur réelle, au lieu du chiffre 1 (type entier), le nombre 1.0 (type réel) est saisi. Opération de division

donne un vrai résultat.

Exemple 3. Calculer la somme

Un fragment de code qui résout ce problème.

flotter s; int je; s = 0 ; pour (i=50 ; i>=1 ; i--) s = i + Math::Sqrt(s); s = Math::Sqrt(s); // s = 1,7579

Dans cet exemple, la valeur du compteur je dans la boucle for change par ordre décroissant. Cette valeur est diminuée de 1 à chaque itération de la boucle. Lors de la résolution de tels problèmes, la valeur du compteur de boucle doit passer de la dernière à la première valeur. Dans ce cas, de 50 à 1.

Les calculs ont utilisé la fonction Sqrt() de la bibliothèque Math.

5. Quelles sont les options disponibles pour implémenter une boucle for ?

La boucle for peut avoir plusieurs implémentations. Le nombre de variables contrôlant la boucle for peut être une, deux ou plus.

Il se peut qu'une boucle for manque l'un des éléments d'en-tête de boucle :

• initialisation ;
• expression;
• croissance.

Exemple un opérateur de boucle for qui a 2 variables de contrôle. Retrouvez les significations du produit :

D = (1 + cos(9)) (2 + cos(8)) … (9 + cos(1))

Un fragment de code qui résout ce problème.

// D = (1 + cos(9))*(2 + cos(8))* ... *(9 + cos(1)) int je, j; flotter d; ré = 1 ; pour (i = 1, j = 9; je<=9; i++, j--) d = d * (i + Math::Cos(j));

Dans l'extrait de code ci-dessus, la boucle for utilise deux variables qui modifient leur valeur ( je , j ).

6. Boucle while. Forme générale

La boucle while est appelée boucle de précondition. La forme générale d'une boucle while est la suivante :

alors que ( expression ) { // séquence d'opérateurs // ... }

Où expression– toute expression valide en C++. La séquence d'instructions est exécutée jusqu'à ce que le conditionnel expression renvoie vrai . Dès que expression devient égal à false , l'exécution de la boucle while est terminée et le contrôle est transféré à l'instruction suivante après la boucle while.

7. Exemples d'utilisation de l'opérateur de boucle while

Exemple 1.Étant donné un nombre réel un. Trouver le plus petit n, auquel

Considérations. Au début la valeur de la somme est inférieure à la valeur un. À chaque itération, la valeur de la somme augmente progressivement. À un moment donné (à une certaine valeur n) ce montant deviendra supérieur à la valeur un. Ce moment (c'est-à-dire n) doit être corrigé. Calculer n, une boucle while est pratique.

Un fragment de code qui résout ce problème.

flotter un; entier n; somme flottante ; // entrez la valeur a une = 2,2 ; n = 1 ; somme = 1,0/n ; tandis que (somme< a) { n++; sum = sum + 1.0/n; } // n = 5; sum = 2.283334

Exemple 2. Un nombre naturel est donné. Déterminez le nombre de chiffres 3 qu'il contient.

Un fragment de code qui résout ce problème.

// nombre de chiffres 3 dans le nombre entier n; // nombre naturel donné entier k ; // nombre de chiffres 3 dans le nombre int t, d; // variables supplémentaires // entrez la valeur n n = 12343 ; t = n; // fait une copie de n k = 0 ; tandis que (t>0) ( d = t % 10 ; // sélectionne le dernier chiffre si (d == 3) k++ ; t = t/10 ; // réduit la profondeur de bits du nombre) // k = 2

Dans cet exemple, la valeur du nombre d'origine sera divisée par 10 à chaque itération. Ainsi, la profondeur de bits du nombre diminuera. A chaque itération, en utilisant l'opération % du langage C++, le reste de la division par 10 est pris, c'est-à-dire que le dernier chiffre du nombre est déterminé. Si ce chiffre est 3, alors le compteur k est incrémenté de 1.

8. Forme générale de l'opérateur de boucle do… while

Il est conseillé d'utiliser la boucle do...while dans les cas où l'itération doit être effectuée au moins une fois. Contrairement aux boucles for et while, dans une boucle do...while, la condition est vérifiée à la sortie de la boucle (pas à l'entrée dans la boucle). La boucle do...while est également appelée boucle de postcondition.

La forme générale de l’instruction de boucle do… while est :

faire( // séquence d'opérateurs// ... ) alors que ( expression );

Où expression– une expression conditionnelle qui vérifie la valeur d'une variable de boucle. A ce stade, la suite de l'exécution du cycle est déterminée.

Les accolades dans cette boucle sont facultatives.

Le cycle fonctionne comme suit. Tout d’abord, le corps de la boucle est exécuté. Ensuite, la valeur est vérifiée expression(expression conditionnelle). Si la valeur expression est vrai (true), le corps de la boucle est à nouveau exécuté. Une fois la valeur expression devient false , l'exécution de la boucle s'arrête

9. Exemples d'utilisation de l'opérateur de boucle do… while

Exemple.À l’aide d’une boucle do… while, trouvez la valeur de la somme :

S = 1 + 3 + … + 99

Un fragment de code qui résout ce problème.

// s = 1 + 3 + ... + 99 int t; int s ; s = 0 ; t = 1 ; faire ( s = s + t; t = t + 2; ) tandis que (t<=99); // s = 2500

10. Boucles imbriquées. Exemples d'utilisation

Les boucles imbriquées peuvent être utilisées, par exemple, lorsque vous travaillez avec des tableaux bidimensionnels (multidimensionnels) (mise à zéro d'un tableau, calcul de sommes, de produits, etc.).

Exemple 1. Calculer le produit

D = 1 · (1 + 2) · (1 + 2 + 3) · … · (1 + 2 + … + 9)

Un fragment de code qui résout ce problème.

// D = 1 * (1+2) * (1+2+3) * ... * (1+2+...+9) flotter d; // le résultat est le produit int je, j; // compteurs de boucles int s ; // variable supplémentaire ré = 1 ; pour (i = 1; je<=9; i++) { s = 0; for (j = 1; j<=i; j++) s = s + j; d = d * s; } // d = 2.571912E+09

Dans cet exemple, dans une boucle for avec un compteur je exécuter une boucle for avec un compteur j .

Exemple 2.Étant donné un tableau bidimensionnel d’entiers de taille 6x9. Écrivez la valeur 5 à tous les éléments du tableau.

entier M ; // tableau bidimensionnel d'entiers int je, j; pour (i=0; je<6; i++) for (j=0; j<9; j++) M[i][j] = 5;

11. Qu'est-ce qu'une boucle sans fin ?

Une boucle infinie est une boucle qui ne finit jamais.

Lors de la programmation de processus cycliques, le programmeur peut écrire par erreur du code de boucle qui ne se termine jamais.

De plus, vous souhaitez parfois que les boucles contiennent un code de terminaison spécial utilisant une instruction break.

Exemple 1. Boucle infinie avec l'instruction for :

pour (; ;) ( // séquence d'opérateurs C++. Déclaration de sélection de commutateur