Kurs C# cz. 7 – pętle

UWAGA! Już teraz sprawdź NOWY, JESZCZE LEPSZY kurs C#, którzy przygotowałem. Znajdziesz go po TYM linkiem.

W poprzedniej części kursu poznaliście sposób na zmuszenie waszych programów do podejmowania decyzji. Tym razem sprawimy, że aplikacja będzie mogła powtarzać operacje dopóki nie stwierdzimy, że już wystarczy. Oto moim drodzy przyszła pora na zapoznanie się z kolejnym tworem dostępnym w naszym ulubionym języku czyli z pętlami.

W dużym skrócie pętle pozwalają nam dodać w programie możliwość powtórzenia danej instrukcji N-krotnie, gdzie to N to może być zarówno jakaś konkretna, wpisana przez nas liczba, ale też np. ilość elementów w liście.

W języku C# właściwie można wyróżnić 3 typy pętli dostosowane do różnych okoliczności:

• wykonywania się N-razy
• wykonywania się dopóki warunek jest spełniony
• wykonywania się dla wszystkich elementów z listy

Dwa pierwsze typy mogą być używane zamiennie, jak również zostać wykorzystane w 3 przypadku, ale ich budowa mimo wszystko sprawia, że najwygodniej zastosować je w konkretnych celach.

Dobra, pora na konkrety. Ponieważ jest to już 7 część kursu i coraz bardziej oswajacie się z językiem C# to moje teksty zawierają coraz mniej lania wody, w końcu po co przedłużać i mówić o rzeczach dla Was oczywistych ;)

Ok, tak więc pętle jakie mamy dostępne w C# to:

1. for – pętla, którą zazwyczaj będziemy używać kiedy będziemy chcieli wykonać kod określoną ilość razy. Jego budowa jest następująca:

for (inicjalizator; warunek; iterator)
{
    //kod
}

Inicjalizator to miejsce gdzie możemy zdefiniować zmienne, w szczególności zmienną, która posłuży nam do zliczania kolejnych przejść pętli. Warto w tym miejscu wyjaśnić, że przejściem pętli będziemy nazywali każde wykonanie kodu znajdującego się wewnątrz niej.

Warunek jest miejscem gdzie podajemy warunek mówiący o tym, czy powinno być wykonane kolejne przejście pętli. Jeśli jest spełniony to pętla „leci” dalej, w przeciwnym wypadku pętla zostanie zakończona. Warunek ten jest sprawdzany także przed pierwszym przejściem pętli dlatego możliwe jest, że pętla nie wykona się ani razu.

Iterator to kod wykonywany po zakończeniu przejścia pętli. Tutaj wpisujemy kod, który zmienia wartość naszej zmiennej jeśli odliczamy ilość przejść pętli.

Przykład prostej pętli for wygląda następująco:

for (var i = 0; i < 5; i++)
{
    //kod
}

W powyższym przykładzie kod znajdujący się wewnątrz pętli wykona się 5 razy, ponieważ zaczynamy liczyć od 0 (zmienną tworzymy w miejscu, które opisałem wcześniej jako inicjalizator i ustawiamy jej wartość początkową), następnie mamy warunek sprawdzający czy wartość zmiennej i jest mniejsza od 5, jeśli tak jest to pętla wykonuje kod znajdujący się w jej wnętrzu. Kiedy kod się wykona wykonywany jest fragment i++  zwiększający wartość zmiennej i  o 1.

2. while – ta pętla ma prostszą budowę niż poprzednia ponieważ zawiera jedynie warunek wykonania. Wygląda ona następująco:

while (warunek)
{
    //kod
}

Tutaj sprawa jest prosta – pętla będzie wykonywać kolejne przejścia do czasu, aż podany warunek będzie spełniony. Pętla doskonale się sprawdza kiedy nie mamy określonej ilości iteracji np. dopóki użytkownik nie wciśnie konkretnego klawisza. Raczej nie ma sensu podawać tutaj przykładu, w końcu po poprzedniej części wiecie już co nieco o warunkach logicznych ;)

Na początku pisałem, że będę mówił o 3 pętlach, ale tak jak w przypadku instrukcji warunkowych mieliśmy w jednym przypadku dwie wersje także tutaj sytuacja wygląda podobnie. Mianowicie poza pętlą while istnieje bardzo podobna do niej pętla do…while. Jej zasada działania jest bardzo podobna, różni się (poza minimalnie inną strukturą) jedynie tym, że wykonuje się co najmniej raz. Wygląda tak:

do
{
    //kod
}
while(warunek);

Jak widzimy warunek w tym wypadku znajduje się na końcu. A więc kiedy program dojdzie do tego momentu najpierw wykona to co znajduje się w bloku do, a dopiero potem sprawdzi warunek i zdecyduje czy wykonać kolejne przejście.

3. foreach – ostatnia z omawianych pętli. W tym wypadku mamy specyficzny rodzaj pętli używany konkretnie do działania na kolejnych elementach wszelkiego rodzaju list, kolekcji itd. Budowę ma następującą:

foreach (var element in lista)
{
    //kod
}

I w tym miejscu warto o trochę więcej słów wyjaśnienia.

var element jest to zmienna, w której znajdować się będą kolejne elementy z obiektu implementującego interfejs IEnumerable, w tym wypadku dla przykładu nazwanym lista. Użyłem słowa kluczowego var ale ogólnie ta zmienna musi być tego samego typu co elementy w liście, ale to chyba jest oczywiste. Słówko in jest tutaj słowem kluczowym, po prostu jest bo musi być. I teraz całość działa w ten sposób, że kolejne iteracje pętli powodują umieszczenie w w zmiennej element kolejnym wartości znajdujących się w liście, od pierwszego do ostatniego. Tak więc jeśli nasza lista/tablica/kolekcja ma 3 elementy to pętla wykona się 3 razy.

Wewnątrz tej pętli mamy dostęp do zmiennej element. Ważne żeby zapamiętać, że nie możemy korzystając z tej pętli modyfikować elementów w liście, a więc ich usuwać albo zamieniać na inne.

Dobra, to przedstawiłem Wam 3 rodzaje list, które możecie używać w programach pisanych w języku C# to teraz jeszcze powiem o 2 słowach kluczowych związanych z nimi:

1. break – umożliwia zakończenie pętli zanim ta wykona wszystkie przewidziane iteracje. Przykładowo kiedy szukamy jakiejś wartości w liście i ją znajdziemy to nie ma potrzeby czekać aż pętla sprawdzi wszystkie elementy. Przykład:

for (int i = 0; i < 10; i++)
{
    //kod
    if (i == 5)
    {
        break;
    }
}

W powyższym kodzie pętla powinna wykonać się 10 razy jednak kiedy warunek wewnątrz zostanie spełniony, a więc kiedy zmienna i osiągnie wartość 5 to pętla zakończy swoje działanie ponieważ wykonana zostanie instrukcja break.

2. continue – to słowo kluczowe również wpływa na przejścia pętli. Konkretnie powoduje natychmiastowe zakończenie danej iteracji pętli i przejście do następnej. Tak więc jeśli chcemy, żeby dane przejście pętli nie wykonało się do końca to korzystamy z instrukcji continue.

I to na tyle w temacie pętli w języku C#. Cały czas idziemy do przodu, mimo, że powoli :P