Pro smyčku - For loop

Pro smyčkový diagram

V počítačové vědě je for-loop (nebo jednoduše pro smyčku ) příkaz toku řízení pro specifikaci iterace , který umožňuje opakované spuštění kódu . Pro upřesnění tohoto tvrzení se používají různá klíčová slova: potomci ALGOLU používají „pro“, zatímco potomci Fortranu používají „do“. Existují i další možnosti, například COBOL, který používá „PERFORM VARYING“.

For-loop má dvě části: záhlaví určující iteraci a tělo, které se provede jednou za iteraci. Záhlaví často deklaruje explicitní čítač smyčky nebo proměnnou smyčky, která umožňuje tělu vědět, která iterace se provádí. For-smyčky se obvykle používají, pokud je počet iterací znám před vstupem do smyčky. For-loops lze považovat za zkratky pro while-smyčky, které zvyšují a testují proměnnou smyčky.

Název for-loop pochází ze slova pro , které se v mnoha programovacích jazycích používá jako klíčové slovo k zavedení smyčky for-loop. Termín v angličtině pochází z ALGOL 58 a byl propagován ve vlivném pozdějším ALGOL 60 ; to je přímý překlad dřívější německé für , který se používá v SUPERPLAN (1949-1951), kterou Heinz Rutishauser , který byl také zapojen do definování ALGOL 58 a ALGOL 60. Tělo cyklu se provádí „za“ daných hodnot proměnné smyčky , ačkoli je to jasnější ve verzi příkazu ALGOL , ve které lze zadat seznam možných hodnot a/nebo přírůstků.

Ve FORTRAN a PL/I se klíčové slovo DO používá pro stejnou věc a nazývá se do-loop ; toto se liší od smyčky do-while .

PRO

Pro ilustraci smyčky od i = 0 do i = 2, což má za následek data1 = 200

Příkaz pro smyčku je k dispozici ve většině imperativních programovacích jazyků. I když ignorujeme drobné rozdíly v syntaxi, existuje mnoho rozdílů v tom, jak tyto příkazy fungují, a na úrovni expresivity, kterou podporují. For-smyčky obecně spadají do jedné z následujících kategorií:

Tradiční for-smyčky

For -loop jazyků jako ALGOL , Simula , BASIC , Pascal , Modula , Oberon , Ada , Matlab , Ocaml , F# atd. Vyžaduje řídicí proměnnou s počáteční a koncovou hodnotou a vypadá nějak takto:

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

V závislosti na jazyce lze místo znaku rovnosti použít explicitní znak přiřazení (a některé jazyky vyžadují slovo i v číselném případě). Může být také zahrnuta volitelná hodnota kroku (přírůstek nebo úbytek ≠ 1), ačkoli přesné syntaxe použité pro tento účel se mezi jazyky trochu více liší. Některé jazyky vyžadují samostatnou deklaraci řídicí proměnné, některé nikoli. int

Další forma byla propagována v C programovací jazyk . Vyžaduje 3 části: inicializaci ( varianta smyčky ), podmínku a postup do další iterace. Všechny tyto tři části jsou volitelné. Tento typ „středníkových smyček“ pocházel z programovacího jazyka B a původně jej vynalezl Stephen Johnson .

V inicializační části jsou deklarovány všechny potřebné proměnné (a obvykle přiřazené hodnoty). Pokud je deklarováno více proměnných, měly by být všechny stejného typu. Část s podmínkou zkontroluje určitou podmínku a pokud je false, smyčku opustí. Pokrok do další iterační části se provádí přesně jednou pokaždé, když smyčka končí. Smyčka se poté opakuje, pokud je podmínka vyhodnocena jako true.

Zde je příklad tradiční for-smyčky ve stylu C v Javě .

// 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();

Tyto smyčky se také někdy nazývají číselné smyčky, když jsou v kontrastu se smyčkami foreach (viz níže).

Smyčky založené na iterátoru

Tento typ pro smyčku je zobecněním typu číselného rozsahu pro smyčku, protože umožňuje výčet sad položek jiných než číselných sekvencí. Obvykle se vyznačuje použitím implicitního nebo explicitního iterátoru , ve kterém proměnná smyčky přebírá každou z hodnot v posloupnosti nebo jiné shromažďování dat. Reprezentativní příklad v Pythonu je:

for item in some_iterable_object:
    do_something()
    do_something_else()

Kde some_iterable_objectje buď sběr dat, který podporuje implicitní iteraci (jako seznam jmen zaměstnanců), nebo může být ve skutečnosti samotný iterátor. Některé jazyky to mají navíc k další syntaxi pro smyčku; pozoruhodně PHP má tento typ smyčky pod názvem for each, stejně jako tři výrazy pro smyčku (viz níže) pod názvem for.

Vektorizované for-smyčky

Některé jazyky nabízejí smyčku for, která funguje, jako by zpracovávala všechny iterace souběžně , například for allklíčové slovo ve FORTRAN 95, které má interpretaci, že všechny výrazy na pravé straně jsou vyhodnoceny před provedením přiřazení, na rozdíl od explicitní iterace formulář. Například v forpříkazu v následujícím fragmentu pseudokódu při výpočtu nové hodnoty pro A(i), s výjimkou prvního (s i = 2) odkazu na A(i - 1), získá novou hodnotu, která tam byla umístěna v předchozím kroku. Ve for allverzi však každý výpočet odkazuje pouze na původní, nezměněný 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;

Rozdíl může být značný.

Některé jazyky (například FORTRAN 95, PL/I) také nabízejí příkazy přiřazení polí, které umožňují vynechat mnoho smyček for-loops. Pseudokód, který A := 0;by nastavil všechny prvky pole A na nulu, bez ohledu na jeho velikost nebo rozměrnost. Smyčku příkladu lze vykreslit jako

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

Ale zda by to bylo vykresleno ve stylu for-loop nebo for all-loop nebo něčeho jiného, nemusí být v manuálu kompilátoru jasně popsáno.

Složené smyčky

Představený s ALGOL 68 a následovaný PL/I , to umožňuje iteraci smyčky kombinovat s testem, jako v

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

To znamená, že hodnota je přiřazena do proměnné smyčky i a to pouze v případě, že zatímco výraz je pravda, že tělo smyčky být provedeny. Pokud by výsledek byl nepravdivý, provádění for-loop se zastaví. Je pravda, že hodnota proměnné smyčky je definována po ukončení smyčky, pak výše uvedený příkaz najde první kladný prvek v poli A (a pokud ne, jeho hodnota bude N + 1 ), nebo s vhodnými variacemi , první neprázdný znak v řetězci atd.

Čítače smyček

V počítačové programování je počítadlo smyčky je proměnná , která ovládá iterací smyčky (počítačový programovací jazyk construct). Je tak pojmenována, protože většina použití tohoto konstruktu má za následek, že proměnná nabývá řady celočíselných hodnot v některých uspořádaných posloupnostech (příklad. Počínaje 0 a končí 10 v přírůstcích po 1)

Počitadla smyček se mění s každou iterací smyčky a poskytují jedinečnou hodnotu pro každou jednotlivou iteraci. Čítač smyčky se používá k rozhodnutí, kdy by měla smyčka skončit, a aby tok programu pokračoval po smyčce na další instrukci .

Běžnou konvencí pojmenování identifikátorů je, aby čítač smyčky používal názvy proměnných i , j a k (a tak dále, pokud je to nutné), kde i by byl nejvíce vnější smyčkou, j další vnitřní smyčkou atd. Obrácené pořadí je používají také někteří programátoři. Obecně se souhlasí s tím, že tento styl pochází z raného programování FORTRAN , kde názvy těchto proměnných začínající těmito písmeny byly implicitně deklarovány jako celočíselné, a tak byly zřejmé volby pro čítače smyček, které byly vyžadovány pouze dočasně. Praxe sahá dále k matematické notaci, kde indexy pro součty a násobení jsou často i , j atd. Variantní konvencí je použití zdvojených písmen pro index, ii , jj a kk , protože to umožňuje snazší vyhledávání a vyhledávání- nahrazení než použití jediného písmene.

Příklad

Příklad kódu C zahrnujícího vnořené smyčky, kde proměnné čítače smyčky jsou i a j :

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

Ukázalo se, že vnořená smyčka, jako ve výše uvedeném příkladu, provádí více výpočtů za jednotku času než smyčka bez ní. Tato optimalizace nezávislá na stroji znamená, že smyčka vnořená pro skončí rychleji, vzhledem ke stejnému počtu provedených výpočtů. To je výhoda vnořené smyčky přes vnořené while, která se chová odlišně.

Pro smyčky v C lze také použít k tisku zadní části slova. Tak jako:

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

Zde, pokud je vstup apple, bude výstup elppa.

Další sémantika a konstrukce

Použijte jako nekonečné smyčky

Tato smyčka ve stylu C je obvykle zdrojem nekonečné smyčky, protože základní kroky iterace jsou zcela v ovládání programátora. Ve skutečnosti, když jsou zamýšleny nekonečné smyčky, lze použít tento typ smyčky for (s prázdnými výrazy), například:

for (;;)
    //loop body

Tento styl se používá místo nekonečných while (1)smyček, aby se zabránilo upozornění na převod typu v některých kompilátorech C/C ++. Někteří programátoři upřednostňují stručnější for (;;)formu před sémanticky ekvivalentní, ale podrobnější while (true)formou.

Předčasný odchod a pokračování

Některé jazyky mohou také poskytovat další podpůrná prohlášení, která, pokud jsou přítomna, mohou změnit způsob, jakým probíhá iterace pro smyčku. Běžné mezi nimi jsou příkazy break a continue nalezené v C a jeho derivátech. Příkaz break způsobí, že smyčka nejvnitřnější bude po spuštění okamžitě ukončena. Příkaz continue se okamžitě přesune na další iteraci bez dalšího postupu přes tělo smyčky pro aktuální iteraci. Příkaz for také skončí, když je v těle příkazu proveden příkaz break, goto nebo return. [Wells] Jiné jazyky mohou mít podobná prohlášení nebo jinak poskytovat prostředky ke změně postupu pro smyčku; například ve 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".

Některé jazyky nabízejí další možnosti, jako je pojmenování různých smyčkových příkazů, takže u více vnořených smyček není pochyb o tom, o kterou smyčku jde. Fortran 95, například:

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

Když je tedy ve vnitřní smyčce detekován „problém“, CYCLE X1 (ne X2) znamená, že přeskočení přejde na další iteraci pro I, ne pro J. Překladač bude také kontrolovat, zda má každý END DO příslušný popisek pro svou pozici: nejedná se pouze o dokumentační pomůcku. Programátor musí stále správně kódovat problém, ale některé možné chyby budou zablokovány.

Smyčka proměnného rozsahu a sémantiky

Různé jazyky určují různá pravidla pro to, jakou hodnotu bude proměnná smyčky držet při ukončení její smyčky, a někteří dokonce tvrdí, že se „stane nedefinovanou“. To kompilátoru umožňuje generovat kód, který ponechá libovolnou hodnotu v proměnné smyčky, nebo ji dokonce nechá beze změny, protože hodnota smyčky byla držena v registru a nikdy nebyla uložena do paměti. Skutečné chování se může dokonce lišit podle optimalizace nastavení kompilátoru, jako u kompilátoru Honywell Fortran66.

V některých jazycích (ne C nebo C ++ ) je proměnná smyčky v rozsahu těla smyčky neměnná , přičemž jakýkoli pokus o úpravu její hodnoty je považován za sémantickou chybu. Takové úpravy jsou někdy důsledkem chyby programátora, kterou lze po provedení velmi obtížně identifikovat. Kompilátor však pravděpodobně detekuje pouze zjevné změny. Situace, kdy je adresa proměnné smyčky předána jako argument podprogramu , velmi ztěžují kontrolu, protože chování rutiny je kompilátoru obecně nepoznatelné. Několik příkladů ve stylu Fortranu:

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?

Běžným přístupem je vypočítat počet iterací na začátku smyčky (s pečlivou pozorností na přetečení jako v for i := 0 : 65535 do ... ;šestnáctibitové celočíselné aritmetice) a při každé iteraci tento počet snižovat a současně upravovat hodnotu I : výsledky dvojitého počítání. Úpravy hodnoty I ve smyčce však nezmění počet provedených iterací.

Ještě další možností je, že generovaný kód může využívat jako proměnnou smyčky pomocnou proměnnou, případně uloženou v registru stroje, jejíž hodnota může nebo nemusí být kopírována do I při každé iteraci. Opět, úpravy I by neměly vliv na ovládání smyčky, ale nyní je možná disjunkce: ve smyčce odkazy na hodnotu I mohou být na (případně změněné) aktuální hodnotě I nebo na pomocné proměnné (držené v bezpečí před nesprávnou úpravou) a matoucí výsledky jsou zaručeny. Například ve smyčce by odkaz na prvek I pole pravděpodobně využíval pomocnou proměnnou (zvláště pokud by byla držena v registru stroje), ale pokud I je parametrem nějaké rutiny (například tiskové prohlášení odhalit jeho hodnotu), pravděpodobně by být odkaz na řádné proměnné I místo. Takovým možnostem je nejlepší se vyhnout.

Úprava mezí

Stejně jako může být proměnná indexu upravena v rámci smyčky for, může být také její hranice a směr. Ale s nejistým účinkem. Kompilátor může těmto pokusům zabránit, nemusí mít žádný účinek, nebo dokonce mohou fungovat správně - ačkoli mnozí prohlašují, že by to bylo špatné. Zvažte prohlášení, jako je

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

Pokud by přístupem ke kompilaci takové smyčky mělo být vyhodnocení prvního , posledního a kroku a výpočet počtu iterací prostřednictvím něčeho podobného (last - first)/steppouze jednou na začátku, pak pokud by tyto položky byly jednoduchými proměnnými a jejich hodnoty byly nějakým způsobem upravovány během iterace, nemělo by to žádný vliv na počet iterací, i když se prvek vybraný pro rozdělení A(last)změnil.

Seznam rozsahů hodnot

PL/I a Algol 68, umožňuje smyčky, ve kterých je proměnná smyčky iterována přes seznam rozsahů hodnot namísto jednoho rozsahu. Následující příklad PL/I spustí smyčku se šesti hodnotami i: 1, 7, 12, 13, 14, 15:

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

Ekvivalence se smyčkami while

For-loop je obecně ekvivalentem while-loop:

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

je ekvivalentní:

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

jak ukazuje výstup proměnných.

Časová osa syntaxe for-loop v různých programovacích jazycích

Vzhledem k akci, kterou je třeba opakovat, například pětkrát, budou smyčky pro různé jazyky zapsány odlišně. Syntaxe pro smyčku se třemi výrazy pro smyčku je téměř identická ve všech jazycích, které ji mají, po zohlednění různých stylů ukončení bloku a tak dále.

1957: FORTRAN

Fortranův ekvivalent smyčky for je smyčka DO , pomocí klíčového slova do místo for, Syntaxe smyčky DO Fortran je:

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

Následující dva příklady se chovají ekvivalentně ke třem argumentům pro smyčku v jiných jazycích, inicializují proměnnou čítače na 1, zvyšují o 1 každou iteraci smyčky a zastavují se na pět (včetně).

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

Ve Fortran 77 (nebo novějším) to může být také zapsáno jako:

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

Kroková část může být vynechána, pokud je krok jedna. Příklad:

* 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

Mezery jsou v příkazech Fortran v pevné formě irelevantní, takže SUM SQ je stejné jako SUMSQ . V moderním stylu Fortran ve volné formě jsou mezery významné.

Ve Fortran 90 se GO TO dá vyhnout použitím příkazu 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 představil forprohlášení pomocí formuláře jako Superplan:

 FOR Identifier = Base (Difference) Limit

Například pro tisk 0 až 10 po 1:

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

1960: COBOL

COBOL byl formalizován na konci roku 1959 a má mnoho zpracování. Používá sloveso PERFORM, které má mnoho možností. Původně všechny smyčky musely být mimo řádek s iterovaným kódem zabírajícím samostatný odstavec. Ignorováním potřeby deklarace a inicializace proměnných by ekvivalent COBOL pro for -loop byl.

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

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

V 80. letech minulého století vedlo přidání smyček in-line a „strukturovaných“ příkazů, jako je END-PERFORM, k vytvoření smyčky for -loop se známější strukturou.

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

Pokud má sloveso PERFORM volitelnou klauzuli TEST PO, výsledná smyčka se mírně liší: tělo smyčky se provede alespoň jednou, před jakýmkoli testem.

1964: ZÁKLADNÍ

Smyčky v BASIC se někdy nazývají smyčky pro další.

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

Všimněte si, že značka na konci smyčky určuje název proměnné indexu, který musí odpovídat názvu proměnné indexu na začátku smyčky for. Některé jazyky (PL/I, FORTRAN 95 a novější) umožňují štítek příkazu na začátku smyčky pro smyčku, který může kompilátor porovnat se stejným textem v odpovídajícím příkazu na konci smyčky. Fortran také umožňuje příkazům EXITa CYCLEpojmenovat tento text; v hnízdě smyček to jasně ukazuje, která smyčka je určena. V těchto jazycích však musí být popisky jedinečné, takže po sobě jdoucí smyčky zahrnující stejnou indexovou proměnnou nemohou používat stejný text ani popisek nesmí být stejný jako název proměnné, například indexová proměnná pro smyčku.

1964: PL/I

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

K opuštění smyčky lze použít příkaz LEAVE . Smyčky mohou být označeny a opuštění může zanechat konkrétní označenou smyčku ve skupině vnořených smyček. Některé dialekty PL/I obsahují příkaz ITERATE k ukončení aktuální iterace smyčky a zahájení další.

1968: Algol 68

ALGOL 68 má to, co bylo považováno za univerzální smyčku, úplná syntaxe je:

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

Dále může být rozsah jedné iterace nahrazen seznamem takových rozsahů. Existuje několik neobvyklých aspektů konstrukce

pouze do ~ odčást byla povinná, v takovém případě bude smyčka iterovat neomezeně dlouho.
klauzule tedy to 100 do ~ odbude iterovat přesně 100krát.
while syntaktický prvek nechá programátor rozbít od forsmyčky časně, jako v:

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

Následná rozšíření standardního Algol68 umožnila tonahrazení syntaktického prvku uptoa downtodosažení malé optimalizace. Stejné překladače také zahrnovaly:

until: pro pozdní ukončení smyčky.
foreach: pro paralelní práci na poli .

1970: Pascal

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

Decrementing (countting backwards) is using downtokeyword instead of to, as in:

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

Číselný rozsah pro smyčku se liší poněkud více.

1972: C/C ++

for (initialization; condition; increment/decrement)
    statement

Tvrzení je často prohlášení bloku; příkladem by bylo toto:

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

Publikace ISO/IEC 9899: 1999 (běžně známá jako C99 ) také umožňuje počáteční deklarace ve forsmyčkách. Všechny tři sekce ve smyčce for jsou volitelné.

1972: Smalltalk

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

Na rozdíl od jiných jazyků není v Smalltalk for-loop jazykovým konstruktem, ale je definován ve třídě Number jako metoda se dvěma parametry, koncovou hodnotou a uzávěrem , pomocí self jako počáteční hodnoty.

1980: Ada

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

K ukončení smyčky lze použít příkaz exit. Smyčky mohou být označeny a opuštění může zanechat specificky označenou smyčku ve skupině vnořených smyček:

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: Javor

Maple má dvě formy pro smyčku, jednu pro iteraci rozsahu hodnot a druhou pro iteraci obsahu kontejneru. Forma rozsahu hodnot je následující:

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

Všechny díly kromě doa odjsou volitelné. Část, pokud je přítomen, musí přijít jako první. Zbývající části ( , , , ) se může objevit v libovolném pořadí. for ifrom fby bto twhile w

Iterace nad kontejnerem se provádí pomocí této formy smyčky:

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

Klauzule určuje nádobu, která může být seznam, sada, částka, produkt, nevyhodnocené funkce, pole, nebo předmět, kterým se provádí iterátor. in c

A pro-smyčka může být ukončena od, endnebo end do.

1982: Maxima CAS

V Maxima CAS lze použít i jiné než celočíselné hodnoty:

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

1982: PostScript

For-loop, zapsaná jako [initial] [increment] [limit] { ... } forinicializuje interní proměnnou, provede tělo, pokud vnitřní proměnná není větší než limit (nebo ne menší, pokud je přírůstek záporný) a na konci každé iterace vnitřní proměnnou zvýší. Před každou iterací je hodnota vnitřní proměnné vložena do zásobníku.

1 1 6 {STATEMENTS} for

Existuje také jednoduchá smyčka opakování. Opakovací smyčka, zapsaná jako X { ... } repeat, opakuje tělo přesně Xkrát.

5 { STATEMENTS } repeat

1983: Ada 83 a výše

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

Po smyčce nby v tomto případě bylo 5.

Jak ise používá pro Imaginary jednotku , jeho použití jako proměnné smyčky se nedoporučuje.

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;
}

(Všimněte si, že „ existuje více než jeden způsob, jak to udělat “ je motto Perl pro programování.)

1988: Mathematica

Konstrukce odpovídající smyčce pro většinu ostatních jazyků se nazývá Do in Mathematica

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

Mathematica má také konstrukt For, který napodobuje for-loop jazyků podobných 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

Pamatujte, že prázdná smyčka (tj. Smyčka bez příkazů mezi doa done) je chybou syntaxe. Pokud by výše uvedené smyčky obsahovaly pouze komentáře, provedení by mělo za následek zprávu „chyba syntaxe poblíž neočekávaného tokenu„ hotovo ““.

1990: Haskell

Vestavěný imperativ forM_ mapuje monadický výraz do seznamu jako

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

nebo získat každý výsledek iterace jako seznam

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

Pokud však chcete ušetřit místo v seznamu [1..5], autentičtější monadickou konstrukci pro LoLop_ lze definovat jako

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

a používá se jako:

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

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

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

Všimněte si, že v původním Oberonském jazyce byla for-loop vynechána ve prospěch obecnější Oberonovy smyčkové konstrukce. For-loop byl znovu zaveden v Oberon-2.

1991: Python

Python neobsahuje klasickou smyčku for, ale foreachsmyčka se používá k iteraci výstupu vestavěné range()funkce, která vrací iterovatelný seznam celých čísel.

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)

Použití range(6)by spustilo smyčku od 0 do 5.

1993: AppleScript

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

Můžete také procházet seznam položek, podobně jako to můžete dělat s poli v jiných jazycích:

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

Můžete také exit repeatkdykoli ukončit smyčku. Na rozdíl od jiných jazyků, AppleScript aktuálně nemá žádný příkaz pro pokračování do další iterace smyčky.

1993: Lua

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

Takže tento kód

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

vytiskne:

1 3 5

For-loops lze také procházet tabulkou pomocí

ipairs()

iterovat číselně prostřednictvím polí a

pairs()

náhodně iterovat prostřednictvím slovníků.

Generic pro-smyčky použití výroba uzávěrů :

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

1995: CFML

Syntaxe skriptu

Jednoduchá indexová smyčka:

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

Použití pole:

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

Pomocí seznamu hodnot řetězců:

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

Výše uvedený listpříklad je k dispozici pouze v dialektu CFML, který používají Lucee a Railo .

Syntaxe tagu