Pourquoi utiliser une boucle” while?

Je n'ai jamais compris pourquoi à l'aide d'un faire tout boucles est nécessaire. Je comprends ce qu'ils font, ce Qui est d'exécuter le code de la boucle while contient sans vérifier si la condition est vraie première.

Mais n'est-ce pas le code ci-dessous:

do{
    document.write("ok");
}
while(x == "10");

Exactement le même qu':

document.write("ok");
while(x == "10"){
    document.write("ok");
}

Je suis peut-être très stupide et manquant quelque chose d'évident, mais je ne vois pas l'avantage de l'utilisation de faire tout sur mon exemple ci-dessus.

Dupe de stackoverflow.com/questions/994905/...

OriginalL'auteur Stanni | 2010-06-09

15

Votre exemple de code est faux:
```
do{
    document.write("ok");
}while(x == "10"){
    document.write("ok");
}
```
Ce serait de la forme:
```
do {
    document.write("ok");
} while(x == "10");
```
Vous avez raison qu'il s'exécute à l'intérieur du bloc de code avant la vérification de la condition, mais il n'a pas besoin de dupliquer l'intérieur du bloc de code de la façon dont vous l'avez. Le do/while construire est (comme vous l'avez déjà dit) une façon de s'assurer qu'un morceau de code est exécutée 1 fois ou plus au lieu de 0 ou plusieurs fois (en fonction du conditionnel).

Je vois maintenant, je ne savais pas qu'il vous évite d'avoir à avoir à dupliquer l'intérieur du code. Merci pour l'aide.

OriginalL'auteur inkedmn
16
- Comme vous le voyez, il fallait répéter les même ligne dans le deuxième exemple.
  Lorsque vous maintenir, vous avez probablement voulez que ces deux lignes soient les mêmes, mais vous avez répété-vous.
- Maintenant, Imaginez que c'était une gros bloc et pas une ligne, non seulement elle se inutiles précieux visual espace, mais il sera également plus difficile à maintenir et d'attirer incohérences.
simple, le mettre dans une fonction 😀

OriginalL'auteur bakkal

faire, tout sera exécuté au moins une fois, vous permettant de le faire, alors... où est-ce que tout exige la condition de démarrer..

var i = 6;
do{
    alert(i);
}while( i < 5)

//alerts 6, but while criteria isn't met so it stops

var i = 6;
while( i < 5) {
  alert(i);
}

//no output - while condition wasn't met

OriginalL'auteur Dan Heberden

4

Ce sujet:
```
do{

   //.....
   //100000 lines of code!
   //.....

} while(i%10);
```
Bien sûr, vous ne écrire que:
```
//.....
//100000 lines of code!
//.....

while(i%10){

   //.....
   //100000 lines of code!
   //.....

} 
```
Et vous serez alors obligé d'utiliser un -lors de la boucle

Dieu le Bénisse!!

Edit:

Ou vous utilisez des procédures..

Quelles sont les langues ont-temps, mais pas de procédures?
Vous pourriez probablement mettre les 100 000 lignes de code dans une fonction...mais point de pris.

OriginalL'auteur Betamoo
2

La différence est la plus importante quand vous avez plus d'une seule ligne de code destiné à être exécuté au moins une fois. La simulation d'une boucle avec une boucle while entraînerait substantielle de la duplication de code, ce qui est toujours mauvais. Accordé, une meilleure solution est de refactoriser le code dans une méthode, puis tout simplement avoir le même appel de la méthode avant de, puis dans la boucle, mais beaucoup de gens n'aiment pas les même que la plupart des doubles emplois, et à l'aide de la do mot-clé déclare sans ambiguïté "c'est un pied-contrôlé en boucle".

Donc, en gros, la lisibilité et la base SE principes.

OriginalL'auteur Kilian Foth
2

De son mieux pour l'écriture de code:
```
int count = ReadDataFromStream();
while(count != 0)
{
    count = ReadDataFromStream();
}
```
Peut être écrite à l'aide de le faire-tout comme:
```
int count = 0;
do
{
    count = ReadDataFromStream();
} while(count != 0);
```
Il y a de meilleurs exemples de faire-temps, mais je ne pouvais pas rappeler à ce moment.

OriginalL'auteur A9S6
1

Ce qu'il vous manque, c'est que votre utilisation de do...while ci-dessus est de 100% MAL!

Un do...while boucle en Java, par exemple, ressemble à quelque chose comme ceci:
```
do {
  //something you want to execute at least once
} while (someBooleanCondition);
```
Voir que l'absence totale d'un deuxième bloc? Voir comment le while se termine la déclaration complètement? Donc ce qui arrive maintenant, c'est que le code de la {...} paire entre do et while sera exécuté, puis someBooleanCondition va faire le test et si c'est vrai, le bloc de code sera exécuté de nouveau. Et de nouveau. Et de nouveau. Jusqu'à ce que someBooleanCondition est testé faux.

Et à ce point, peut-être, vous comprendrez pourquoi nous avons à la fois des formes de la boucle. Le code ci-dessus pourrait être traduit:
```
//something you want to execute at least once
while (someBooleanCondition) {
  //something you want to execute at least once
}
```
Ce code, cependant, vous oblige à taper le même (potentiellement vaste et compliqué), code à deux reprises, en laissant la porte ouverte pour plus d'erreurs. D'où la nécessité pour le bas de la boucle de test à la place de l'un de haut de la boucle de test.

OriginalL'auteur JUST MY correct OPINION
1

Tout d'abord votre do..while la syntaxe est incorrecte. Il est comme ça:
```
do
{
  document.write("ok");
}while(x=="10");
```
Il est utile lorsque vous voulez exécuter le corps de la boucle au moins une fois, sans évaluer ses teminating condition. Par exemple, disons que vous voulez écrire une boucle où vous invitant l'utilisateur pour l'entrée et la fonction d'entrée d'exécuter du code. Vous voudriez que cette pour exécuter au moins une fois et ensuite demander à l'utilisateur s'il veut continuer. Dans de tels cas, do..while boucle résultats à moindre et plus propre code par rapport à un while boucle.

OriginalL'auteur Naveen

Bien que

do { 
    s1;
    ...
    sn;
} while (p);

peut être écrite comme

boolean done = false;
while (!done) {
    s1;
    ...
    sn;
    done = !p;
}

le premier est plus compréhensible.

OriginalL'auteur August Karlstrom

Vous devez vous connecter pour publier un commentaire.