Ko želimo v programskem jeziku nek postopek ponoviti večkrat, v ta namen uporabljamo zanke.

Recimo, da želimo izpisati vsa števila od 1 do 10. To lahko storimo ročno, zato ker je dokaj malo dela. Enostavno 10-krat izpišemo ukaz Console.Write() ali Console.WriteLine(), ki nam vsako število zapiše v svojo vrsto in kot argument stavka vnesemo številke od 1 do 10 in dobimo izpis števil na zaslon.

Če pa imamo nalogo, da izpišemo vsa števila od 1 do 10000000, tega seveda ne počnemo z ročnim vnosom, kot v zgornjem primeru. Takrat uporabimo zanko. Obstaja več različnih zank, v teh prosojnicah si bomo ogledali zanki do while ter foreach.

• Oblika zanke je:

do {stavek;} while (pogoj);

Najprej zapišemo besedo do, kar pomeni izvajaj tisto kar je v stavek, vse dokler je izpolnjen pogoj v while.

Poznamo še eno zelo podobno zanko, to je zanka while. Njena oblika je:

while(pogoj) {stavek;}

• Obstaja bistvena razlika med zankama. Pri zanki while program najprej prebere pogoj. Če na začetku le-ta ni izpolnjen, se zanka zaključi in ne naredi nič. Če pa pogoj je izpolnjen, se izvede stavek v zanki (v zavitih oklepajih). Pogojev in stavkov je lahko več. Zanka se izvaja, dokler je pogoj izpolnjen, nato se konča.

• Pri do while zanki pa opazimo, da je stavek do še pred pogojem, kar pomeni, da se ob zagonu programa izvede stavek v delu do tudi, če pogoj v while ni izpolnjen. Torej se do while zanka vedno izvede vsaj enkrat. Podobno kot while se izvaja, dokler je pogoj izpolnjen.

Ko rešujemo nek problem z do while ali z while zanko, se izvajanje konča, ko najdemo tisto, kar smo iskali oz. ko sami prekinemo zanko s stavkom break.

Recimo da za primer vzamemo izpis celih števil od i do 10, pri čemer i preberemo.

• Ideja: Na zaslon bomo izpisovali vsa števila od i do vključno 10.

• Problem: Kaj če uporabnik vnese število, ki je večje od 10? Zato poskrbimo z začetnim stavkom if, ki preveri ali je število ustrezno. Če ni, s stavkom break prekinemo izvajanje in napišemo opozorilo uporabniku.

• Oblika:

Kako pa izgleda program v C#?

Oblika:

Komentar.

• Uporabnik vnese število i, C# ga prebere kot niz z ukazom Console.ReadLine(). Zato ga z metodo int.parse() pretvorimo v celo število.
• Tukaj se dobro vidi razlika med while in do while zankama. Če damo v zanko if pogoj, da je i>10, nam bo ob vnosu 10-ke izpisal 10 in 11, kar pa ne želimo (vemo, da se do del vedno izvede!). Zato v pogoj napišemo i>=10. Pri while zanki bi bilo dovolj, da v pogoj napišemo i<10.
• če število i ni ustrezno, prekinemo izvajanje zanke s stavkom break;
• izpišemo opozorilo uporabniku
• če pa je število manjše od 10, ga izpišemo
• nato pa povečujemo za 1
• dokler ni manjše od 10

Uporabnik za i vnese 4 in dobi naslednji rezultat:

Še en primer:

Poglejmo si še en primer. Recimo, da želimo izračunati "dolžino" števila, ki ga vnese uporabnik, tj. koliko števk ima. Število 67 je dolžine 2, število 128907 je dolžine 6 itd.

• Ideja: Program prebere število in izračuna njegovo dolžino ter le-to izpiše na zaslon.
• Problem: Kaj, če je število negativno? Program namreč ne more minusa šteti k dolžini števila. Za to poskrbimo s preverjanjem že na začetku.

Program bi izgledal nekako takole:

Komentar.

• Uporabnik vnese število, ki ga program prebere kot niz
• število pretvorimo v celo število z metodo int.parse()
• če je število manjše od 0, ga pomnožimo z 1, saj nas zanima dolžina števila, minusa ne štejemo zraven!
• definiramo števec in ga postavimo na 0 (ta bo štel števke)
• definiramo tudi spreemenljivko enice
• v do delu izračunamo enice ter števec povečamo za 1, številu pa odrežemo enice
• to počnemo, dokler je število večje od 0
• na koncu izpišemo, koliko je število dolgo
• Pozor! Seveda moramo paziti, da ne vnesemo prevelikega števila, ki ni v obsegu podatkovnega tipa integer!

Še en primer:

In še primer za negativno število:

Večino programov, ki jih napišemo z while (do while) zanko, lahko napišemo tudi z zanko for ali foreach. Dogovor je tak, da če poznamo število korakov, uporabimo for zanko, sicer pa while zanko; ni pa nujno. Tudi for zanko uporabljamo takrat, ko želimo nek postopek ponoviti večkrat.

• Oblika zanke je:

for (začetek, do kam, korak) { stavek1; stavek2; . .

Najprej zapišemo besedo for, nato pa v oklepajih navedemo 3 parametre. Prvi je začetek, tj. nek števec, ki ga lahko definiramo že prej in mu v zanki določimo začetek ali pa ga definiramo v zanki ter mu določimo začetno vrednost. Parameter do kam nam pove, do kam bo tekla zanka, oz. kdaj naj se konča. Tretji parameter, tj. korak pa nam pove, kako naj se povečuje/zmanjšuje števec. Zanka se izvaja, dokler ne pridemo do konca, torej dokler je izpolnjen 2. pogoj (do kam). Izvajajo se stavki stavek1 do stavekn. Teh stavkov je lahko poljubno monogo.

Poznamo še eno obliko for zanke, to je zanka foreach. Le-ta deluje na že ustvarjenih tabelah. Recimo, da imamo primer, ko želimo izpisati cela števila od 1 do 10. S for zanko definiramo števec, ki bo tekel od 1 do 10 ter se bo po vsakem koraku povečal za 1. Na zaslon izpisujemo vrednost števca. Če pa želimo isto nalogo opraviti s foreach zanko pa moramo najprej definirati tabelo števil od 1 do 10, nato pa iz nje na vsakem koraku vzeti en element in ga izpisati na zaslon.

• Oblika zanke je:
  int[] tabela = {1,2,3,4,5,6,7,8,9,10};
  **foreach (int stevec in tabela)
  {
        izpiši stevec;         .
  }
  
  

Pa si poglejmo isti primer kot pri while zankah. Program bo izpisal vsa cela števila od 1 do 10.

• s for zanko:
  for (int i = 1; i < 11; i++)
              {
                  Console.WriteLine(i);
              }
              Console.ReadLine();
  

• s foreach zanko:

int[] tabela = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            foreach (int i in tabela)
            {
                Console.WriteLine(i);
            }
            Console.ReadLine();

• Komentar k primeru s for zanko:
• Števec i definiramo kar v zanki in mu takoj določimo vrednost 1 s stavkom int i = 1
• drugi parameter je pogoj, do kdaj naj se zanka izvaja, v našem primeru se izvaja, dokler je i manjši od 11 oz. dokler ni i enak 10
• s Console.WriteLine() funkcija na zaslon izpiše vrednost i-ja
• v prvem koraku program izpiše vrednost 1
• ker je pogoj izpolnjen (1<11), nadaljuje z izvajanjem naslednjega stavka, tj. i++, ki prejšnjo vrednost i-ja poveča za 1
• sedaj je i enak 2, program ga izpiše na zaslon
• nato še 3, ... do 10
• ko program izpiše zadnjo številko, to je 10, se ponovno izvede stavek i++
• sedaj je i enak 11
• in ker 11 ni manjše od 11, se izvajanje zaključi

• Komentar k primeru s foreach zanko:
• kot sem že zgoraj omenila, foreach zanka deluje na že ustvarjeni tabeli
• tabelo lahko ustvarimo na več načinov, jaz sem jo ročno - z vnosom števil od 1 do 10 (to si lahko privoščimo zato, ker je tako malo števil)
• tabela je tipa integer, na to moramo biti pozorni pri parametru foreach zanke
• v zanki definiramo spremenljivko i, ki mora biti istega tipa kot elementi v tabeli
• s Console.WriteLine() izpisujemo vrednost i-ja na vsakem koraku

• Kot vidimo iz kode v zgornjem primeru, lahko isto nalogo predstavimo z obema zankama.
• Opazimo, da pri for zanki moramo sami določiti pogoje ter korak
• foreach zanka ima vse te parametre že vgrajene
• vemo, da se zanka sprehaja po tabeli, dokler ni konec tabele
• zelo moramo biti pozorni na to, da pri foreach zanki uporabimo isti tip podatka za števec kot je tip podatkov v tabeli!

Poglejmo si kaj dobimo pri for zanki:

in kaj pri foreach zanki:

Rezultat je seveda enak, saj tudi mora biti!

Zanke delujejo tudi na nizih. Poglejmo si primer s foreach zanko. Recimo, da želimo iz danega seznama črk izpisati besedo.

char[] tabela = {'p','r','o','g','r','a','m','i','r','a','n','j','e'};
            foreach (char znak in tabela)
            {
                Console.Write(znak);
            }
            Console.ReadLine();

• Komentar
• najprej definiramo tabelo tipa char, ki je znakovni tip
• nato v foreach zanki definiramo novo spremenljivko, ki gre po tabeli
• s Console.Write() izpisujemo črke na zaslon, eno za drugo
• če bi uporabili Console.WriteLine() pa bi dobili vsak znak v svojo vrsto
• Console.ReadLine() uporabimo zato, da je rezultat na zaslonu, dokler ne pritisnemo tipko Enter

Rezultat: