Pourquoi utiliser une boucle for au lieu d’une boucle while?

Dupliqués possibles:
Itérer avec boucle ou boucle?
Boucles en C – pour () ou while () – quel est le MEILLEUR?

Quand faut-il utiliser une boucle for au lieu d’une boucle while?

Je pense que les boucles suivantes sont identiques, à l’exception de leur syntaxe. Si oui, alors pourquoi choisir l’un sur l’autre?

 int i; for (i = 0; i < arr.length; i++) { // do work } int i = 0; while (i < arr.length) { // do work i++; } 

Dans votre cas, vous ne gagnez pas beaucoup plus qu’une ligne de code de moins dans la boucle for .

Cependant, si vous déclarez la boucle comme ceci:

 for(int i = 0; i < x; i++) 

Vous réussissez à garder i dans le cadre de la boucle, au lieu de le laisser échapper au rest du code.

De plus, dans une boucle while, vous avez la déclaration de variable, la condition et l'incrémentation à 3 endroits différents. Avec le for loop, tout est dans un endroit pratique et facile à lire.

Dernière pensée:
Une note plus importante Il y a une différence sémantique entre les deux. Alors que les boucles, en général, sont censées avoir un nombre indéfini d'itérations. (c'est-à-dire jusqu'à ce que le fichier ait été lu, peu importe le nombre de lignes qu'il contient), et pour les boucles, le nombre d'itérations doit être plus précis. (parcourir tous les éléments d'une collection, que nous pouvons compter en fonction de la taille de la collection.)

Il y a une raison de choisir for plus de while : la lisibilité.

En utilisant une boucle for , vous dites expressément que votre intention est d’effectuer un type d’opération nécessitant une initialisation, une opération «étape» et une condition d’achèvement.

Avec while , d’autre part, vous dites seulement que vous avez besoin de la condition d’achèvement.

J’utilise «while» lorsque je n’ai pas nécessairement besoin d’un compteur, par exemple lorsque vous lisez un fichier et que vous attendez d’atteindre EOF. Dans ce cas, «pour» peut ne pas être la meilleure solution. Lorsque vous parcourez des éléments sur un tableau, je préfère utiliser «for», car cela traduit mieux l’intention.

La différence notable entre une boucle for () et la boucle while () est qu’une instruction “continue” dans une boucle while () sera reliée au sumt de la boucle, alors qu’une boucle dans une boucle for () sera connectée à la troisième partie. de la clause for () [celle après la condition, généralement utilisée pour bump des variables].

En tant que professeur, j’ai réfléchi à cela sous différentes formes et formes. ma suggestion se résume toujours à

  • for boucles sont à compter. compter, compter.
  • while / do-while sont destinées à toutes les autres conditions. c!=EOF , diff<0.02 , etc. Les iterators / énumérateurs sont des compteurs très appropriés pour les boucles for.

c'est à dire votre int=0; while( ... ) int=0; while( ... ) est hideux à mes yeux.

Pourquoi choisir Coke over Pepsi?

Entre une boucle WHILE et FOR, vous pouvez les utiliser indifféremment. Pour être puriste, vous pouvez prendre votre décision en fonction de la nature des conditions. Si vous effectuez une boucle basée sur le nombre, une boucle FOR serait la plus logique.

 for( cur = 0; cur < myList.Length; cur++ ){ doSomething( myList[cur] ); } 

Si vous effectuez une boucle basée sur la logique, un WHILE constitue la solution la plus propre

 Iterator i = myObject.getIterator(); while( i.hasNext() ){ doSomething( i.next() ); } 

Comme vous le dites, les raisons sont sémantiques et esthétiques, plutôt que les performances (leur code compilé a tendance à être très similaire).

Cela dit, for est habituel dans les cycles qui ont un nombre d’itérations connu, tandis while tandis while implique que la condition n’est pas nécessairement corrélée à ce que vous faites dans le cycle, ou que vous ne savez pas au début combien d’itérations Il y aura.

En général, je préfère toujours les boucles, même dans les cas où la boucle n’a rien à voir avec le comptage, car elle localise la maintenance de la boucle dans un seul endroit. Lorsqu’une autre personne arrive et décide d’append / modifier la boucle, si elle utilise une boucle FOR, la personne qui effectue la modification peut généralement être sûre que, tant qu’elle ne joue pas avec les éléments de l’expression FOR. , ils ne vont pas casser l’itération dans la boucle.

Cependant, quelque chose comme une boucle while nécessite que le programmeur parsing complètement le corps de la boucle et comprenne comment il itère, pour s’assurer qu’il garde le code de maintenance de la boucle non modifié et dans le bon ordre lors de ses modifications.

Par conséquent, je n’utilise WHILE que dans les cas où je n’ai besoin que de la partie centrale du FOR.

Ils sont fonctionnellement identiques, cependant, on peut affirmer que la boucle for est moins sujette aux erreurs, car toutes les fonctionnalités de la boucle sont réunies. Si vous avez plusieurs lignes séparant la déclaration de i, la déclaration while et l’iterator d’index, vous pourriez oublier ou être confondu par la façon dont il est utilisé. Tout cela est subjectif bien sûr.

Au début de la programmation, le tableau linéaire (aka vector) était la structure de données la plus répandue et un motif répété devait parcourir et utiliser chaque élément du tableau. Ce scénario était si habituel que les langages incluaient une syntaxe spécifique pour ce modèle: la boucle for. En dehors de cet inheritance historique, vous pouvez utiliser la boucle while (de nos jours avec des langages fonctionnels comme F #, vous préféreriez utiliser List.map ou List.fold 😉

C’est surtout un problème de lisibilité. Généralement, utilisez des boucles for lorsque vous avez une plage de valeurs définie à parcourir. Utilisez des boucles while lorsque vous ne faites pas d’itération ou ne savez pas quand votre condition de sortie sera vraie.

Du sharepoint vue java, je trouve pour les boucles très pratiques pour les collections:

 for (Object o : objects){ o.process(); } 

est beaucoup plus facile à lire que:

 int i=0; while(i < objects.size()){ objects.get(i).process(); i++; } 

Ils vont généralement comstackr au même résultat final. Je préfère pour ou pour la plupart du temps. L’écriture

 for (;x<5;x++){ //do work } 

n'est pas si sinistre, mais écrire

 while(x<5){ x++ //do work } 

au lieu de

 while(x<5){ //do work x++ } 

pourrait confondre certaines personnes et causer des erreurs par un.

Dans un langage comme Pascal, les constructions for et while ont des applications différentes. Vous écrivez une boucle for dans Pascal comme suit:

 for i := 1 to 5 do begin { some code here } end 

Donc, vous déclarez explicitement que i est incrémenté de 1. Aucune condition de terminaison n’est explicitement spécifiée ici. Ainsi, vous pouvez utiliser une boucle for uniquement aux endroits où vous savez que la boucle s’exécutera pendant un certain nombre de fois prédéterminé avant que l’exécution de la boucle ne commence. D’autre part, vous pouvez spécifier une condition de terminaison explicite dans le cas d’une boucle while.

 i:=0; while (i<>5) do begin { some code here } i:=i+1; end 

Ainsi, une boucle while est beaucoup plus flexible. Plus tard, lorsque C a été développé, bien que pour et pendant qu’ils aient été supportés, la signification de la construction a changé et vous pouvez append des conditions de terminaison explicites en utilisant des opérateurs booléens. Ainsi, la puissance du temps et des langages de type C et C est la même, ce qui en fait un problème de lisibilité plutôt qu’un problème de convivialité.

En jetant un coup d’œil aux autres réponses (très bonnes), il y a un point que je n’ai pas vu se faire. (S’il a été fait, je l’ai manqué et je m’excuse.)

Je vais vous donner deux extraits de code apparemment sémantiquement identique.

Extrait n ° 1:

 for (int a = 0; a < arr.length; a++) { /* do some work here */ } 

Extrait n ° 2:

 int b = 0; while (b < arr.length) { // do work b++; } 

Ils ont l'air de faire la même chose, non? Maintenant, laissez-moi append une seule ligne à chaque extrait et voyons ce qui se passe:

Extrait n ° 3:

 for (int c = 0; c < arr.length; c++) { /* do some work here */ } printf("%d\n", c); 

Extrait n ° 4:

 int d = 0; while (d < arr.length) { // do work d++; } printf("%d\n", d); 

Donc, quand je comstack un fichier indésirable avec ces quatre extraits de code intégrés (plus de la colle pour avoir arr.length signifie quelque chose), j'obtiens l'erreur suivante:

 $ clang junk.c junk.c:20:17: error: use of undeclared identifier 'c' printf("%d\n", c); ^ 1 diagnostic generated. 

Il s'avère que l'utilisation de la boucle for vous permet de fournir plus de localités à vos variables de compteur factices, etc. Cela vous donne une plus grande marge de manœuvre pour réutiliser les noms de variables sans risque de collision (au désortingment de l'observation potentielle).

Généralement, la différence entre une boucle while et une boucle for est la syntaxe et non la performance. Cela dit, on dirait que cette question a déjà été traitée pour Java: Java pour la boucle vs la boucle while. Différence de performance?

Lisibilité. Et de l’ancien VB 6 jours de wend chaque fois que je vois un moment je veux pleurer.

Il y a des cas où les boucles sont bonnes à utiliser. Appeler une fonction sur un object qui renvoie true / false mais itère une valeur dans cet object.

Exemple étant un DataReader en C #:

 List ssortingngs = new List(); while(DataReader.Read()) { ssortingngs.Add(DataReader["foo"].ToSsortingng()); } 

Une boucle for permet d’encapsuler votre travail dans une fonction, ce qui permet une meilleure gestion de la mémoire. De plus, si une erreur survient dans votre boucle while, elle pourrait former une boucle hors de contrôle qui menace toute vie:

 bool keepGoing = true; while(keepgoing) { try { //something here that causes exception, fails to set keepGoing = false; keepGoing = false; } catch(Exception) { //Do something, but forget to set keepGoing. //maybe there is always an exception... } } 

Je pense aussi que c’est juste une pratique générale. Tout comme dans la construction. Vous utilisez des clous pour placer des plats de toiture sur les montants. Vous “pourriez” utiliser des vis, ils feraient le même travail, mais ce n’est pas une pratique courante.

Personne ne dit que c’est faux, nous disons simplement “s’il vous plaît pliez-vous sous la pression de vos pairs pour que le monde du codage fonctionne”.

Il y a une différence sémantique entre les boucles for et while . Avec les boucles for , le nombre d’itérations est prédéfini, alors while boucles while ne sont pas nécessaires.

Certains langages (comme Ada) imposent cette règle en faisant du compteur for loop une constante dans le corps de la boucle. Il serait donc illégal de dire, par exemple:

 for i in values'range loop ... i := i + 1; -- this is illegal, as i is a constant within the loop body end if; 

Cette différence sémantique, cependant, n’est pas si claire avec la plupart des langages, qui ne traitent pas le compteur de boucles for comme une constante.

Choisissez-en un, puis copiez et collez / ajustez-le tout au long de vos projets. Moins de décisions, moins de frappe, un codage plus rapide. Différence de performance négligeable.

Je ne suis pas non plus avec Justin dans le cadre de la boucle, ET j’utilise aussi var aL = array.length dehors de la boucle. Ensuite, utilisez i et aL dans le constructeur de la boucle for afin de ne pas recalculer la longueur du tableau à chaque hit (avec une création var encore et encore;)). À nouveau nég. performance vraiment (voir le premier morceau de ma réponse), à ​​moins que vous ayez de très gros tableaux qui volent. Si vous connaissez la longueur du tableau, commencez par l’initialiser avec sa longueur fixe (aide légère à l’allocation de mémoire sur les navigateurs obsolètes;) si c’est le côté client et que vous avez beaucoup de données).

js exemple

  

Assurez-vous également qu'une condition est remplie, demandez-vous "dois-je toujours terminer la boucle?" Sinon, n'oubliez pas de sortir de la boucle le plus tôt possible.

Trivia connexe:

Dans la nouvelle langue de Google, ils ont décidé de ne pas inclure la déclaration while . Au lieu de cela, ils vous permettent d’écrire une instruction for qui ne contient que la clause condition. Donc l’équivalent de

 while (a < b) { ... } 

est simplement

 for a < b { ... } 

Tout simplement:

Une boucle «for» a tendance à être utilisée pour une utilisation itérative. Vous devez parcourir un tableau, vous avez besoin des numéros 1 à 100 (ou d’autres plages) pour diverses raisons.

Une boucle “while” a tendance à être une boucle conditionnelle. Vous voulez continuer à faire quelque chose jusqu’à ce qu’une concurrence soit fausse. En supposant que vous ayez une classe appelée “Toast” et que vous vouliez faire cuire le toast jusqu’à ce qu’il soit grillé, vous obtiendrez quelque chose comme ceci:

while (!toast.isToasted) cook(toast);

Vous pouvez le plus souvent (je ne peux pas penser à un exemple où vous ne pouvez pas) écrire une boucle for comme une boucle while et une boucle while comme une boucle for, mais choisir celle qui convient le mieux à la situation revient généralement à points ci-dessus.

La lisibilité est un point très important, mais cela fonctionne dans les deux sens. Je vais convertir une boucle en une boucle while, même si j’utilise une variable de compteur ou si elle est “naturelle” à utiliser, lorsque cela est plus lisible. Cela est fréquent lorsque vous avez une expression longue ou complexe dans l’une des trois parties ou plusieurs compteurs (ce qui est lié à la complexité).

La boucle et demi de Knuth fonctionne également mieux, dans plusieurs langues, comme une boucle infinie avec une pause, plutôt qu’une boucle for.

Cependant, il existe une différence sémantique très importante:

 for (int i = 0; i < arr.length; i++) { if (filter(arr[i])) continue; use(arr[i]); } int i = 0; while (i < arr.length) { if (filter(arr[i])) continue; use(arr[i]); i++; } 

Utilisez for-loop quand c’est approprié. La solution while a des inconvénients syntaxiques (c’est plus long) et vous devez vérifier que vous incrémentez i avant tout appel continu dans la boucle.

Préférence. Pour moi, toute la logique de bouclage est intégrée à l’instruction for, vous n’avez donc pas à déclarer la variable du compteur ou à faire les incrémentations / décrémentations dans la boucle réelle. En outre, vous pouvez déclarer le compteur / index local à l’instruction for.

Car les boucles sont souvent plus faciles à paralléliser. Puisque le programme peut indiquer à l’avance le nombre d’itérations qui seront effectuées et la valeur de l’iterator à tout moment, la parallélisation utilisant une API telle qu’OpenMP est sortingviale. Bien sûr, si vous commencez à faire des pauses, continuez et changez l’iterator manuellement, cet avantage disparaît.

parce que ce dernier peut être un liner: while (++ i

L’une des raisons est que la condition d’un temps peut être une chaîne.

De plus, si nous ajoutons «Do» au mixage, nous pouvons utiliser une boucle do while lorsque nous voulons que l’opération soit exécutée au moins une fois, quel que soit son état actuel.

C’est juste ma logique que nous utilisons généralement pour la boucle lorsque nous connaissons le nombre exact de nos itérations et que nous utilisons une boucle while lorsque nous voulons généralement vérifier une condition. Nous les utilisons ensuite selon vos besoins. Sinon, ils montrent tous les deux le même comportement.

Une boucle while définie comme

 while(condition) 

représente ce modèle de programmation:

 1: if(!condition) goto 2; ... goto 1; 2: 

Considérant qu’une boucle for, définie comme

 for(var i = seed; condition; operation) 

représente ce modèle:

 var i = seed 1: if(!condition) goto 2; ... operation; goto 1; 2: 

Les deux modèles sont si couramment utilisés qu’ils ont été nommés et intégrés dans les langues.

Si vous devez définir un compteur pour contrôler votre boucle, utilisez une boucle for. Sinon, utilisez une boucle while.