Pourquoi utiliser une boucle for au lieu d'une boucle while? [dupliquer]

il y a une raison de choisir for plutôt que while : la lisibilité.

en utilisant une boucle for , vous dites expressément que votre intention est d'effectuer un type d'opération qui nécessite une initialisation, une opération" pas", et une condition d'achèvement.

avec while , d'un autre côté, vous dites seulement que vous avez besoin de la condition d'achèvement.

j'utilise 'while' quand je n'ai pas nécessairement besoin d'un compteur, par exemple quand vous lisez à partir d'un fichier et que vous attendez pour atteindre L'EOF. Dans ce cas, 'pour' ne peuvent pas être la meilleure alternative. Lorsque vous parcourez des articles sur un tableau, je préfère utiliser "pour" parce qu'il transmet l'intention mieux.

la seule différence notable entre une boucle for() et while() est qu'une boucle" continue " dans une boucle while() se ramifiera vers le haut de la boucle, tandis qu'une boucle for() se ramifiera vers la troisième partie de la clause for () [celle qui suit la condition, habituellement utilisée pour heurter les variables].

en tant qu'enseignant, j'ai réfléchi à cela sous diverses formes; ma suggestion se résume toujours à

• for -les boucles sont pour compter. comptage, le compte à rebours.
• while / do-while les constructions sont pour toutes les autres conditions. c!=EOF , diff<0.02 , etc. Iterators / Enumerators sont des compteurs très appropriés pour les for-loops.

i.e. votre int=0; while( ... ) est hideux à mes yeux.

Pourquoi choisir Coke plutôt que Pepsi?

entre un certain temps et pour boucle, vous pouvez les utiliser de façon interchangeable. Pour être un puriste, vous pourriez prendre votre décision sur la base de la nature des conditions. Si vous effectuez une boucle basée sur le nombre, alors une boucle FOR aurait le plus de sens.

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

si vous effectuez une boucle basée sur la logique, alors un certain temps ferait l'implémentation la plus propre

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

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

qui dit, for est habituel dans les cycles qui ont un nombre connu d'itérations, tandis que while implique que la condition n'est pas nécessairement corrélée à ce que vous faites à l'intérieur du 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, parce qu'elle localise la maintenance de la boucle en un seul endroit. Quand quelqu'un d'autre arrive et décide d'ajouter/modifier la boucle, s'il utilise une boucle FOR, la personne qui fait la modification peut généralement être sûre que, tant qu'ils ne brouillent pas les éléments à l'intérieur de la boucle FOR expression(s), ils ne vont pas casser l'itération dans la boucle.

cependant, quelque chose comme une boucle while exige que le programmeur analyse le corps de boucle complètement, et comprendre comment il itère, pour s'assurer qu'ils gardent le code de maintenance de boucle non modifié et dans le bon ordre quand ils font des changements.

par conséquent, I seulement utiliser alors que dans les cas où je n'ai effectivement besoin de la partie centrale de la FOR.

ils sont fonctionnellement identiques, mais on peut faire valoir que la boucle for Est moins sujette aux erreurs, parce que 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, et l'indice d'itérateur, vous pouvez oublier, ou d'être surpris par la façon dont il est utilisé. Tout cela est évidemment subjectif.

dans les premiers temps de la programmation une structure de données prédominante était le tableau linéaire (aka vecteur) et un motif de répétition était de parcourir et d'utiliser chaque élément du tableau. Ainsi, le scénario habituel était que les langues incluaient une syntaxe spécifique pour ce motif: la boucle for. En dehors de ce patrimoine historique, vous pourriez utiliser la boucle de tandis tout droit (Eh bien de nos jours avec des langues fonctionnelles Comme F# vous préféreriez utiliser la liste.de carte ou de Liste.fois ;-)

C'est surtout une question de lisibilité. Généralement, utiliser pour les boucles quand vous avez une gamme définie de valeurs pour itérer plus. Utilisez les boucles while lorsque vous n'itérez pas, ou ne savez pas quand votre condition de sortie sera vraie.

D'un point de vue java, je trouve pour les boucles très pratique 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 compiler pour le même résultat final. Je préfère pour ou de pour-chaque la plupart du temps. Ecriture

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

n'est pas si sinistre, mais écrit

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

au lieu de

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

pourrait embrouiller certaines personnes et causer des erreurs.

dans un langage comme Pascal, pour et tandis que les constructions avaient des applications différentes. Vous écririez une boucle pour en Pascal comme suit:

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

ainsi vous déclarez explicitement que je suis incrémenté par 1. Il n'y a pas de condition de résiliation explicitement spécifiée ici. Ainsi, vous pouvez utiliser une boucle for uniquement dans les endroits où vous savez que la boucle sera exécutée pour un certain nombre prédéterminé de fois avant le début de l'exécution de la boucle. D'autre part, vous pouvez spécifiez la résiliation condition dans le cas d'une boucle while.

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

ainsi une boucle de temps est beaucoup plus flexible. Plus tard quand C a été développé, bien que pour et tandis que ont été soutenus, le sens de la construction de for a changé et vous pouvez ajouter des conditions de terminaison explicites en utilisant des opérateurs booléens. Ainsi, le pouvoir de while et for dans les langues de type C et c est le même et devient plus une question de lisibilité qu'une question d'utilisabilité.

en regardant les autres (très bonnes) réponses, il y a un point que je n'ai pas vu se faire. (Si elle ne se fait je l'ai raté et m'en excuse.)

je vais vous donner deux bribes de code apparemment sémantiquement identiques.

Extrait #1:

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

Extrait #2:

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

on dirait qu'Ils font la même chose, non? Maintenant laisse moi ajouter une ligne simple à chaque morceau et voyons ce qui se passe:

Extrait #3:

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

Extrait #4:

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

donc quand je compile un fichier junk avec ces quatre snippets incrustés (plus un peu de colle pour avoir arr.longueur de dire quelque chose), je reçois le message d'erreur suivant:

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

L'utilisation de la boucle for , il s'avère, vous permet de fournir plus de localité à vos variables nominales de compteur, etc. Cela vous donne une plus grande marge de manœuvre dans la réutilisation nom des variables sans risque de collision (mais au détriment de l'augmentation de l'ombre potentielle).

en général, la différence entre une boucle while et pour une boucle est liée à la syntaxe et non à la performance. Cela dit, il semble que cette question ait déjà été abordée pour Java: Java for loop vs. while loop. 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 ya quelques cas tandis que les boucles sont bonnes à utiliser. Appeler une fonction sur un objet qui retourne true / false mais qui itère une valeur à l'intérieur de cet objet.

exemple d'un lecteur de données en C#:

List<string> strings = new List<string>();
while(DataReader.Read())
{
  strings.Add(DataReader["foo"].ToString());
}

a pour boucle vous permet d'encapsuler votre travail dans une fonction, ce qui donne une meilleure mémoire gestion. En outre, s'il y a une erreur dans votre boucle while, elle pourrait se transformer en 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 de la pratique générale. Un peu comme dans la construction. Vous utilisez des clous pour poser des toitures sur les goujons. 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 mal, nous disons simplement " s'il vous plaît, couchez-vous sous la pression de votre pairs afin de garder le codage du monde de fonctionnement".

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 qu'avec les boucles while il n'est pas nécessaire.

certaines langues (comme L'Ada) l'appliquent en faisant du compteur de boucle for une constante à l'intérieur du corps de 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 clair avec la plupart des langues, qui ne traitent pas le compteur de boucle for comme une constante.

il suffit de décider d'un et ensuite copier / coller / ajuster tout au long de vos projets. Moins de décisions, moins de dactylos, un codage plus rapide. Négligeable différence de performances.

aussi Je ne suis pas avec Justin garder i dans le cadre de la boucle, et j'utilise var aL = array.length aussi en dehors de la boucle. Puis utilisez i et aL dans le constructeur de boucle for de sorte que vous ne recalculez pas la longueur du tableau sur chaque coup (avec une création var plus et plus ;)). Nouveau nég. performance really (voir la première partie de ma réponse), à moins que vous ayez de très grands tableaux volant autour. S'il vous arrive de connaître la longueur du tableau à l'avance, lancez-le avec sa longueur fixe d'abord (aide légère avec l'allocation de mémoire sur les navigateurs merdiques ;) si c'est côté client et vous avez beaucoup de données).

js exemple

<script>
var i=0;
var myArray = ["D","R","Y"];//literal style will do for now;)
var aL=myArray.length; //or use 3 if known upfront
for(i;i<aL;i++){/*always do DRY things here*/}
</script>

également s'assurer lorsqu'une condition est remplie, demandez-vous "puis-je encore besoin pour compléter l'ensemble boucle?"Il ne faut pas oublier de sortir de la boucle dès que vous le pouvez.

anecdotes connexes:

dans le nouveau Go langue de Google , ils ont décidé de ne pas inclure le tandis que déclaration. Au lieu de cela, ils vous permettent d'écrire un pour déclaration qui a seulement la clause de condition. Donc l'équivalent de

while (a < b) { ... }

est simplement

for a < b { ... }

il suffit de mettre:

une boucle " for " tend à être utilisée pour une utilisation itérationnelle. Vous devez itérer à travers un tableau, vous avez besoin des numéros 1 à 100 (ou d'autres gammes) pour diverses raisons.

a 'while' tend à être une boucle conditionnelle. Tu veux continuer à faire quelque chose jusqu'à ce qu'une constitution soit fausse. En supposant que vous ayez un cours appelé "Toast" et que vous vouliez faire cuire le toast jusqu'à ce qu'il soit grillé, vous auriez quelque chose comme le suivant:

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

vous pouvez la plupart du temps (Je ne peux pas penser à un exemple où vous ne pouvez pas) écrire un pour boucle en tant que boucle while et une boucle while en tant que pour boucle, mais en choisissant celui qui est le mieux la situation descend habituellement à mes points ci-dessus.

la lisibilité est un point très important, mais il fonctionne dans les deux sens. Je convertirai une boucle for en boucle while-même si j'utilise une contre-variable ou qu'il serait autrement "naturel" d'utiliser pour-quand il est plus lisible de cette façon. C'est courant lorsque vous avez une expression longue ou complexe dans l'une des trois parties de for ou plusieurs compteurs (ce qui est lié au fait d'être complexe).

Knuth la boucle-et-un-moitié fonctionne mieux, dans plusieurs langages, comme une boucle infinie avec une rupture, plutôt qu'une boucle pour.

cependant, il y a 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++;
}

utiliser pour-boucle lorsque 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 dans la déclaration for de sorte que vous n'avez pas à déclarer la variable du compteur ou faire le truc incrément/décrément dans la boucle réelle. Aussi, vous pouvez déclarer le compteur / index local à la déclaration for.

pour 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'itérateur à n'importe quel point, la parallélisation à l'aide d'une API telle que OpenMP est triviale. Bien sûr, si vous entrez dans les pauses, continue, et en changeant l'itérateur manuellement cet avantage disparaît.

parce que ce dernier peut être un liner: while (++i < arr.cents cinquante et une million neuf cent dix mille neuf cent vingt"

une raison est que la condition d'un certain temps peut être une chaîne.

en outre, si nous ajoutons 'Do' au mix, nous pouvons utiliser une boucle do while lorsque nous voulons que l'opération s'exécute au moins une fois quel que soit son état actuel.

C'est juste ma logique que nous utilisons généralement pour boucle quand nous connaissons le nombre exact de nos itérations et nous utilisons une boucle while quand nous voulons généralement vérifier une condition.Puis nous les utilisons selon nos exigences. Sinon, ils montrent le même comportement.

boucle "while", définie comme

while(condition)

représente ce schéma de programmation:

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

alors que a pour boucle, défini 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 construits en langues.

Si vous avez besoin de définir un compteur pour contrôler vos boucles, utilisez une boucle for. Sinon, utilisez un lors de la boucle.