Faire la boucle while - Do while loop
| Constructions de boucle |
|---|
Dans la plupart des langages de programmation informatique , une boucle do while est une instruction de flux de contrôle qui exécute un bloc de code au moins une fois, puis exécute à plusieurs reprises le bloc ou arrête de l'exécuter, en fonction d'une condition booléenne donnée à la fin du bloc .
La construction do while se compose d'un symbole de processus et d'une condition. Tout d'abord, le code dans le bloc est exécuté, puis la condition est évaluée. Si la condition est vraie, le code dans le bloc est à nouveau exécuté. Cela se répète jusqu'à ce que la condition devienne fausse . Étant donné que les boucles do while vérifient la condition après l'exécution du bloc, la structure de contrôle est souvent également connue sous le nom de boucle post-test . Contrairement à la boucle while , qui teste la condition avant l'exécution du code dans le bloc, la boucle do-while est une boucle de condition de sortie. Cela signifie que le code doit toujours être exécuté en premier, puis l'expression ou la condition de test est évaluée. Si c'est vrai, le code exécute à nouveau le corps de la boucle. Ce processus est répété tant que l'expression est évaluée à true. Si l'expression est fausse, la boucle se termine et le contrôle passe à l'instruction suivant la boucle do-while. En d'autres termes, alors qu'une boucle while définit la vérité d'une instruction comme condition préalable à l'exécution du code, une boucle do-while prévoit l'exécution continue de l'action sujette à la défaisance par la fausseté de la condition, laquelle fausse ( c'est -à- dire la vérité la négation de la condition) est définie comme condition subséquente .
Il est possible, et dans certains cas souhaitable, que la condition soit toujours évaluée à true, créant une boucle infinie . Lorsqu'une telle boucle est créée intentionnellement, il existe généralement une autre structure de contrôle (telle qu'une instruction break ) qui permet de terminer la boucle.
Certains langages peuvent utiliser une convention de nommage différente pour ce type de boucle. Par exemple, les langages Pascal et Lua ont une boucle " répéter jusqu'à ", qui continue de s'exécuter jusqu'à ce que l'expression de contrôle soit vraie (puis se termine) — alors qu'une boucle " while " s'exécute tant que l'expression de contrôle est vraie (et se termine une fois que le expression devient fausse).
Constructions équivalentes
do {
do_work();
} while (condition);
est équivalent à
do_work();
while (condition) {
do_work();
}
De cette manière, la boucle do ... while enregistre l'"amorçage de boucle" initial avec do_work();sur la ligne avant la whileboucle.
Tant que l' instruction continue n'est pas utilisée, ce qui précède est techniquement équivalent à ce qui suit (bien que ces exemples ne soient pas de style typique ou moderne utilisé dans les ordinateurs de tous les jours) :
while (true) {
do_work();
if (!condition) break;
}
ou alors
LOOPSTART:
do_work();
if (condition) goto LOOPSTART;
Démonstration de boucles do while
Ces exemples de programmes calculent la factorielle de 5 en utilisant la syntaxe de leurs langages respectifs pour une boucle do-while.
ActionScript 3
var counter: int = 5;
var factorial: int = 1;
do {
factorial *= counter--; /* Multiply, then decrement. */
} while (counter > 0);
trace(factorial);
Ada
with Ada.Integer_Text_IO;
procedure Factorial is
Counter : Integer := 5;
Factorial : Integer := 1;
begin
loop
Factorial := Factorial * Counter;
Counter := Counter - 1;
exit when Counter = 0;
end loop;
Ada.Integer_Text_IO.Put (Factorial);
end Factorial;
DE BASE
Les premiers BASIC (tels que GW-BASIC ) utilisaient la syntaxe WHILE/WEND. Les BASIC modernes tels que PowerBASIC fournissent à la fois des structures WHILE/WEND et DO/LOOP, avec une syntaxe telle que DO WHILE/LOOP, DO UNTIL/LOOP, DO/LOOP WHILE, DO/LOOP UNTIL et DO/LOOP (sans tests externes, mais avec une boucle de sortie conditionnelle quelque part à l'intérieur de la boucle). Code source BASIC typique :
Dim factorial As Integer
Dim counter As Integer
factorial = 1
counter = 5
Do
factorial = factorial * counter
counter = counter - 1
Loop While counter > 0
Print factorial
C#
int counter = 5;
int factorial = 1;
do {
factorial *= counter--; /* Multiply, then decrement. */
} while (counter > 0);
System.Console.WriteLine(factorial);
C
int counter = 5;
int factorial = 1;
do {
factorial *= counter--; /* Multiply, then decrement. */
} while (counter > 0);
printf("factorial of 5 is %d\n", factorial);
Les instructions Do-while(0) sont également couramment utilisées dans les macros C comme moyen d'encapsuler plusieurs instructions dans une instruction régulière (par opposition à une instruction composée). Il fait un point-virgule nécessaire après la macro, offrant une apparence plus fonctionnelle pour les analyseurs et les programmeurs simples, tout en évitant le problème de portée avec if. Il est recommandé dans la règle PRE10-C de la
norme de codage CERT C.
C++
int counter = 5;
int factorial = 1;
do {
factorial *= counter--;
} while (counter > 0);
std::cout << "factorial of 5 is "<< factorial << std::endl;
CFScript
factorial = 1;
count = 10;
do {
factorial *= count--;
} while (count > 1);
writeOutput(factorial);
ré
int counter = 5;
int factorial = 1;
do {
factorial *= counter--; // Multiply, then decrement.
} while (counter > 0);
writeln("factorial of 5 is ", factorial);
Fortran
Avec l'ancien FORTRAN 77, il n'y a pas de construction DO-WHILE mais le même effet peut être obtenu avec GOTO :
INTEGER CNT,FACT
CNT=5
FACT=1
1 CONTINUE
FACT=FACT*CNT
CNT=CNT-1
IF (CNT.GT.0) GOTO 1
PRINT*,FACT
END
Fortran 90 et versions ultérieures n'ont pas non plus de construction do-while, mais il a une construction de boucle while qui utilise les mots-clés "do while" et est donc en fait la même que la boucle for .
program FactorialProg
integer :: counter = 5
integer :: factorial = 1
factorial = factorial * counter
counter = counter - 1
do while (counter > 0) ! Truth value is tested before the loop
factorial = factorial * counter
counter = counter - 1
end do
print *, factorial
end program FactorialProg
Java
int counter = 5;
int factorial = 1;
do {
factorial *= counter--; /* Multiply, then decrement. */
} while (counter > 0);
System.out.println("The factorial of 5 is " + factorial);
//============================================//
// The below function does the same as above. //
//============================================//
int counter = 5;
int factorial = 1;
while (counter > 0){
factorial *= counter--; /* Multiply, then decrement. */
}
System.out.println("The factorial of 5 is " + factorial);
JavaScript
let counter = 5; // Declaring two variables, counter and factorial
let factorial = 1;
do {
factorial *= counter--; //What will be looped
} while (counter > 0); //The looping conditions
console.log(factorial); //Showing the result
Kotlin
var counter = 5
var factorial = 1
//These line of code is almost the same as the above JavaScript codes, the only difference is the keyword that shows the results
do {
factorial *= counter--
} while (counter > 0)
println("Factorial of 5 is $factorial")
Pascal
Pascal n'a pas d'action à faire ; au lieu de cela, il a une répétition/jusqu'à. Comme mentionné dans l'introduction, on peut considérer qu'un repeat/until est équivalent à une construction "do code while not expression".
factorial := 1;
counter := 5;
repeat
factorial := factorial * counter;
counter := counter - 1; // In Object Pascal one may use dec (counter);
until counter = 0;
PHP
$counter = 5;
$factorial = 1;
do {
$factorial *= $counter--;
} while ($counter > 0);
echo $factorial;
PL/I
L' instruction PL/I DO subsume les fonctions de la boucle post-test ( do until ), de la boucle pré-test ( do while ) et de la boucle for . Toutes les fonctions peuvent être incluses dans une seule instruction. L'exemple montre uniquement la syntaxe "faire jusqu'à".
declare counter fixed initial(5);
declare factorial fixed initial(1);
do until(counter <= 0);
factorial = factorial * counter;
counter = counter - 1;
end;
put(factorial);
Python
Python n'a pas de construction de contrôle de flux do while spécifique. Cependant, l'équivalent peut être construit à partir d'une boucle while avec une pause.
counter = 5
factorial = 1
while True:
factorial *= counter
counter -= 1
if counter == 0:
break
print(factorial)
Raquette
Dans Racket, comme dans d'autres implémentations de Scheme , un "named-let" est un moyen courant d'implémenter des boucles :
#lang racket
(define counter 5)
(define factorial 1)
(let loop ()
(set! factorial (* factorial counter))
(set! counter (sub1 counter))
(when (> counter 0) (loop)))
(displayln factorial)
Comparez cela avec le premier exemple de boucle while pour Racket. Sachez qu'un let nommé peut également prendre des arguments.
Racket et Scheme fournissent également une boucle do appropriée.
(define (factorial n)
(do ((counter n (- counter 1))
(result 1 (* result counter)))
((= counter 0) result) ; Stop condition and return value.
; The body of the do-loop is empty.
))
Rubis
counter = 10
factorial = 2
begin
factorial *= counter
counter -= 2
end while counter > 1
puts factorial
Petite conversation
| counter factorial |
counter := 5.
factorial := 1.
[counter > 0] whileTrue:
[factorial := factorial * counter.
counter := counter - 1].
Transcript show: factorial printString
Rapide
Swift 2.x et versions ultérieures :
var counter = 5
var factorial = 1
repeat {
factorial *= counter
counter -= 1
} while counter > 0
print(factorial)
Swift 1.x :
var counter = 5
var factorial = 1
do {
factorial *= counter
counter -= 1
} while counter > 0
println(factorial)
Visual Basic .NET
Dim counter As Integer = 5
Dim factorial As Integer = 1
Do
factorial *= counter
counter -= 1
Loop While counter > 0
Console.WriteLine(factorial)
