Silmukan aikana - While loop

Image
Silmukan vuokaavio
Silmukkarakenteet

Useimmissa tietokoneohjelmointikielissä while -silmukka on ohjausvirran käsky, joka sallii koodin suorittamisen toistuvasti tietyn Boolen ehdon perusteella. Taas silmukka voidaan ajatella toistuvia jos ilmoitus .

Yleiskatsaus

Kun konstrukti koostuu koodiosion ja kunto / ilme. Ehto/lauseke arvioidaan, ja jos ehto/lauseke on tosi , suoritetaan kaikkien niiden seuraavien lohkon koodi. Tämä toistuu, kunnes ehto/lauseke muuttuu vääräksi . Koska while- silmukka tarkistaa ehdon/lausekkeen ennen lohkon suorittamista, ohjausrakenne tunnetaan usein myös esitestin silmukana . Vertaa tätä tehdä, kun silmukka , joka testaa ehdon / ilmaisun jälkeen silmukka on suoritettu.

Esimerkiksi C-ohjelmointikielellä (samoin kuin Java , C# , Objective-C ja C ++ , jotka käyttävät samaa syntaksia tässä tapauksessa), koodifragmentti 

int x = 0;

while (x < 5) {
    printf ("x = %d\n", x);
    x++;
}

tarkistaa ensin, onko x pienempi kuin 5, mikä on, joten syötetään sitten {silmukan runko}, jossa printf -funktio suoritetaan ja x: tä kasvatetaan 1: llä. x <5), tarkistetaan uudelleen ja silmukka suoritetaan uudelleen, tämä prosessi toistuu, kunnes muuttujan x arvo on 5.

Huomaa, että on mahdollista ja joissakin tapauksissa toivottavaa, että ehto arvioidaan aina totta, jolloin syntyy ääretön silmukka . Kun tällainen silmukka luodaan tarkoituksella, on yleensä toinen ohjausrakenne (kuten taukolauseke ), joka ohjaa silmukan päättämistä. Esimerkiksi: 

while (true) {
    // do complicated stuff
    if (someCondition)
        break;
    // more stuff
}

Osoittaa , kun taas silmukat

Nämä kun silmukat laskevat luvun 5 kertoimen :

ActionScript 3

var counter: int = 5;
var factorial: int = 1;

while (counter > 1) {
    factorial *= counter;
    counter--;
}

Printf("Factorial = %d", factorial);

Ada

with Ada.Integer_Text_IO;

procedure Factorial is
    Counter   : Integer := 5;
    Factorial : Integer := 1;
begin
    while Counter > 0 loop
        Factorial := Factorial * Counter;
        Counter   := Counter - 1;
    end loop;

    Ada.Integer_Text_IO.Put (Factorial);
end Factorial;

AutoHotkey

counter := 5
factorial := 1

While counter > 0
    factorial *= counter--    

MsgBox % factorial

Microsoft Small Basic

counter = 5    ' Counter = 5
factorial = 1  ' initial value of variable "factorial"

While counter > 0
    factorial = factorial * counter
    counter = counter - 1
    TextWindow.WriteLine(counter)
EndWhile

Visual Basic

Dim counter As Integer = 5    ' init variable and set value
Dim factorial As Integer = 1  ' initialize factorial variable

Do While counter > 0
    factorial = factorial * counter
    counter = counter - 1
Loop     ' program goes here, until counter = 0

'Debug.Print factorial         ' Console.WriteLine(factorial) in Visual Basic .NET

Bourne (Unix) -kuori 

counter=5
factorial=1
while [ $counter -gt 0 ]; do
    factorial=$((factorial * counter))
    counter=$((counter - 1))
done

echo $factorial

C tai C ++ 

int main() {
    int counter = 5;
    int factorial = 1;

    while (counter > 1)
        factorial *= counter--;

    printf("%d", factorial);
}

CFML

Skriptin syntaksi

counter = 5;
factorial = 1;
 
while (counter > 1) {
    factorial *= counter--;
}

writeOutput(factorial);

Tagin syntaksi

<cfset counter = 5>
<cfset factorial = 1>
<cfloop condition="counter GT 1">
    <cfset factorial *= counter-->
</cfloop>
<cfoutput>#factorial#</cfoutput>

Fortran

program FactorialProg
    integer :: counter = 5
    integer :: factorial = 1

    do while (counter > 0)
        factorial = factorial * counter
        counter = counter - 1
    end do

    print *, factorial
end program FactorialProg

Mennä

Go: lla ei ole whiile -lauseketta, mutta sillä on for -lause, jos jätät joitakin for -lausekkeen elementtejä pois. 

counter, factorial := 5, 1

for counter > 1 {
	counter, factorial = counter-1, factorial*counter
}

Java , C# , D

Silmukan koodi on sama Java, C# ja D: 

int counter = 5;
int factorial = 1;

while (counter > 1)
    factorial *= counter--;

JavaScript

let counter = 5;
let factorial = 1;

while (counter > 1)
    factorial *= counter--;

console.log(factorial);

Lua

counter = 5
factorial = 1

while counter > 0 do
  factorial = factorial * counter
  counter = counter - 1
end

print(factorial)

MATLAB & GNU Octave 

counter = 5;
factorial = 1;

while (counter > 0)
    factorial = factorial * counter;      %Multiply
    counter = counter - 1;                %Decrement
end

factorial

Mathematica

Block[{counter=5,factorial=1},  (*localize counter and factorial*)
    While[counter>0,            (*While loop*)
        factorial*=counter;     (*Multiply*)
        counter--;              (*Decrement*)
    ];

    factorial
]

Oberon , Oberon-2 (ohjelmointikieli) , Oberon-07 tai Component Pascal 

MODULE Factorial;
IMPORT Out;
VAR
    Counter, Factorial: INTEGER;
BEGIN
    Counter := 5;
    Factorial := 1;

    WHILE Counter > 0 DO
        Factorial := Factorial * Counter;
        DEC(Counter)
    END;
    
    Out.Int(Factorial,0)
END Factorial.

Mayan sulautettu kieli

int $counter = 5;
int $factorial = 1;

int $multiplication;

while ($counter > 0) {
    $multiplication = $factorial * $counter;

    $counter -= 1;
    
    print("Counter is: " + $counter + ", multiplication is: " + $multiplication + "\n");
}

Nim

var
  counter = 5            # Set counter value to 5
  factorial = 1          # Set factorial value to 1

while counter > 0:       # While counter is greater than 0
    factorial *= counter # Set new value of factorial to counter.
    dec counter          # Set the counter to counter - 1.

echo factorial

Keskeytymätön silmukka: 

while true:
  echo "Help! I'm stuck in a loop!"

Pascal

Pascalilla on kaksi while -silmukan muotoa, while ja toista . Vaikka toistaa yhden lauseen (ellei sitä ole sisällytetty alku-loppu-lohkoon) niin kauan kuin ehto on totta. Toistuva lause suorittaa toistuvasti yhden tai useamman lauseen lohkon till -lausekkeen kautta ja jatkaa toistamista, ellei ehto ole epätosi. Suurin ero näiden kahden välillä on, että kun silmukka voi suorittaa nolla kertaa, jos ehto on alun perin epätosi, toistosilmukka suoritetaan aina vähintään kerran. 

program Factorial1;
var
    Fv: integer;

    procedure fact(counter:integer);
    var
        Factorial: integer;

    begin       
         Factorial := 1;
    
         while Counter > 0 do
         begin
             Factorial := Factorial * Counter;
             Counter := Counter - 1
         end;

         WriteLn(Factorial)
     end;

begin
    Write('Enter a number to return its factorial: ');
    readln(fv);
    repeat
         fact(fv);
         Write('Enter another number to return its factorial (or 0 to quit): '); 
     until fv=0;
end.

Perl

my $counter   = 5;
my $factorial = 1;

while ($counter > 0) {
    $factorial *= $counter--; # Multiply, then decrement
}

print $factorial;

Vaikka silmukoita käytetään usein tietojen lukemiseen riviltä riviltä ( $/rivinerottimen määrittelemänä ) avoimista tiedostokahvoista: 

open IN, "<test.txt";

while (<IN>) {
    print;
}

close IN;

PHP

$counter = 5;
$factorial = 1;

while ($counter > 0) {
    $factorial *= $counter--; // Multiply, then decrement.
}

echo $factorial;

PL/I 

declare counter   fixed initial(5);
declare factorial fixed initial(1);

do while(counter > 0)
    factorial = factorial * counter;
    counter = counter - 1;
end;

Python

counter = 5                           # Set the value to 5 
factorial = 1                         # Set the value to 1

while counter > 0:                    # While counter(5) is greater than 0  
    factorial *= counter              # Set new value of factorial to counter.
    counter -= 1                      # Set the counter to counter - 1.

print(factorial)                      # Print the value of factorial.

Keskeytymätön silmukka: 

while True:
    print("Help! I'm stuck in a loop!")

Maila

Racketissa, kuten muissakin Scheme- toteutuksissa, nimeltä-let on suosittu tapa toteuttaa silmukoita: 

#lang racket
(define counter 5)
(define factorial 1)
(let loop ()
    (when (> counter 0)
        (set! factorial (* factorial counter))
        (set! counter (sub1 counter))
        (loop)))
(displayln factorial)

Makrojärjestelmän avulla while -silmukan toteuttaminen on triviaali harjoitus (yleisesti käytetään makrojen käyttöönotossa): 

#lang racket
(define-syntax-rule (while test body ...) ; implements a while loop
    (let loop () (when test body ... (loop))))
(define counter 5)
(define factorial 1)
(while (> counter 0)
    (set! factorial (* factorial counter))
    (set! counter (sub1 counter)))
(displayln factorial)

Huomaa kuitenkin, että välttämätöntä ohjelmointityyliä ei usein suositella Racketissa (kuten kaaviossa).

Rubiini

# Calculate the factorial of 5
i = 1
factorial = 1

while i <= 5
  factorial *= i
  i += 1
end

puts factorial

Ruoste

fn main() {
    let mut counter = 5;
    let mut factorial = 1;

    while counter > 1 {
        factorial *= counter;
        counter -= 1;
    }

    println!("{}", factorial);
}

Rupattelu

Toisin kuin muut kielet, Smalltalkissa while -silmukka ei ole kielikonstruktio, vaan se määritellään luokassa BlockClosuremenetelmäksi, jolla on yksi parametri, runko sulkeutumisena käyttäen ehtoa itse.

Smalltalkilla on myös vastaava whileFalse: -menetelmä. 

| count factorial |
count := 5.
factorial := 1.
[count > 0] whileTrue: 
    [factorial := factorial * count.
    count := count - 1].
Transcript show: factorial

Nopea

var counter = 5                 // Set the initial counter value to 5 
var factorial = 1               // Set the initial factorial value to 1

while counter > 0 {             // While counter(5) is greater than 0  
    factorial *= counter        // Set new value of factorial to factorial x counter.
    counter -= 1                // Set the new value of counter to  counter - 1.
}

print(factorial)                // Print the value of factorial.

Tcl

set counter 5
set factorial 1

while {$counter > 0} {
    set factorial [expr $factorial * $counter] 
    incr counter -1 
}

puts $factorial

VEX

int counter = 5;
int factorial = 1;

while (counter > 1)
    factorial *= counter--;

printf("%d", factorial);

PowerShell

$counter = 5
$factorial = 1

while ($counter) {
    $factorial *= $counter--
}

$factorial

Ohjelmointikieli

Vaikka ohjelmointikieli on yksinkertainen ohjelmointikieli, joka on rakennettu tehtävistä, peräkkäisestä kokoonpanosta, ehdoista ja lausunnoista, joita käytetään pakollisen ohjelmointikielen semantiikan teoreettisessa analyysissä . 

C := 5;
F := 1;

while (C > 1) do
    F := F * C;
    C := C - 1;

Katso myös

Viitteet