Upravljanje tokom
<s>U računarstvu, upravljanje tokom predstavlja redosled po kome se naredbe, uputstva ili pozivi funkcija proveravaju ili izvršavaju.</s><s>Eksplicitnim naglaskom na kontrolu toka se razlikuju imperativni programski jezici od deklarativnih programskih jezika.</s>

<s>U okviru imperativnog programskog jezika, naredba upravljanja tokom svojim izvršavanjem daje odgovor na pitanje kojim putem (ako postoje 2 ili više) treba nastaviti izvršavanje.</s><s>Kod ne-striktnih programskih jezika, funkcijama i jezičkim konstrukcijama se dolazi do istog rezultata, ali se to ne zove nužno upravljanje tokom.</s>

<s>Vrste naredbi kontrole tokom koje podržavaju različiti jezici se razlikuju, ali se mogu podeliti po njihovom efektu:
 nastavak na drugoj naredbi(bezuslovno grananje ili skok),
 izvršavanje bloka naredbi samo ako je ispunjen određeni uslov (izbor, odnosno uslovna grana),
 izvršavanje sklopa naredbi nijednom ili više puta, dok se ne ispuni određeni uslov (npr. petlja - isto gao i uslovna grana),
 izvršavanje udaljenog kompleta naredbi, nakon kojeg se uglavnom tok upravljanja vraća (potprogrami, koprogrami i kontinuacije),
 zaustavljanje programa, sprečavajući dalji rad (bezuslovni zastoj).</s>

<s>Skup naredbi je zato generalno strukturiran kao blok, koji pored grupisanja definiše i leksički obim.</s>

<s>Prekidi i signali su mehanizmi niskog nivoa koji menjaju tok upravljanja na sličan način kao i potprogrami, ali se pre javljaju kao odgovor na neke eksterne stimuluse (koji mogu da se dese asinhrono), nego na „in-lajn naredbe upravljanja tokom.</s>

<s>Na nivou mašine ili asemblerskog jezika, instrukcije upravljanja tokom rade tako što menjaju programski registar.</s><s>Za neke procesore jedina uputstva za upravljanje tokom su uslovne ili bezuslovne naredbe za grananje (skokovi).</s>

<s>Primitive</s>

<s>Labele</s>

<s>Labela prestavlja ime ili broj eksplicitno dodeljen fiksnoj poziciji unutar izvornog koda, koji može biti pozvan naredbom upravljanja toka koja se nalazi na nekom drugom mestu unutar izvornog koda.</s><s>Labela, osim što obeležava poziciju unutar izvornog koda, nema drugih funkcija.</s>

<s>Brojevi redova su zamena za labelu sa imenom (koji se koriste u nekim programskim jezicima kao što su Fortran i Bejsik), to su celi brojevi postavljeni na početak svakog reda teksta unutar izvornog koda.</s><s>Programski jezici u kojima se ovo koristi često postavljaju uslov da broj svakog novog reda mora biti veći od broja iz prethodnog reda, ali ne mora nužno biti prvi uzastopni.</s><s>Na primer, u Bejsiku:10 LET X = 3
20 PRINT XU drugim jezicima kao što su C i Ada, labela je identifikator koji se obično pojavljuje na početku reda, praćen kolonom.</s><s>Na primer, u programskom jeziku C:Success: printf("The operation was successful.\n");Programski jezik Algol 60 je dozvoljavao kako cele brojeve tako i identifikatore kao labele (oba zakačena za kolonu sa određenom naredbom), ali samo nekoliko u slučaju da je neka druga varijanta Algola dozvoljavala cele brojeve.</s>

<s>Goto 
goto naredba (reč nastala spajanjem engleskih reči gou i tu) je najjednostavnija forma bezuslovnog prenosa upravljanja.</s>

<s>Iako ključna reč može biti sastavljena i od velikih i od malih slova u zavisnosti od programskog jezika, obično se zapisuje kao:
    goto labelCilj goutu naredbe je da izazove izvršavanje naredbe koja je data određenom labelom (ili sledi odmah nakon nje).</s>

<s>Goutu naredbe se smatraju štetnim od strane mnogih stručnjaka iz oblasti računarstva, među kojima je i Edsger Dajkstra.</s>

<s>Potprogrami</s>

<s>Terminologija reči potprogram dosta varira; alternativni nazivi su rutine, procedure, funkcije (pogotovo ako vraćaju rezultate) ili metode (posebno ako pripadaju klasama ili klasama tipa).</s>

<s>Tokom pedesetih godina dvadesetog veka, memorije računara su bile veoma male u poređenju sa današnjim standardima, pa su potprogrami pre svega korišćene radi smanjivanja veličine programa; deo koda je bio jednom napisan a onda korišćen mnogo puta iz različitih delova programa.</s>

<s>U današnje vreme, potprogrami se češće koriste sa stvaranje programa koji ima obimniju strukturu, npr. izdvajanjem određenog algoritma ili sakrivanjem određene metode prsistupa podacima, potprogrami su jedan tip modularnosti koji pomaže da se skrati posao.</s>

<s>Minimalno strukturirano upravljanje tokom 
U maju 1966., Bom i Jakopini su objavili članak u časopisu Komunikacije ACM-a u kojem tvrde da bilo koji program sa goutujem može da se preobrazi u program bez goutua koristeći samo izbor (IF THEN ELSE) i petlje (WHILE uslov DO xxx), moguće sa dupliranim kodom i/ili dodavanjem Bulovih varijabli (tačno/netačno).</s><s>Kasnije su autori dokazali da izbor može biti zamenjen petljama (i još više Bulovih promenljivih).</s>

<s>Činjenica da je takav minimalizam moguć, ne znači i da je poželjan; uostalom, računarima je teoretski potrebna samo jedna mašinska instrukcija (oduzmi jedan broj od drugog i granaj ako je rezultat negativan), ali praktični računari imaju više desetina ili više stotina mašinskih instrukcija.</s>

<s>Bomov i Jakopinijev članak je pokazao da svi programi mogu biti bez goutu-a.</s><s>Ostala istraživanja su pokazala da su kontrolne strukture sa po jednim ulazom i izlazom bile mnogo lakše za razumevanje nego bilo koja druga forma, najviše zbog toga što su mogle da se koriste svuda kao naredbe, bez remećenja upravljanja tokom.</s><s>Drugim rečima, bile su kompozabilne. (Kasnija unapređenja, kao što su ne-striktni programski jezici - ili ranija, kompozabilne softverske transakcije - su pratile ovaj pravac mišljenja, što je činilo komponente programa još više kompozabilnim.)</s>

<s>Neki akademici su puristički pristupili rezultatima Boma i Jakopinija i započeli raspravu o tome da su čak i break i return naredbe koje se nalaze u petljama loše u praksi pošto uopšte nisu potrebne u navedenom dokazu, stoga su se zalagali da sve petlje treba da imaju samo jedan izlaz.</s><s>Ovakav puristički pristup je osnova programskog jezika Paskal (dizajniranog 1968-1969), koji je do sredine devedesetih godina dvadesetog veka bio preferiran jezik za programere početnike na fakultetima.</s><s>Direktna primena Bom-Jakopini teoreme može dovesti do pojave dodatnih lokalnih promenljivih u strukturiranom grafikonu, i takođe dovesti do ponavljanja u kodu.</s><s>Potonji problem se naziva petlja i po u ovom kontekstu.</s><s>Paskal je zahvaćen sa oba navedena problema i sudeći po empirijskim istraživanjima Erika S. Robertsa, studenti su imali poteškoća sa formulacijom tačnih rešenja za nekolicinu prostih problema, uključujući pisanje funkcije koja traži element u nizu.</s><s>U istraživanju Henrija Šapira iz 1980. navedenog od strane Robertsa, stoji podatak da koristeći samo kontrolne strukture koje nudi Paskal, samo 20% subjekata je dalo tačan odgovor, dok nijedan subjekat nije napisao pogrešan kod za rešenje problema ako mu je bilo dozvoljeno da napiše return naredbu u telu petlje.</s>

<s>Kontrolne strukture u praksi 
Većina programskih jezika koji sadrže kontrolne strukture poseduju i inicijalnu ključnu reč koja kazuje koji tip kontrolne strukture je sadržan.</s><s>Jezici se tada dele na one čije kontrolne strukture imaju odnosno nemaju finalnu ključnu reč.</s>

<s>Bez finalne ključne reči: Algol 60, C, C++, Haskel, Java, Paskal, Perl, PHP, PL/I, Pajton, PauerŠel.</s><s>Ovakvim jezicima je potreban neki način grupisanja izjava:
 Algol 60 i Paskal : begin ... end
 C, C++, Java, Perl, PHP i PauerŠel: vitičaste zagrade { ... }
 PL/1: DO ...</s><s>END
 Pajton: koristi nivo uvlačenja (vidi pravilo sa-strane)
 Haskel: mogu se koristiti i metod uvlačenja i vitičaste zagrade, uz slobodu da se mešaju
 Finalne ključne reči: Ada, Algol 68, Modula-2, Fortran 77, Mitril, Vižual bejsik.</s><s>Forme finalnih ključnih reči:
 Ada: Finalna ključna reč je end + spejs + inicijalna ključna reč npr. if ... end if, loop ... end loop
 Algol 68, Mitril: inicijalna ključna reč pisana otpozadi npr. if ... fi, case ... esac
 Fortran 77: finalna ključna reč je end + inicijalna ključna reč npr. IF ...</s><s>ENDIF, DO ...</s><s>ENDDO
 Modula-2: ista finalna ključna reč END za sve
 Vižual bejsik: svaka kontrolna struktura ima svoju ključnu reč.</s><s>If ...</s><s>End If; For ...</s><s>Next; Do ...</s><s>Loop; While ...</s><s>Wend</s>

<s>Izbor</s>

<s>If-then-(else) naredbe 
Uslovni izrazi i uslovne konstrukcije su odlike programskog jezika koji izvršava različite operacije u zavisnosti da li Bulov uslov vraća true ili false.</s>

<s>IF..</s><s>GOTO.</s><s>Forma koja se sreće u nestrukturiranim programskim jezicima koja imitira običnu instrukciju mašinskog koda, bi trebalo da skoči (GOTO) do oznake ili linijskog broja kada se uslov ispuni.</s>

<s>IF..</s><s>THEN..(ENDIF).</s><s>Umesto da budu ograničene na skok, bilo koja prosta naredba ili ugnežđeni bi mogli da prate THEN ključnu reč.</s><s>Ovo je strukturirana forma.</s>

<s>IF..</s><s>THEN..</s><s>ELSE..(ENDIF).</s><s>Kao gorenavedeno, ali preduzimajući drugu radnju ukoliko je uslov false.</s><s>Ovo je jedna od najzastupljenijih formi, sa mnogo varijacija.</s><s>Neke zahtevaju završno ENDIF, neke ne.</s><s>C i slični jezici ne zahtevaju završnu ključnu reč, ili 'then', ali zahtevaju zagrade oko uslova.</s>

<s>Uslovne naredbe su često ugnežđene unutar uslovnih naredbi.</s><s>Neki jezici dozvoljavaju ELSE i IF da se kombinuju u ELSEIF, izbegavajući potrebuza većim brojem ENDIF ili ostalih finalnih naredbi na kraju složene naredbe.</s>

<s>Manje poznate varijacije uključuju:-
 Neki jezici, kao što je Fortran, imaju "trostruko" ili "aritmetičko if", testiranje, koje proverava da li je numerička vrednost pozitivna, negativna ili nula..</s>

<s>Neki jezici poseduju funkcionalnu formu "if" naredbe, na primer Lispov cond.</s>

<s>Neki jezici poseduju operatorsku formu "if" naredbe, kao na primer trojni operator u jeziku C.</s>

<s>Perl pruža if sa when i unless po uzuru na C.</s>

<s>Smalltalk koristi ifTrue i ifFalse poruke za implementaciju kondicionala, radije nego neke osnovne jezičke konstrukcije.</s>

<s>Naredbe zamene i predmeta 
Naredbe zamene (ili naredbe predmeta, ili višestruke grane) porede zadatu vrednost sa određenim konstantama i započinju izvršavanje u zavisnosti od prve konstante sa kojom se poklope.</s><s>Obično postoji ograničen broj uobičajenih akcija ("else", "otherwise") koje se preduzimaju ako se nijedno poklapanje ne dogodi.</s><s>Naredbe zamene dozvoljavaju optimizaciju kompajlera, kao što su lukap tabele.</s><s>U dinamičkim jezicima, predmeti ne moraju biti ograničeni konstantnim izrazima, i moguće je da se produže do poklapanja šablona, kao u primeru šel skripte sa desne strane, gde *) implementira uobičajeni slučaj kao glob koji se poklapa sa bilo kojim stringom.</s><s>Logika slučaja se takođe može implementirati u funkcionalnu formu, kao u SQL-ovoj decode naredbi.</s>

<s>Petlje 
Petlja predstavlja niz naredbi koji se definiše jednom ali se može izvršite više puta uzastopno.</s><s>Kod "unutar" petlje (telo petlje, ispod prikazano kao hhh) se izvršava određen broj puta, ili jedanput za kolekciju stavki, ili dok se ne ispuni određeni uslov, ili neograničeno mogo puta.</s>

<s>U funkcionalnim programskim jezicima, kao što su Haskel i Scheme, petlje se mogu iskazati pomoću rekurzije ili iteracije sa zadatom tačkom bolje nego eksplicitnim konstrukcijama petlje.</s><s>Repna rekurzija predstavlja specijalni slučaj rekurzije koja se lako može pretvoriti u iteraciju.</s>

<s>Petlje kontrolisane brojanjem</s>

<s>Većina programskih jezika poseduje konstrukcije za ponavljanje petlje određen broj puta.</s><s>Treba zapaziti da, ako je N manje od 1 u ovim slučajevima, onda jezik zapravo specifikuje da telo treba potpuno preskočiti, ili izvršiti jedanput ako je N=1. U većini slučajeva, brojanje je moguće i unazad, a ne mora ni biti uzastopno.</s><s>FOR I = 1 TO N           | for I := 1 to N do begin
        xxx                  |     xxx
    NEXT I                   | end;
 ------------------------------------------------------------
    DO I = 1,N               | for ( I=1; I<=N; ++I ) {
        xxx                  |     xxx
    END DO                   | }
U velikom broju programskih jezika, samo se intidžeri mogu pouzdano koristiti za petlju koja je kontrolisana brojačem.</s><s>Flouting-point brojevi nisu precizno predstavljeni zbog ograničenja hardvera, tako da petlja npr.:
    for X := 0.1 step 0.1 to 1.0 do
možda može biti ponovljena 9 ili 10 puta, u zavisnosti od grešaka sa saokruživanjem brojeva i/ili hardvera i/ili verzije kompajlera.</s><s>Osim toga, ako se povećanje H-a dogodi puetm ponovljenjog sabiranja, nagomilane greške u zaokruživanju značiti da se vrednost H u svakoj iteraciji može dosta razlikovati od očekivanog niza 0.1, 0.2, 0.3, ..., 1-0.</s>

<s>Uslovno-kontrolisane petlje</s>

<s>Većina programskih jezika poseduje strukture za ponavljanje petlje sve dok se neki uslov ne promeni.</s><s>Treba napomenuti da je kod nekih varijacija provera na početku, a kod nekih na kraju petlje.</s><s>U slučaju da je provera pre petlje, telo petlje se može u potpunosti preskočiti, ali ako se nalazi posle tela petlje, petlja se mora izvršiti bar jedanput.</s><s>DO WHILE (test)          | repeat 
        xxx                  |     xxx 
    LOOP                     | until test;
 ----------------------------------------------
    while (test) {           | do
        xxx                  |     xxx
    }                        | while (test);
Prekid kontrole je metoda detekcije promene vrednosti koja se koristi u običnim petljama za započinjanje obrade grupe promenljivih.</s><s>Ključna promenljiva vrednost ili vrednosti se nadgledaju unutar petlje a njihova promena menja tok rada programa u zavisnosti od zadatih naredbi koje zavise od tih promenljivih vrednosti.</s><s>DO UNTIL (End-of-File)
       IF new-zipcode <> current-zipcode
          display_tally(current-zipcode, zipcount)
          
          current-zipcode = new-zipcode
          zipcount = 0
       ENDIF
       
       zipcount++
    LOOP</s>

<s>Petlje kontrolisane kolekcijom</s>

<s>Nekolicina programskih jezika (npr. Ada, D, Smalltalk, PHP, Perl, Objektni Paskal, Java, C#, Matlab, Mitril, Vižual Bejsik, Rubi, Pajton, Javaskript, Fortran 95 i kasniji) poseduju specijalne strukture koje dozvoljavaju ponavljanje petlje kroz sve elemente niza, ili sve članove kompleta ili kolekcije.
    nekaKolekcija do: [:svakiElement |xxx].</s>

<s>for Predmet in Kolekcija do begin xxx end;
 
    foreach (predmet; mojaKolekcija) { xxx }
 
    foreach nekiNiz { xxx }
 
    foreach ($nekiNiz as $k => $v) { xxx }
 
    Kolekcija<Niska> coll; for (Niska s : coll) {}
 
    foreach (niska s in mojaNiskaKolekcija) { xxx }
 
    $nekaKolekcija | ZaSvaki-Objekat { $_ }</s>

<s>forall ( index = first:last:step... )
Skala ima for-naredbe, koje generalizuju petlje kontrolisane kolekcijama, i pomažu druge radnje, kao što je paralelna obrada.</s><s>Haskel ima do-naredbe, koje pružaju sličnu funkcionalnost kao i for-izraza u Skali.</s>

<s>Opšta iteracija 
Strukture generalne iteracije, kao što je for-naredba u C-u i do forma u Common Lisp-u, se mogu iskoristiti za izražavanje bilo koje od gore navedenih petlji, kao i ostalih—npr. petljanje preko niza zbirki paralelno.</s><s>Tamo gde se može primeniti konkretnija struktura petlje, ona je prioritetnija od obične iterativne strukture, pošto čini svrhu izraza jasnijom.</s>

<s>Beskonačne petlje 
Beskonačne petlje se koriste da osiguraju da deo programa prolazi kroz petlju zauvek ili dok se ne pojavi izuzetan uslov, kao što je greška.</s><s>Na primer, program koji radi na principu događaja (kao što je server) bi trebalo da se nalazi u beskonačnoj petlji, obrađujući u momentu kad se dogode , zaustavljajući se samo u slučaju kada se proces prekine od strane operatora.</s>

<s>Beskonačne petlje mogu biti realizovane korišćenjem drugih konstrukcija za kontrolu toka.</s><s>Najčešće, kod nestrukturiranog programiranja ovo je skok unazad (goto), dok je u strukturiranom programiranju ovo beskonačna petlja (while petlja) podešena da se nikada ne završi, tako što se uslov izostavi ili jednostavno postavljanje istog uslova na True, kao while (true) ....</s><s>Neki jezici poseduju specijalne konstrukcije za beskonačne petlje, obično je to izostavljanje uslova iz beskonačne petlje.</s><s>Neki od pomenutih jezika su Ada (loop ... end loop), Fotran (DO ...</s><s>END DO), Gou (for { ... }), i Rubi (loop do ... end).</s>

<s>Često se dešava da se beskonačna petlja stvori kao posledica greške u uslovno-kontrolisanoj petlji, gde petlja koristi promenljive koje se u stvari nikada ne menjaju unutar te same petlje.</s>

<s>Kontinuacija sa narednom iteracijom 
Ponekad u telu petlje postoji potreba da se preskoči ostatak petlje i da se nastavi sa sledećom iteracijom petlje.</s><s>U nekim jezicima postoji naredba kao što je continue (većina jezika), skip, ili next (Perl i Rubi), koja će to učiniti.</s><s>Cilj je da se eliminiše izvršenje tela petlje koja se nalazi u sredini koda i da se nastavi sa normalnim izvršavanjem sledeće iteracije.</s><s>Ako je iteracija na poslednjem mestu u petlji, cilj je da se rano eliminiše čitava petlja.</s>

<s>Ponavljanje trenutne iteracije 
Neki jezici, poput Perla i Rubija, poseduju redo naredbu koja započinje trenutnu iteraciju od početka.</s>

<s>Ponovno pokretanje petlje 
Rubi poseduje retry naredbu koja pokreće celu petlju ispočetka, od prve iteracije.</s>

<s>Rani izlazak iz petlje 
Pri korišćenju petlje kontrolisane brojanjem za pretragu tabele, poželjno je da se pretraga obustavi u momentu kada se željena stavka pronađe.</s><s>Neki programski jezici poseduju naredbu kao što je break (većina jezika), exit, ili last (Perl), čiji je cilj da odmah prekine petlju i prebaci upravljanje na naredbu koja direktno sledi nakon petlje.</s>

<s>Naredni primer je prikazan u jeziku Ada koji podržava i rani izlaz iz petlje i petlje sa proverom u sredini.</s><s>Obe odlike su veoma slične i samo poređenjem isečaka iz oba koda može se videti razlika: rani izlaz zahteva da stoji u kombinaciji sa if naredbom, dok je provera u sredini samostalna konstrukcija.with Ada.</s><s>Text IO;
with Ada.</s><s>Integer Text IO;</s>

<s>procedure Štampaj_Kvadrate is 
    X : Integer;
begin
    Read_Data : loop
        Ada.</s><s>Integer Text IO.</s><s>Get(X);
    exit Read_Data when X = 0;
        Ada.</s><s>Text IO.</s><s>Put (X * X);
        Ada.</s><s>Text IO.</s><s>New_Line;
    end loop Read_Data;
end Štampaj_Kvadrate;Pajton podržava uslovno izvršavanje koda u zavisnosti od toga da li je se rano izašlo iz petlje (sa break naredbom), ili nije - koristeći se else-klauzulom sa petljom.</s><s>Na primer,for n in niz_brojeva:
    if prost_broj(n):
        print "Niz sadrži prost broj"
        break
else:
    print "Niz ne sadrži prost broj"Treba zapaziti da je else klauzula u gorenavedenom primeru zakačena za for naredbu, a ne unutrašnju if naredbu.</s><s>Obe petlje u Pajtonu,  for i while , podržavaju else klauzulu, koja se izvršava samo u slučaju da se rani izlazak iz petlje nije dogodio.</s>

<s>Neki jezici podržavaju prekidanje iz ugnežđenih petlji; u teorijskim krugovima, to se zove izbijanje sa više nivoa.</s><s>Tipična primena ovog principa je pretraživanje višedimenzionalnih tabela.</s><s>Ovo se može uraditi pomoću prekidanja sa više nivoa (prekidanje sa N nivoa), kao u bash-u i PHP-u, ili putem označenih prekida (izbij i nastavi kod date oznake), kao u Javi i Perlu.</s><s>Alternative za prekide sa više nivoa uključuju jednostruke prekide, zajedno sa neredbenim promenljivama koji se koriste za prekid još jednom nivou; izuzeci, koji se nalaze na nivou na koji se prekida; stavljanje ugnežđene petlje u funkciju i korišćenje return naredbe za izazivanje prekida čitave ugnežđene petlje; ili korišćenje oznake i goto iskaza.</s><s>C ne podržava prekid sa više nivoa, i uobičajena alternativa je korišćenje goto naredbe za implementaciju označenog prekida.</s><s>Pajton ne poseduje prekid sa više nivoa niti nastavak – ovo je predloženo u PEP 3136, ali je odbačeno na osnovu toga što dodatna kompleksnost nije bila vredna legitimne.</s>

<s>Pojam prekida sa više nivoa nekim delom bitna za teorijsko računarstvo, jer dovodi do nečega što se danas naziva the ,, kosaradžu hijerarhija' Godine 1973.</s><s>S. Rao Kosaradžu je preradio teoremu strukturiranih programa tako što je dokazao da je moguće da se izbegne dodavanje dodatnih promenljivih u strukturiranom programiranju, dok kod su proizvoljno-duboki prekidi sa više nivoa dozvoljeni u petlji.</s><s>Štaviše, Kosaradžu je dokazao da postoji stroga hijerarhija programa: za svaki intedžer n postoji program koji sadrži prekid sa više nivoa dubine n koji se ne može preraditi kao program sa prekidima sa više nivoa dubine manje od n bez uvođenja dodatnih promenljivih.</s>

<s>Takođe se može koristiti return naredba u potprogramu koja izvršava naredbe u petlji, vršeći time prekid kako ugnežđene petlje, tako i potprograma.</s><s>There are other proposed control structures for multiple breaks, but these are generally implemented as exceptions instead.</s>

<s>U svom udžbeniku iz 2004., Dejvid Vat koristi Tenentov pojam of sekvencera za objašnjenje sličnosti prekida sa više nivoa sa return naredbama.</s><s>Vat napominje da klasa sekvencera poznatih kao izlazni sekvenceri, definisanih kao "sekvencer koji prekida izvršavanje komande ili procedure koja prima tekst", obuhvata kako prekide petlji (uključujući prekide sa više nivoa) i return naredbe.</s><s>Međutim, iako se često implementira, return sekvenceri takođe mogu nositi (return) vrednost, dok the break sekvencer implementiran u savremenim jezicima obično ne može.</s>

<s>Varijante i invarijante petlji 
Varijante petlji i invarijante petlji se koriste za izražavanje ispravnosti petlji.</s>

<s>U praksi, varijanta petlje je ceo izraz koji ima početnu ne-negativnu vrednost.</s><s>Vrednost varijante se mora smanjitivati tokom svake iteracije petlje, ali nikad ne sme postati negativna tokom pravilnog izvršavanja petlje.</s><s>Varijante petlje se koriste da zagarantuju okončanje petlje.</s>

<s>Invarijanta petlje je tvrdnja koja mora biti tačna pre prve iteracije u petlji i ostati tačna posle svake iteracije.</s><s>Ovo podrazumeva da kada se petljanje ispravno okonča, i izlazni uslov i invarijanta petlje moraju biti zadovoljeni.</s><s>Invarijante petlje se koriste za praćenje određenih svojstava petlje tokom uzastopnih iteracija.</s>

<s>Neki programski jezici, poput Ajfela sadrže ugrađenu podršku za varijante i invarijante petlji.</s><s>U ostalim slučajevima podrška je dodatak, kao što je specifikacija Java jezika za modeliranje za naredbe u petlji u Javi.</s>

<s>Podjezik petlje 
Neki Lisp dijalekti pružaju bogat podjezik za opisivanje petlji.</s><s>Rani primer se može naći u Konverzionalnom Lisp-u Interlispa.</s><s>Common Lisp  pruža makro za petlje koji implementira takav podjezik.</s>

<s>Tabela sistema koji upravljaju petljama</s>

<s>while (true) se ne računa kao beskonačna petlja u ovu svrhu, jer nije prava jezička struktura.</s><s>C-ova for (init; test; increment) petlja je generalna konstrukcija petlje, ali ne nužno brojeća, iako je često korišćena u tu svrhu.</s><s>Duboki prekidi se mogu ostvariti u jezicima C, C++ i C# korišćenjem oznaka i goto-a.</s><s>Iteracija nad objektima je dodata u PHP 5.
  Petlja sa brojanjem se može imitirati iteracijom nad an listom koja se povećava ili generatorom, na primer Pajtonova range() naredba.</s><s>Duboki prekidi se mogu ostvariti pomoću upravljanja izuzecima.</s><s>Ne postoji specijalna konstrukcija, pošto se while funkcija može koristiti u ovu svrhu.</s><s>Ne postoji specijalna konstrukcija, ali korisnici mogu definisati obične funkcije petlje.</s><s>Nacrt C++11 je uveo for funkciju na osnovu niza.</s><s>U STL postoji std::for_each šablon koji može vršiti iteracije nad STL kolekcijama i pozvati unarnu funkciju za svaki element.</s><s>Funkcionalnost se takođe može konstruisati kao macro nad ovim kolekcijama.</s><s>Petljanje kontrolisano brojanjem je pod uticajem iteracije kroz interval celih brojeva; rani izlaz iz petlje uključujući dodatni uslov za izlaz.</s><s>Ajfel podržava rezervisanu reč retry, ali se ona koristi u upravljanju izuzecima, a ne kontroli petlje.</s><s>Zahteva Java Jezik za Modelovanje (JML).</s><s>Zahteva da varijante petlje budu celi brojevi; transfinit varijante nisu podržane.</s><s>D podržava beskonačne kolekcije, i mogućnost iteracije nad tim kolekcijama.</s><s>Ovo ne zahteva nikakvu specijalnu konstrukciju.</s><s>Duboki prekidi se mogu ostvariti korišćenjem GO TO i procedura.</s><s>Common Lisp prethodi konceptu generičkog tipa kolekcija.</s>

<s>Strukturirano vanlokalno upravljanje tokom 
Mnogi programski jezici, posebno oni u kojima se praktikuje dinamičan stil programiranja, nude konstrukcije za vanlokalno upravljanje tokom.</s><s>One dovode do toga da tok izvršavanja iskoči iz datog konteksta i nastavi se u nekoj određenoj tački.</s><s>Uslovi, izuzeci i kontinuacije su tri opšte vrste vanlokalnih kontrolnih konstrukcija; postoje i kompleksnije vrste, kao što su generatori, koprogrami i ključna reč async.</s>

<s>Uslovi 
PL/I poseduje 22 standardna uslova (npr. ZERODIVIDE SUBSCRIPTRANGE ENDFILE) koji se mogu podići i presresti putem: ON uslovnom akcijom; Programeri takođe mogu definisati i koristiti svoje imenovane uslove.</s>

<s>Poput nestrukturiranog if, samo jedna naredba može biti određena tako da je u mnoštvu slučajeva GOTO potreban za odluku kuda se upravljanje tokom treba nastaviti.</s>

<s>Nažalost, neke implementacije su imale značajan overhead kako sa prostorom tako i sa vremenom (posebno SUBSCRIPTRANGE), tako da su mnogi programeri pokušavali da ih zaobiđu korišćenjem uslova.</s>

<s>Prosti primeri sintakse:
  ON uslov GOTO oznaka</s>

<s>Izuzeci</s>

<s>Savremeni jezici have poseduju specijalizovane strukturirane konstrukcije za upravljanje izuzecima koje se ne oslanja na korišćenje naredbe GOTO ili break (sa više nivoa) ili return naredbama.</s><s>Na primer, u jeziku C++ može se napisati:try {
    xxx1                                  // Negde unutar ovoga
    xxx2                                  //     use: '''throw''' someValue;
    xxx3
} catch (nekaKlasa& someId) { // uhvati vrednost od nekaKlasa
    actionForSomeClass 
} catch (nekiTip& anotherId) { // uhvati vrednost od nekiTip
    actionForSomeType
} catch (...) { // uhvati bilo šta što još nije uhvaćeno
    actionForAnythingElse
}Bilo koji broj i varijetet catch klauzula se može koristiti u gorenavedenom primeru.</s><s>Ako ne postoji catch koji se podudara sa određenim throw, kontrola se vraća nazad kroz pozive potprograma i/ili ugnežđene blokove dok se ne pronađe catch koji se poklapa ili dok se ne dostigne kraj glavnog programa, u tom slučaju se program nasilno gasi sa odgovarajućim obaveštenjem o grešci.</s>

<s>Zahvaljujući uticaju jezika C++, catch je ključna reč rezervisana za deklaraciju upravljača izuzetaka koji radi na principu prepoznavanja šablona u ostalim, danas popularnim, jezicima, kao što su Java ili C#.</s><s>Neki drugi jezici kao što je Ada koriste ključnu reč exception za uvođenje upravljača izuzecima i možda upotrebe drugu ključnu reč (when u jeziku Ada) za poklapanje šablona.</s><s>Nekoliko jezika poput EplSkripta uvode plejsholdere u sintaksu upravljača izuzecima za automatsko vađenje nekoliko delova informacija kada se izuzetak dogodi.</s><s>Ovaj pristup je dat u primeru ispod kosriteći on error konstrukciju u EplSkriptu:try
    set mojBroj to mojBroj / 0
on error e number n from f to t partial result pr
    if ( e = "Nemoguće deliti nulom" ) then display dialog "Ne smete to raditi"
end tryU udžbeniku Davida Vata iz 2004 godine se takođe analizira upravljanje izuzecima u okviru sekvencera (o ovome više piše u ovom članku, u odeljku o ranim izlazima iz petlji.) Vat ističe da abnormalna situacija, kao na primer aritmetičko prelivanje ili input/output kvara kao što je ,, datoteka nije pronađena“, je poput greške koja "se detektuje u nekoj jedinici programa na niskom nivou, ali [za koju] se upravljač u većini slučajeva nalazi u programskoj jedinici visokog nivoa".</s><s>Na primer, program može da sadrži više poziva za čitanje datoteka, ali radnja koja treba da se izvrši u slučaju da datoteka nije pronađena zavisi od značenja (svrhe) te datoteke za program i zato se rutina za upravljanje ovom abnormalnom situacijom ne može naći u sistemskom kodu niskog nivoa.</s><s>Kasnije Vat navodi da uvođenje testiranja statusnih oznaka u pozivaocu, kako bi se to zahtevalo u jednoizlaznom strukturiranom programiranju ili čak (višeizlaznom) povratnom sekvenceru, rezultuje u tome da "aplikacijski kod obično biva pretrpan testovima statusnih oznaka" i da "programer možda ne testira statusnu oznaku kao posledica lenjosti ili zaboravnosti.</s><s>U stvari, abnormalne situacije predstavljene od strane statusnih oznaka su po pravilu ignorisane!" Vat naglašava da u suprotnosti sa testiranjem statusnih oznaka, izuzeci imaju suprotno opšte ponašanje, što dovodi do gašenja programa osim u slučaju da se programer ne pozabavi sa izuzetkom na neki način, npr. dodajući u kod naredbe za ignorisanje.</s><s>Na osnovu ovih argumenata, Vat donosi zaključak da jump sekvenceri ili escape sekvenceri nisu pogodni koliko i sekvencer izuzetaka sa dolenavedenom semantikom.</s>

<s>U jezicima Obdžekt Paskal, D, Java, C#, i Pajton, klauzula finally se može dodati na try konstrukciju.</s><s>Bez obzira na to kako kontrola napušta try, kod unutar finally klauzule se zagarantovano izvršava.</s><s>Ovo je korisno u slučaju pisanja koda koji treba da se odrekne bitnih resursa (kao što je otvorena datoteka ili veza sa bazom podataka) na kraju izračunavanja:FileStream stm = null; // C# primer
try {
    stm = new FileStream ("logfile.txt", FileMode.</s><s>Create);
    return ProcessStuff(stm);             // možda izbaci izuzetak
} finally {
    if (stm != null)
        stm.</s><s>Close();
}Pošto je ovakav šablon dosta zastupljen, C# ima specijalnu sintaksu:using (FileStream stm = new FileStream ("logfile.txt", FileMode.</s><s>Create)) {
    return ProcessStuff(stm);             // možda izbaci izuzetak
}Po napuštanju using-bloka, kompilator garantuje da je stm objekat oslobođen, spajajući tako promenljivu za tok datoteka dok paralelno abstrahuje od sporednih efekata inicijalizacije i oslobađanja datoteke.</s><s>Pajtonova with naredba i Rubijev blok argument za File.open se koriste uz slične ishode.</s>

<s>Svi gorepomenuti jezici definišu standardne izuzetke i okolnosti pod kojima su izbačeni.</s>

<s>Korisnici mogu da izbacuju sopstvene izuzetke; C++ dozvoljava korisnicima da izbace i hvataju bilo koji tip, uključujući osnovne tipove poput int, dok neki drugi jezici ne dozvoljavaju takve radnje.</s>

<s>Kontinuacije</s>

<s>Async 
C# 5.0 je uveo async ključnu reč kao podršku asinhronom I/O u "direktnom stilu".</s>

<s>Generatori 
Generatori, takođe poznati pod nazivom polu-koprograme, dozvoljavaju privremenu predaju upravljanja potrošačkoj metodi, obično koristeći ključnu reč yield.</s><s>Poput async ključne reči, ovo podržava programiranje u "direktnom stilu".</s>

<s>Koprogrami 
Koprogrami su funkcije koje mogu da međusobno predaju kontrolu - oblik ko-operativnog multitaskinga.</s>

<s>Koprogrami se mogu implementirati kao biblioteka u slučaju da programski jezik omogućava kontinuacije ili generatore - tako da razlike između koprograma i generatora u praksi postaju samo tehnički detalj.</s>

<s>Tabela van-lokalnog upravljanja tokom</s>

<s>Predložene kontrolne strukture 
U satiričnom članku lista Datamejšn iz 1973., R. Lorens Klark je predložio da se GOTO naredba može zameniti COMEFROM naredbom, i naveo neke zanimljive primere.</s><s>Ovo je zaista implementrirano u jeziku INTERCAL, a namenski ezoteričnom programskom jeziku.</s>

<s>U svom članku iz 1974.</s><s>"Strukturirano Programiranje sa go to Naredbama", Donald Knut je prepoznao dve situacije koje nisu objašnjene gorenavedenim kontrolnim strukturama, i izneo primere kontrolnih struktura koje bi mogle da upravljaju ovim situacijama.</s><s>Uprkos njihovoj korisnosti, ove konstrukcije i dalje nisu zastupljene u konvencionalnim programskim jezicima.</s>

<s>Petlja sa središnjim testiranjem 
Predloženo od strane  in 1972:
    loop                           loop        xxx1                           read(char);
    while test;                    while not atEndOfFile;
        xxx2                           write(char);
    repeat;                        repeat;
Ako se izostavi xxx1, dobijamo petlju sa testiranjem na vrhu.</s>

<s>Ako se izostavi xxx2, dobijamo petlju sa testiranjem na kraju.</s>

<s>Ako se while izostavi, dobijamo beskonačnu petlju.</s>

<s>Zato ova jedna konstrukcija može zameniti više različitih konstrukcija u većini programskih jezika.</s>

<s>Jedna od mogućih varijanti je da se dozvoli testiranje while naredbe više puta; unutar petlje, ali upotreba exitwhen (pogledaj sledeći odeljak) bolje pokriva ovaj slučaj.</s>

<s>Jezici koji ne poseduju ovu konstrukciju mogu da je imitiraju koristeći idiome beskonačnih petlji sa izlazom:
 while (true) {
     xxx1
     if (not test)
         break     xxx2
 }
U jeziku Ada, gorenavedena konstrukcija petlje (loop-while-repeat) se može predstaviti korišćenjem standardne beskonačne petlje (loop - end loop) koja ima exit when klauzulu u sredini (ne treba pomešati sa exitwhen naredbom iz narednog odeljka).with Ada.</s><s>Text_IO;
with Ada.</s><s>Integer_Text_IO;</s>

<s>procedure Print_Squares is 
    X : Integer;
begin
    Read_Data : loop
        Ada.</s><s>Integer_Text_IO.</s><s>Get(X);
    exit Read_Data when X = 0;
        Ada.</s><s>Text IO.</s><s>Put (X * X);
        Ada.</s><s>Text IO.</s><s>New_Line;
    end loop Read_Data;
end Print_Squares;Dodavanje imena petlji (kao Read_Data u ovom primeru) je opcionalno ali dozvoljava izlaženje iz spoljne petlje koja se nalazi u nekoliko ugnežđenih petlji.</s>

<s>Višestruki rani izlaz/izlaz iz ugnežđenih petlji 
Ovo je predložio Can1974.</s><s>Promenjena verzija je prikazana ovde.
    exitwhen DogađajA or DogađajB or DogađajC;
        xxx
    exits        DogađajA: radnjaA
        DogađajB: radnjaB
        DogađajC: radnjaC
    endexit;exitwhen se koristi za specifikaciju događaja koji se mogu odigrati unutar xxx,
njihovo događanje je dokazano korišćenjem imena događaja kao naredbe.</s>

<s>Kad se neki događaj manifestuje, izvrši se relevantna radnja, i upravljanje se prebacuje odmah nakon endexit.</s>

<s>Ova konstrukcija pruža veoma jasnu razliku između određivanja da li se neka situacija primenjuje i radnje koja se treba izvržiti za tu situaciju.exitwhen je po konceptu slično upravljanju izuzetaka, a u ovu svrhu se koriste izuzeci ili slične konstrukcije u dosta jezika.</s>

<s>Prost primer koji sledi uključuje pretragu dvodimenzionalne tabele u cilju pronalaženja određene stavke.
    exitwhen found or missing;
        for I := 1 to N do            for J := 1 to M do                if table[I,J] = target then found;
        missing;
    exits        found:   print ("item is in table");
        missing: print ("item is not in table");
    endexit''';</s>

<s>Vidi još 
 Grana (računarstvo)
 dijagram upravljanja tokom
 Grafik upravljanja tokom
 Tabela upravljanja
 Koprogram
 Ciklomatička kompleksnost
 Dijagram toka
 GOTO
 Džeru, pomaže pri učenju kontrolnih struktura
 Glavna petlja
 Rekurzija
 Raspoređivanje
 Špageti kod
 Strukturirano programiranje
 Potprogram
 Naredba zamene, uslovno menja tok upravljanja</s>

<s>Reference</s>

<s>Spoljašnje veze</s>

<s>Go To Statement Considered Harmful
 A Linguistic Contribution of GOTO-less Programming 
  PDF (2.88 MB)
  PDF (31.4 MB)</s>

<s>Programske konstrukcije</s>

