Pentru bucla - For loop

Pentru diagrama fluxului de buclă

În informatică , un for-loop (sau pur și simplu pentru loop ) este o instrucțiune de flux de control pentru specificarea iterației , care permite executarea repetată a codului . Diverse cuvinte cheie sunt folosite pentru a specifica această afirmație: descendenții ALGOL folosesc „pentru”, în timp ce descendenții lui Fortran folosesc „face”. Există și alte posibilități, de exemplu COBOL care folosește „PERFORM VARING”.

O buclă for are două părți: un antet care specifică iterația și un corp care se execută o dată pe iterație. Antetul declară adesea un contor de buclă explicit sau o variabilă de buclă, care permite corpului să știe ce iterație se execută. For-buclele sunt de obicei utilizate atunci când numărul de iterații este cunoscut înainte de a intra în buclă. For-buclele pot fi considerate ca abrevieri pentru buclele while care incrementează și testează o variabilă de buclă.

Numele pentru buclă provine din cuvântul pentru , care este folosit ca cuvânt cheie în multe limbaje de programare pentru a introduce o buclă pentru. Termenul în limba engleză datează din ALGOL 58 și a fost popularizat în influența ulterioară ALGOL 60 ; este traducerea directă a für-ului german anterior , folosită în Superplan (1949–1951) de Heinz Rutishauser , care a fost implicat și în definirea ALGOL 58 și ALGOL 60. Corpul buclei este executat „pentru” valorile date ale variabilei buclei , deși acest lucru este mai explicit în versiunea ALGOL a declarației, în care poate fi specificată o listă de valori posibile și / sau incremente.

În FORTRAN și PL / I , cuvântul cheie DO este folosit pentru același lucru și se numește do-loop ; acest lucru este diferit de o buclă do-while .

PENTRU

Pentru ilustrarea buclei, de la i = 0 la i = 2, rezultând date1 = 200

O declarație pentru buclă este disponibilă în majoritatea limbajelor de programare imperative . Chiar și ignorând diferențe minore de sintaxă, există multe diferențe în modul în care funcționează aceste afirmații și nivelul de expresivitate pe care îl susțin. În general, buclele for se încadrează în una dintre următoarele categorii:

Bucle tradiționale

Bucla pentru limbaje precum ALGOL , Simula , BASIC , Pascal , Modula , Oberon , Ada , Matlab , Ocaml , F # și așa mai departe, necesită o variabilă de control cu valori inițiale și finale și arată așa:

for i = first to last do statement
(* or just *)
for i = first..last do statement

În funcție de limbă, un semn de atribuire explicit poate fi utilizat în locul semnului egal (iar unele limbi necesită cuvântul intchiar și în cazul numeric). Poate fi inclusă, de asemenea, o valoare pas pas opțională (o creștere sau scădere ≠ 1), deși sintaxele exacte utilizate pentru aceasta diferă puțin mai mult între limbi. Unele limbi necesită o declarație separată a variabilei de control, altele nu.

O altă formă a fost popularizat de limbajul de programare C . Necesită 3 părți: inițializarea ( varianta buclei ), condiția și avansarea la următoarea iterație. Toate aceste trei părți sunt opționale. Acest tip de „puncte punct și virgulă” provine din limbajul de programare B și a fost inițial inventat de Stephen Johnson .

În partea de inițializare, toate variabilele necesare sunt declarate (și de obicei atribuite valorile). Dacă sunt declarate mai multe variabile, toate acestea ar trebui să fie de același tip. Partea de condiție verifică o anumită condiție și iese din buclă dacă este falsă. Avansarea către următoarea parte de iterație se realizează exact o dată de fiecare dată când se termină bucla. Bucla este apoi repetată dacă condiția se evaluează la adevărat.

Iată un exemplu de buclă tradițională în stil C în Java .

// Prints the numbers from 0 to 99 (and not 100), each followed by a space. 

for (int i=0; i<100; i++)  
{
    System.out.print(i);
    System.out.print(' ');
}
System.out.println();

Aceste bucle sunt, de asemenea, numite uneori numere pentru bucle numerice atunci când sunt contrastate cu bucle foreach (vezi mai jos).

Bucle pentru iteratoare

Acest tip de buclă for este o generalizare a tipului de interval numeric de buclă for, deoarece permite enumerarea seturilor de elemente, altele decât secvențele numerice. De obicei, se caracterizează prin utilizarea unui iterator implicit sau explicit , în care variabila buclă preia fiecare dintre valorile dintr-o secvență sau altă colectare de date. Un exemplu reprezentativ în Python este:

for item in some_iterable_object:
    do_something()
    do_something_else()

Unde some_iterable_objecteste fie o colecție de date care acceptă iterația implicită (cum ar fi o listă cu numele angajaților), fie poate fi de fapt un iterator în sine. Unele limbi au acest lucru în plus față de o altă sintaxă pentru buclă; în special, PHP are acest tip de buclă sub nume for each, precum și o buclă pentru trei expresii pentru buclă (a se vedea mai jos) sub nume for.

Bucle vectorizate pentru

Unele limbi oferă o buclă for care acționează ca și cum ar procesa toate iterațiile în paralel , cum ar fi for allcuvântul cheie din FORTRAN 95, care are interpretarea că toate expresiile din partea dreaptă sunt evaluate înainte de efectuarea oricărei atribuții, distinct de iterația explicită formă. De exemplu, în fordeclarația din următorul fragment de pseudocod, atunci când se calculează noua valoare pentru A(i), cu excepția primei (cu i = 2) referința la A(i - 1)va obține noua valoare care a fost plasată acolo în pasul anterior. Cu for alltoate acestea, în versiune, fiecare calcul se referă doar la original, nealterat A.

for     i := 2 : N - 1 do A(i) := [A(i - 1) + A(i) + A(i + 1)] / 3; next i;
for all i := 2 : N - 1 do A(i) := [A(i - 1) + A(i) + A(i + 1)] / 3;

Diferența poate fi semnificativă.

Unele limbi (cum ar fi FORTRAN 95, PL / I) oferă, de asemenea, instrucțiuni de atribuire de matrice, care permit omiterea multor bucle for. Astfel, pseudocodul care A := 0;ar seta toate elementele matricei A la zero, indiferent de mărimea sau dimensionalitatea sa. Bucla de exemplu ar putea fi redată ca

 A(2 : N - 1) := [A(1 : N - 2) + A(2 : N - 1) + A(3 : N)] / 3;

Dar dacă acest lucru ar fi redat în stilul pentru buclă pentru sau pentru buclă pentru toate sau altceva poate să nu fie descris clar în manualul compilatorului.

Compuse pentru bucle

Introdus cu ALGOL 68 și urmat de PL / I , acest lucru permite iterația unei bucle să fie combinată cu un test, ca în

for i := 1 : N while A(i) > 0 do etc.

Adică, o valoare este atribuită variabilei de buclă i și numai dacă expresia while este adevărată , corpul buclei va fi executat. Dacă rezultatul a fost fals , execuția for-loop se oprește scurt. Acordat că valoarea variabilei de buclă este definită după terminarea buclei, atunci afirmația de mai sus va găsi primul element nepozitiv din matricea A (și dacă nu există astfel, valoarea sa va fi N + 1 ) sau, cu variații adecvate , primul caracter ne-gol dintr-un șir și așa mai departe.

Contoare de bucle

În programarea computerului, un contor de buclă este variabila care controlează iterațiile unei bucle (o construcție de limbaj de programare pentru computer ). Se numește așa deoarece majoritatea utilizărilor acestui construct au ca rezultat variabila luând un interval de valori întregi în unele secvențe ordonate (de exemplu, începând cu 0 și terminând cu 10 în trepte de 1)

Contoare de bucle se schimbă cu fiecare iterație a unei bucle, oferind o valoare unică pentru fiecare iterație individuală. Contorul de buclă este utilizat pentru a decide când bucla ar trebui să se încheie și pentru ca fluxul de programe să continue la următoarea instrucțiune după buclă.

O convenție comună de denumire a identificatorului este ca contorul de buclă să utilizeze numele variabilelor i , j și k (și așa mai departe dacă este necesar), unde i- ar fi cea mai exterioară buclă, j următoarea buclă interioară etc. Ordinea inversă este folosit și de unii programatori. Acest stil este, în general, de acord să aibă originea din programarea timpurie a FORTRAN , unde aceste nume de variabile care încep cu aceste litere au fost declarate implicit ca având un tip întreg, la fel și alegerile evidente pentru contoare de bucle care erau necesare doar temporar. Datele de practică susține și în continuare a notație matematice în cazul în care indicii pentru sume și înmulțiri sunt de multe ori i , j , etc. O variantă convenție este utilizarea literelor reduplicată pentru indicele, ii , jj , și kk , deoarece acest lucru permite căutarea mai ușoară și Search - înlocuind decât folosind o singură literă.

Exemplu

Un exemplu de cod C care implică imbricate pentru bucle, unde variabilele contorului de buclă sunt i și j :

for (i = 0; i < 100; i++) {
    for (j = i; j < 10; j++) {
        some_function(i, j);
    }
}

S-a arătat că o buclă imbricată, ca în exemplul de mai sus, efectuează mai multe calcule pe unitate de timp decât o buclă fără ea. Această optimizare independentă de mașină înseamnă că bucla imbricată va termina mai repede, având în vedere același număr de calcule de efectuat. Acesta este un avantaj imbricat pentru buclă peste buclă imbricată while, care se comportă diferit.

Pentru buclele din C pot fi utilizate și pentru a imprima reversul unui cuvânt. La fel de:

for (i = 0; i < 6; i++) {
    scanf("%c", &a[i]);
}
for (i = 4; i >= 0; i--) {
    printf("%c", a[i]);
}

Aici, dacă intrarea este apple, ieșirea va fi elppa.

Semantică și constructe suplimentare

Folosiți ca bucle infinite

Această buclă în stil C este de obicei sursa unei bucle infinite, deoarece pașii fundamentali ai iterației sunt complet în controlul programatorului. De fapt, atunci când sunt intenționate bucle infinite, acest tip de buclă for poate fi utilizat (cu expresii goale), cum ar fi:

for (;;)
    //loop body

Acest stil este folosit în loc de while (1)bucle infinite pentru a evita o avertizare de conversie de tip în unele compilatoare C / C ++. Unii programatori preferă forma mai succintă for (;;)decât cea semantic echivalentă, dar mai detaliată while (true).

Ieșirea timpurie și continuarea

Unele limbi pot furniza, de asemenea, alte declarații de susținere, care, atunci când sunt prezente, pot modifica modul în care se desfășoară iterația pentru buclă. Cele mai frecvente dintre acestea sunt declarațiile de pauză și continuare găsite în C și derivatele sale. Instrucțiunea break face ca bucla cea mai internă să fie terminată imediat când este executată. Instrucțiunea continue se va muta imediat la următoarea iterație fără a mai progresa prin corpul buclei pentru iterația curentă. O instrucțiune for se termină, de asemenea, atunci când se execută o instrucțiune break, go sau return în cadrul instrucțiunii. [Wells] Alte limbi pot avea afirmații similare sau pot furniza în alt mod mijloace pentru a modifica progresul pentru buclă; de exemplu în FORTRAN 95:

DO I = 1, N
  statements               !Executed for all values of "I", up to a disaster if any.
  IF (no good) CYCLE       !Skip this value of "I", continue with the next.
  statements               !Executed only where goodness prevails.
  IF (disaster) EXIT       !Abandon the loop.
  statements               !While good and, no disaster.
END DO                     !Should align with the "DO".

Unele limbi oferă facilități suplimentare, cum ar fi denumirea diferitelor instrucțiuni de buclă, astfel încât, cu mai multe bucle imbricate, nu există nicio îndoială cu privire la ce buclă este implicată. Fortran 95, de exemplu:

X1:DO I = 1,N
     statements
  X2:DO J = 1,M
       statements
       IF (trouble) CYCLE X1
       statements
     END DO X2
     statements
   END DO X1

Astfel, atunci când se detectează „probleme” în bucla interioară, CICLUL X1 (nu X2) înseamnă că săritura va fi la următoarea iterație pentru I, nu J. Compilatorul va verifica, de asemenea, dacă fiecare END DO are eticheta corespunzătoare. pentru poziția sa: acesta nu este doar un ajutor pentru documentare. Programatorul trebuie să codeze în continuare problema corect, dar unele gafe posibile vor fi blocate.

Domeniu variabil de buclă și semantică

Diferite limbi specifică reguli diferite pentru ce valoare va deține variabila buclă la terminarea buclei sale și, într-adevăr, unele consideră că „devine nedefinită”. Acest lucru permite unui compilator să genereze cod care lasă orice valoare în variabila buclă, sau poate chiar o lasă neschimbată deoarece valoarea buclei a fost păstrată într-un registru și niciodată stocată în memorie. Comportamentul real poate varia chiar și în funcție de setările de optimizare ale compilatorului, ca și în cazul compilatorului Honywell Fortran66.

În unele limbi (nu C sau C ++ ) variabila buclă este imuabilă în sfera corpului buclei, orice încercare de modificare a acesteia fiind considerată o eroare semantică. Astfel de modificări sunt uneori o consecință a unei erori de programare, care poate fi foarte dificil de identificat odată făcute. Cu toate acestea, este posibil ca numai modificările evidente să fie detectate de compilator. Situațiile în care adresa variabilei de buclă este transmisă ca argument către un subrutină fac foarte dificilă verificarea, deoarece comportamentul rutinei este în general necunoscut compilatorului. Câteva exemple în stilul lui Fortran:

DO I = 1, N
  I = 7                           !Overt adjustment of the loop variable. Compiler complaint likely.
  Z = ADJUST(I)                   !Function "ADJUST" might alter "I", to uncertain effect.
  normal statements               !Memory might fade that "I" is the loop variable.
  PRINT (A(I), B(I), I = 1, N, 2) !Implicit for-loop to print odd elements of arrays A and B, reusing "I"...
  PRINT I                         !What value will be presented?
END DO                            !How many times will the loop be executed?

O abordare obișnuită este calcularea numărului de iterații la începutul unei bucle (cu o atenție atentă la deversare ca în for i := 0 : 65535 do ... ;aritmetica întreagă de șaisprezece biți) și cu fiecare iterație decrementează acest număr, ajustând în același timp și valoarea lui I : rezultate de numărare dublă. Cu toate acestea, ajustările valorii lui I în buclă nu vor schimba numărul de iterații executate.

O altă posibilitate este că codul generat poate utiliza o variabilă auxiliară ca variabilă de buclă, posibil deținută într-un registru al mașinii, a cărei valoare poate sau nu să fie copiată la I pe fiecare iterație. Din nou, modificările lui I nu ar afecta controlul buclei, dar acum este posibilă o disjuncție: în cadrul buclei, referințele la valoarea lui I ar putea fi la valoarea curentă (posibil modificată) a lui I sau la variabila auxiliară (deținută în condiții de siguranță împotriva modificărilor necorespunzătoare) și rezultatele confuze sunt garantate. De exemplu, în cadrul buclei o referință la elementul I al unui tablou ar folosi probabil variabila auxiliară (mai ales dacă ar fi păstrată într-un registru al mașinii), dar dacă I este un parametru pentru o rutină (de exemplu, o declarație de tipărire la dezvăluie valoarea acestuia), ar fi probabil o referință la variabila corectă I în schimb. Cel mai bine este să evitați astfel de posibilități.

Ajustarea limitelor

La fel cum variabila index ar putea fi modificată într-o buclă for, tot așa pot fi limitele și direcția acesteia. Dar cu efect incert. Un compilator poate preveni astfel de încercări, este posibil să nu aibă niciun efect sau chiar ar putea funcționa corect - deși mulți ar declara că acest lucru ar fi greșit. Luați în considerare o afirmație precum

for i := first : last : step do
  A(i) := A(i) / A(last);

Dacă abordarea compilării unei astfel de bucle urma să fie evaluarea primului , ultimului și pasului și calcularea unui număr de iterații printr- (last - first)/stepo singură dată la început, atunci dacă acele elemente erau variabile simple și valorile lor au fost cumva ajustate în timpul iterații, acest lucru nu ar avea niciun efect asupra numărului de iterații, chiar dacă elementul selectat pentru divizare prin A(last)modificat.

Lista intervalelor de valori

PL / I și Algol 68, permit bucle în care variabila de buclă este iterată pe o listă de intervale de valori în loc de un singur interval. Următorul exemplu PL / I va executa bucla cu șase valori de i: 1, 7, 12, 13, 14, 15:

do i = 1, 7, 12 to 15;
  /*statements*/
end;

Echivalența cu buclele de timp

O buclă for este în general echivalentă cu o buclă while:

factorial := 1
 for counter from 2 to 5
     factorial := factorial * counter
counter := counter - 1
print counter + "! equals " + factorial

este echivalent cu:

factorial := 1
counter := 1
 while counter < 5
    counter := counter + 1
    factorial := factorial * counter
print counter + "! equals " + factorial

după cum demonstrează rezultatul variabilelor.

Cronologia sintaxei for-loop în diferite limbaje de programare

Având în vedere o acțiune care trebuie repetată, de exemplu, de cinci ori, diferite bucle pentru limbi diferite vor fi scrise diferit. Sintaxa pentru o buclă pentru trei expresii este aproape identică în toate limbile care o au, după ce se iau în calcul diferite stiluri de terminare a blocului și așa mai departe.

1957: FORTRAN

Echivalentul Fortran al buclei for este bucla DO , folosind cuvântul cheie do în loc de for, Sintaxa buclei DO a lui Fortran este:

        DO label counter = first, last, step
          statements
label     statement

Următoarele două exemple se comportă echivalent cu cele trei argumente pentru buclă în alte limbi, inițializând variabila contorului la 1, incrementând cu 1 fiecare iterație a buclei și oprindu-se la cinci (inclusiv).

        DO 9, COUNTER = 1, 5, 1
          WRITE (6,8) COUNTER
    8     FORMAT( I2 )
    9   CONTINUE

În Fortran 77 (sau mai târziu), acest lucru poate fi scris și ca:

do counter = 1, 5
  write(*, '(i2)') counter
end do

Partea pasului poate fi omisă dacă pasul este unul. Exemplu:

* DO loop example.
       PROGRAM MAIN
         SUM SQ = 0
         DO 199 I = 1, 9999999
           IF (SUM SQ.GT.1000) GO TO 200
199        SUM SQ = SUM SQ + I**2
200      PRINT 206, SUMSQ
206      FORMAT( I2 )
       END

Spațiile sunt irelevante în instrucțiunile Fortran de formă fixă, astfel SUM SQ este același cu SUMSQ . În stilul modern Fortran în formă liberă, semifabricatele sunt semnificative.

În Fortran 90, GO TO poate fi evitat prin utilizarea unei declarații EXIT .

* DO loop example.
       program main
         implicit none

         integer :: sumsq
         integer :: i

         sumsq = 0
         do i = 1, 9999999
           if (sumsq > 1000.0) exit
           sumsq = sumsq + i**2
          end do
         print *, sumsq

       end program

1958: ALGOL

ALGOL 58 a introdus fordeclarația, folosind formularul ca Superplan:

 FOR Identifier = Base (Difference) Limit

De exemplu, pentru a imprima 0-10 crescute cu 1:

FOR x = 0 (1) 10 BEGIN
PRINT (FL) = x END

1960: COBOL

COBOL a fost oficializat la sfârșitul anului 1959 și a avut multe elaborări. Folosește verbul PERFORM, care are multe opțiuni. Inițial, toate buclele trebuiau să fie în afara liniei, codul iterat ocupând un paragraf separat. Ignorând necesitatea declarării și inițializării variabilelor, echivalentul COBOL al unui for -loop ar fi.

      PERFORM SQ-ROUTINE VARYING I FROM 1 BY 1 UNTIL I > 1000

      SQ-ROUTINE
             ADD I**2 TO SUM-SQ.

În anii 1980, adăugarea de bucle în linie și declarații „structurate”, cum ar fi END-PERFORM, a dus la un buclă for -cu o structură mai familiară.

      PERFORM VARYING I FROM 1 BY 1 UNTIL I > 1000
             ADD I**2 TO SUM-SQ.
      END-PERFORM

Dacă verbul PERFORM are clauza opțională TEST DUPĂ, bucla rezultată este ușor diferită: corpul buclei este executat cel puțin o dată, înainte de orice test.

1964: BAZIC

Buclele din BASIC sunt uneori numite bucle următoare.

10 REM THIS FOR LOOP PRINTS ODD NUMBERS FROM 1 TO 15
20 FOR I = 1 TO 15 STEP 2
30 PRINT I
40 NEXT I

Observați că marcatorul de buclă de sfârșit specifică numele variabilei index, care trebuie să corespundă cu numele variabilei index la începutul buclei for. Unele limbi (PL / I, FORTRAN 95 și versiunile ulterioare) permit o etichetă de declarație la începutul unei bucle for care poate fi asortată de compilator cu același text pe instrucțiunea de buclă finală corespunzătoare. Fortran permite, de asemenea, EXITși CYCLEdeclarațiilor să denumească acest text; într-un cuib de bucle, acest lucru arată clar care buclă este destinată. Cu toate acestea, în aceste limbi etichetele trebuie să fie unice, deci buclele succesive care implică aceeași variabilă index nu pot utiliza același text și nici o etichetă nu poate fi aceeași cu numele unei variabile, cum ar fi variabila index pentru buclă.

1964: PL / I

do counter = 1 to 5 by 1; /* "by 1" is the default if not specified */
  /*statements*/;
  end;

Instrucțiunea LEAVE poate fi utilizată pentru a ieși din buclă. Buclele pot fi etichetate, iar lăsarea poate lăsa o buclă specifică etichetată într-un grup de bucle imbricate. Unele dialecte PL / I includ instrucțiunea ITERATE pentru a termina iterația curentă a buclei și a începe următoarea.

1968: Algol 68

Algol 68 a ceea ce a fost considerat bucla universală, sintaxa completă este:

FOR i FROM 1 BY 2 TO 3 WHILE i≠4 DO ~ OD

Mai mult, intervalul de iterație unică ar putea fi înlocuit cu o listă de astfel de intervale. Există mai multe aspecte neobișnuite ale construcției

numai do ~ odporțiunea a fost obligatorie, caz în care bucla va itera la nesfârșit.
astfel clauza to 100 do ~ odva itera exact de 100 de ori.
while elementul sintactică a permis un programator pentru a rupe dintr - o forbuclă mai devreme, la fel ca în:

INT sum sq := 0;
FOR i
 WHILE
  print(("So far:", i, new line)); # Interposed for tracing purposes. #
  sum sq ≠ 70↑2                    # This is the test for the WHILE   #
DO
  sum sq +:= i↑2
OD

Extensiile ulterioare la standardul Algol68 au permis ca toelementul sintactic să fie înlocuit cu uptoși downtosă realizeze o optimizare mică. Aceiași compilatori au încorporat, de asemenea:

until: pentru terminarea buclei târzii.
foreach: pentru lucrul la matrice în paralel .

1970: Pascal

for Counter := 1 to 5 do
  (*statement*);

Decrementarea (numărarea înapoi) folosește downtocuvânt cheie în loc de to, ca în:

for Counter := 5 downto 1 do
  (*statement*);

Intervalul numeric pentru buclă variază ceva mai mult.

1972: C / C ++

for (initialization; condition; increment/decrement)
    statement

Declarația este de multe ori o declarație de bloc; un exemplu în acest sens ar fi:

//Using for-loops to add numbers 1 - 5
int sum = 0;
for (int i = 1; i < 6; ++i) {
    sum += i;
}

Publicația ISO / IEC 9899: 1999 (cunoscută sub numele de C99 ) permite, de asemenea, declarații inițiale în forbucle. Toate cele trei secțiuni din bucla for sunt opționale.

1972: Smalltalk

1 to: 5 do: [ :counter | "statements" ]

Spre deosebire de alte limbi, în Smalltalk o buclă for nu este o construcție de limbaj, ci este definită în clasa Număr ca metodă cu doi parametri, valoarea finală și o închidere , folosind auto ca valoare de pornire.

1980: Ada

for Counter in 1 .. 5 loop
   -- statements
end loop;

Instrucțiunea exit poate fi utilizată pentru a ieși din buclă. Buclele pot fi etichetate, iar ieșirea poate lăsa o buclă specificată într-un grup de bucle imbricate:

Counting:
    for Counter in 1 .. 5 loop
   Triangle:
       for Secondary_Index in 2 .. Counter loop
          -- statements
          exit Counting;
          -- statements
       end loop Triangle;
    end loop Counting;

1980: Arțar

Maple are două forme de buclă, una pentru iterarea unei game de valori, iar cealaltă pentru iterarea asupra conținutului unui container. Formularul intervalului de valori este după cum urmează:

for i from f by b to t while w do
    # loop body
od;

Toate piesele, cu excepția doși odsunt opționale. Parte, dacă este prezent, trebuie să vină mai întâi. Piesele rămase ( , , , ) pot apărea în orice ordine. for ifrom fby bto twhile w

Iterarea peste un container se face folosind această formă de buclă:

for e in c while w do
    # loop body
od;

Clauza specifică containerului, care poate fi o listă, set, sumă, produs, funcția neevaluate, matrice, sau un obiect de punere în aplicare un iterator. in c

O buclă pentru poate înceta od, endsau end do.

1982: Maxima CAS

În Maxima CAS se pot utiliza și valori care nu sunt întregi:

for x:0.5 step 0.1 thru 0.9 do
    /* "Do something with x" */

1982: PostScript

Bucla for, scrisă ca [initial] [increment] [limit] { ... } forinițializează o variabilă internă, execută corpul atâta timp cât variabila internă nu depășește limita (sau nu mai mică, dacă incrementul este negativ) și, la sfârșitul fiecărei iterații, mărește variabila internă. Înainte de fiecare iterație, valoarea variabilei interne este împinsă pe stivă.

1 1 6 {STATEMENTS} for

Există, de asemenea, o repetare simplă. Bucla de repetare, scrisă ca X { ... } repeat, repetă corpul exact de X ori.

5 { STATEMENTS } repeat

1983: Ada 83 și mai sus

procedure Main is
  Sum_Sq : Integer := 0;
begin
  for I in 1 .. 9999999 loop 
    if Sum_Sq <= 1000 then
      Sum_Sq := Sum_Sq + I**2
    end if;
  end loop;
end;

1984: MATLAB

for n = 1:5 
     -- statements
end

După buclă, nar fi 5 în acest exemplu.

Așa cum ise folosește pentru unitatea imaginară , este descurajată utilizarea acesteia ca variabilă de buclă.

1987: Perl

for ($counter = 1; $counter <= 5; $counter++) { # implicitly or predefined variable
    # statements;
}
for (my $counter = 1; $counter <= 5; $counter++) { # variable private to the loop
    # statements;
}
for (1..5) { # variable implicitly called $_; 1..5 creates a list of these 5 elements
    # statements;
}
statement for 1..5; # almost same (only 1 statement) with natural language order
for my $counter (1..5) { # variable private to the loop
    # statements;
}

(Rețineți că „ există mai multe modalități de a face acest lucru ” este un motto de programare Perl.)

1988: Mathematica

Construcția corespunzătoare buclei for a celor mai multe limbi se numește Do în Mathematica

Do[f[x], {x, 0, 1, 0.1}]

Mathematica are, de asemenea, o construcție For care imită bucla for a limbajelor asemănătoare cu C

For[x= 0 , x <= 1, x += 0.1,
    f[x]
]

1989: Bash

# first form
for i in 1 2 3 4 5
do
    # must have at least one command in loop
    echo $i  # just print value of i
done

# second form
for (( i = 1; i <= 5; i++ ))
do
    # must have at least one command in loop
    echo $i  # just print value of i
done

Rețineți că o buclă goală (adică una fără comenzi între doși done) este o eroare de sintaxă. Dacă buclele de mai sus conțin doar comentarii, executarea ar duce la mesajul „eroare de sintaxă lângă simbolul neașteptat„ făcut ””.

1990: Haskell

Imperativul încorporat forM_ mapează o expresie monadică într-o listă, ca

forM_ [1..5] $ \indx -> do statements

sau obțineți fiecare rezultat de iterație ca listă în

statements_result_list <- forM [1..5] $ \indx -> do statements

Dar, dacă doriți să salvați spațiul listei [1..5], o construcție monadică mai autentică pentru Loop_ poate fi definită ca

import Control.Monad as M

forLoopM_ :: Monad m => a -> (a -> Bool) -> (a -> a) -> (a -> m ()) -> m ()
forLoopM_ indx prop incr f = do
        f indx
        M.when (prop next) $ forLoopM_ next prop incr f
  where      
    next = incr indx

și folosit ca:

  forLoopM_ (0::Int) (< len) (+1) $ \indx -> do -- whatever with the index

1991: Oberon-2, Oberon-07 sau Component Pascal

FOR Counter := 1 TO 5 DO
  (* statement sequence *)
END

Rețineți că în limba originală Oberon bucla for a fost omisă în favoarea construcției buclei Oberon mai generale. For-loop a fost reintrodus în Oberon-2.

1991: Python

Python nu conține bucla clasică pentru, mai degrabă foreachse utilizează o buclă pentru a itera peste ieșirea range()funcției încorporate care returnează o listă iterabilă de numere întregi.

for i in range(1, 6):  # gives i values from 1 to 5 inclusive (but not 6)
    # statements
    print(i)
# if we want 6 we must do the following
for i in range(1, 6 + 1):  # gives i values from 1 to 6
    # statements
    print(i)

Utilizarea range(6)ar rula bucla de la 0 la 5.

1993: AppleScript

repeat with i from 1 to 5
	-- statements
	log i
end repeat

De asemenea, puteți itera printr-o listă de articole, similar cu ceea ce puteți face cu matricele în alte limbi:

set x to {1, "waffles", "bacon", 5.1, false}
repeat with i in x
	log i
end repeat

De asemenea, puteți utiliza oricând exit repeatpentru a ieși dintr-o buclă. Spre deosebire de alte limbi, AppleScript nu are în prezent nicio comandă pentru a continua la următoarea iterație a unei bucle.

1993: Lua

for i = start, stop, interval do
  -- statements
end

Deci, acest cod

for i = 1, 5, 2 do
  print(i)
end

va imprima:

1 3 5

For-buclele pot, de asemenea, să treacă printr-un tabel folosind

ipairs()

să itereze numeric prin tablouri și

pairs()

pentru a itera aleatoriu prin dicționare.

Generic pentru buclă folosind închideri :

for name, phone, address in contacts() do
  -- contacts() must be an iterator function
end

1995: CFML

Sintaxa scriptului

Buclă index simplă:

for (i = 1; i <= 5; i++) {
	// statements
}

Folosind o matrice:

for (i in [1,2,3,4,5]) {
	// statements
}

Folosind o listă de valori șir:

loop index="i" list="1;2,3;4,5" delimiters=",;" {
	// statements
}

Exemplul de mai sus listeste disponibil numai în dialectul CFML folosit de Lucee și Railo .

Sintaxa etichetei