# Dokumentacja programistyczna języka &logo; &kturtle;

Poniżej znajduje się dokumentacja języka &logo; używanego przez &kturtle;. W tym rozdziale najpierw zostaną krótko wymienione różne typy instrukcji. Następnie zostaną objaśnione komendy. Po nich kontenery, terminy matematyczne, zapytania oraz kontrolery wykonawcze. Na końcu pokazane zostanie jak za pomocą nauczyciela tworzyć własne komendy.

## Różne typy instrukcji

Jak każdy inny język programowania ,LOGO posiada różne typy wyrazów i symboli. Oto różnice pomiędzy typami i krótkie wyjaśnienia.

### Komendy

Przy użyciu komend wskazujemy &kturtle; czynności do wykonania. Niektóre z komend potrzebują argumentów wejściowych a inne wyjściowych.

    # naprzód to komenda z argumentem wejściowym, tutaj jest to liczba 100:
    naprzód 100

Szczegółowy opis wszystkich komend &kturtle; znajduje się tutaj.

### Liczby

Każdy użytkownik z pewnością wie trochę o liczbach. Sposób w jaki liczby używane są przez &kturtle; niezbyt różni się od języka mówionego czy matematyki.

Mamy liczby naturalne: `0`, `1`, `2`, `3`, `4`, `5`, itd. Liczby ujemne: `-1`, `-2`, `-3`, itd. Oraz liczby dziesiętne np: `0.1`, `3.14`, `33.3333`, `-5.05`, `-1.0`.

Liczby mogą być używane w obliczeniach matematycznych oraz zapytaniach. Mogą być również wkładane do kontenerów.

W edytorze kodów liczby są podświetlone na niebiesko.

### Łańcuchy znaków

Najpierw przykład:

    pisz "Cześć, Jestem łańcuchem znaków."

W tym przykładzie `pisz` jest komendą a `"Cześć, Jestem łańcuchem znaków."` łańcuchem znaków. Łańcuch zaczyna i kończy się znakiem `"`, dzięki niemu &kturtle; rozpoznaje łańcuch znakowy.

Łańcuchy mogą być wkładane do kontenerów. ale nie mogą być używane w obliczeniach matematycznych i zapytaniach.

W edytorze kodów liczby są podświetlone na kolor ciemnoczerwony.

### Nazwy

Przy użyciu języka programowania &logo; tworzy się nowe obiekty. Pisząc programy często potrzebować będziemy kontenerów a w niektórych przypadkach nauczyciela do tworzenia nowych komend. Tworząc kontener lub nową komendę za pomocą nauczyciela należy określić ich nazwę.

Można wybrać dowolną nazwę, pod warunkiem, iż nie odnosi się ona już do niczego. Np. nie można nazwać kontenera naprzód, jako, że jest to nazwa komendy.

    # tutaj naprzód jest używane jako kontener, ale ta nazwa jest już używana jako komenda
    # zatem pokaże się komunikat błędu:
    naprzód = 20

    # natomiast działać będzie:
    naprzód 20

Nazwy mogą zawierać tylko litery, cyfry oraz linie poziome (_). ale muszą zaczynać się od litery.

Więcej przykładów oraz dokładniejsze wyjaśnienie znajduje się w dokumentacji kontenerów oraz nauczyciela.

### Przypisania

Przypisań dokonuje się za pomocą symbolu `=`. W językach programowania zaleca się czytanie symbolu `=` nie jako równa się ale jako oznacza. Zwrot równa się bardziej odpowiada symbolowi `==` będącemu zapytaniem.

Przypisań dokonuje się z dwóch powodów, (1) by dodać zawartość do kontenerów, oraz (2) by zmodyfikować zawartość kontenerów. Na przykład:

    x = 10
    # kontener x zawiera teraz liczbę 10
    W = "Mój wiek to: "
    # kontener W zawiera teraz łańcuch"Mój wiek to: "
    # poniższa instrukcja drukuje na płótnie zawartość kontenerów 'W' i 'x'
    pisz W + x

Więcej przykładów znajduje się z sekcji wyjaśniającej kontenery.

### Symbole matematyczne

&kturtle; rozpoznaje wszystkie podstawowe symbole matematyczne: plus (`+`), minus (`-`), mnożenie (`*`), dzielenie (`/`) oraz nawiasy `(` i `)`.

Dokładniejsze wyjaśnienie i więcej przykładów znajduje się w sekcji matematyka.

### Zapytania

Możemy zadać proste pytania, na które możliwe są jedynie odpowiedzi 'prawda' lub 'fałsz'.

Użycie pytań jest dokładniej wyjaśnione w sekcji zapytania.

### Wyrazy łączące pytania

Zapytania mogą być składane razem dzięki tak zwanym wyrazom łączącym. Takimi wyrazami są `i`, `lub`, oraz: `nie`.

Użycie wyrazów łączących pytania wyjaśnione jest w sekcji Łączenie pytań.

### Komentarze

Komentarzami są linie zaczynające się od `#`. Na przykład:

    # to jest komentarz!
    pisz "to nie jest komentarz"
    # poprzednia linia nie jest komentarzem natomiast wcześniejsza jest:
    # pisz "to nie jest komentarz"

Do kodu możemy dodawać komentarze dla nas bądź dla innych czytających. Komentarzy używa się do: (1) dodawania krótkich opisów programu, (2) wyjaśniania jak działa dany fragment kodu, oraz (3) wykomentowania linii kodu, które powinny być ignorowane (chwilowo) (patrz ostatnia linia przykładu).

W edytorze kodów komentarze są podświetlone na kolor ciemnożółty.

## Komendy

Używając komend mówimy żółwiowi lub &kturtle; by wykonywał konkretne polecenia. Niektóre komendy wymagają argumentów wyjściowych a niektóre dają coś na wyjściu. W tej sekcji wyjaśniamy działanie wszystkich komend używanych przez &kturtle;. Należy zauważyć, że wszystkie omawiane tutaj wbudowane komendy są w edytorze kodu podświetlone na kolor ciemnozielony, co pomaga je rozróżnić.

### Poruszanie żółwia

Do poruszania żółwia po ekranie służy kilka komend

#### naprzód (np)

naprzód

-     naprzód X

  `naprzód` przesuwa żółwia do przodu o X pikseli. Gdy ołówek jest skierowany w dół żółw zostawia ślad. `naprzód` może być użyty za pomocą skrótu `np`

#### wstecz (ws)

w tył

-     wstecz X

  `wstecz` przesuwa żółwia do tyłu o X pikseli. Gdy ołówek jest skierowany w dół żółw zostawia ślad. `wstecz` może być użyty za pomocą skrótu `ws`.

#### obróć_w_lewo (lw)

skręć w lewo

-     obróć_w_lewo X

  `obróć_w_lewo` powoduje, że żółw skręca w lewo o X stopni. `obróć_w_lewo` może być użyty za pomocą skrótu `lw`.

#### obróć_w_prawo (pw)

skręć w prawo

-     obróć_w_prawo X

  `obróć_w_prawo` powoduje, że żółw skręca w prawo o X stopni. `obróć_w_prawo` może być użyty za pomocą skrótu `pw`.

#### kierunek (kie)

kierunek

-     kierunek X

  `kierunek` ustawia kierunek ruchu żółwia na X stopni licząc od zera, nie wiąże się to z poprzednim kierunkiem ruchu żółwia. `kierunek` może być użyty za pomocą skrótu `kie`

#### środek

środek

-     środek

  `środek` przesuwa żółwia na środek płótna.

#### idź

idź

-     idź X,Y

  Komenda `idź` przesuwa żółwia na wskazaną lokalizację na płótnie. Ta lokalizacja to X pikseli od lewej strony płótna oraz Y pikseli od góry płótna. Użycie komendy `idź` nie powoduje, że żółw rysuje linie.

#### idźx

idźx

-     idźx X

  `idźx` powoduje przesunięcie żółwia do pozycji X pikseli od lewej strony płótna, podczas gdy wysokość pozostaje bez zmiany.

#### idźy

idźy

-     idźy Y

  `idźy` powoduje przesunięcie żółwia do pozycji Y pikseli od góry płótna, podczas gdy odległość od lewego brzegu pozostaje bez zmian.

### Żółw posiada ołówek

Żółw posiada ołówek, który rysuje linię gdy żółw się przesuwa. Istnieje kilka komend zarządzających ołówkiem. W tej sekcji wyjaśniamy te komendy.

#### podnieś (pod)

podnieś

-     podnieś

  `podnieś` podnosi ołówek z płótna. Gdy ołówek jest podniesiony nie będzie rysowana linia gdy porusza się żółw. Zobacz także `opuść`. `podnieś` może być użyte za pomocą skrótu `pod`.

#### opuść (opu)

opuść

-     opuść

  `opuść` kładzie ołówek na płótnie. Gdy ołówek jest położony będzie rysowana linia gdy porusza się żółw. Zobacz także `podnieś`. `opuść` może być użyte za pomocą skrótu `opu`.

#### ustaw_grubość_pisaka (ugp)

ustaw_grubość_pisaka

-     ustaw_grubość_pisaka X

  `ustaw_grubość_pisaka` ustawia grubość ołówka (grubość rysowanej linii) na X pikseli. `ustaw_grubość_pisaka` może być użyte za pomocą skrótu`ugp`.

#### kolor_pisaka (kp)

kolor ołówka

-     kolor_pisaka R,G,B

  `kolor_pisaka` ustawia kolor ołówka. `kolor_pisaka` przyjmuje kombinację RGB jako argument wejściowy. `kolor_pisaka` może być użyty za pomocą skrótu `kp`.

### Komendy do zarządzania płótnem

Istnieje kilka komend sterujących płótnem.

#### przeskaluj_tło (pt)

przeskaluj_tło

-     przeskaluj_tło X,Y

  Za pomocą komendy `przeskaluj_tło` można ustawić rozmiar płótna. Komenda przyjmuje jako argumenty wejściowe liczby X i Y, gdzie X jest nową szerokością płótna w pikselach, a Y jest nową wysokością płótna w pikselach. `przeskaluj_tło` może być użyte za pomocą skrótu `pt`.

#### kolor_tła (kt)

kolor_tła

-     kolor_tła R,G,B

  Komenda `kolor_tła` ustawia kolor płótna. `kolor_tła` przyjmuje kombinację RGB jako argument wejściowy. `kolor_tła` może być użyty za pomocą skrótu `kt`.

#### zawijaj

zawijaj

-     zawijaj

  Przy pomocy komendy `zawijaj` można włączyć zawijanie płótna. Znaczenie terminu zawijania znajduje się w słowniku.

#### nie_zawijaj

nie_zawijaj

-     nie_zawijaj

  Przy pomocy komendy `zawijaj` można wyłączyć zawijanie płótna. Oznacza to, że żółw może wyjść poza płótno i zgubić się. Znaczenie terminu zawijania znajduje się w słowniku.

### Komendy czyszczenia

Istnieją dwie komendy czyszczące płótno.

#### czyść (cs)

czyść

-     czyść

  Komenda `czyść` usuwa wszystkie rysunki z płótna. Pozostałe rzeczy zostają: pozycja i kąt ruchu żółwia, kolor płótna, widoczność żółwia, i rozmiar płótna. `czyść` może być użyta za pomocą skrótu `cs`.

#### zeruj

zeruj

-     zeruj

  Komenda`zeruj` czyści bardziej dokładnie niż komenda `czyść`. Po wykonaniu komendy `zeruj` płótno wygląda jak po rozpoczęciu pracy &kturtle;. Żółw umieszczony jest na środku ekranu, kolor płótna jest biały, żółw rysuje czarną linię.

### Żółw jest sprajtem

Najpierw krótkie wytłumaczenia czym jest sprajt: sprajty to małe obrazki, które mogą być przesuwane po ekranie, jak często to widzimy w grach komputerowych. Nasz żółwik jest także sprajtem. Dokładniejsze wyjaśnienie znajduje się w słowniku pod hasłem sprajty.

Poniżej znajduje się pełen przegląd komend do pracy ze sprajtami.

[Obecna wersja &kturtle; nie obsługuje jeszcze użycia sprajtów innych niż żółw. Kolejne wersje będą umożliwiać zmianę żółwia na coś zaprojektowanego przez siebie]

#### pokaż

pokaż (pk)

-     pokaż

  Komenda `pokaż` sprawia, że żółw staje się widoczny (gdy był ukryty). `pokaż` może być użyty za pomocą skrótu `pk`.

#### ukryj (uk)

ukryj

-     ukryj

  Komenda `ukryj` sprawia, że żółw jest ukrywany. Opcja używana gdy żółw nie pasuje do rysunku. `pokaż` może być użyty za pomocą skrótu `uk`.

### Czy żółw może pisać?

Odpowiedź brzmi: tak. Żółw potrafi pisać: wszystko co każe mu się pisać.

#### pisz

pisz

-     pisz X

  `pisz` każe żółwiowi pisać podany tekst na płótnie. `pisz` przyjmuje jako argumenty wejściowe liczy i łańcuchy znaków. Używając symbolu + można `napisać` kilka liczb i łańcuchów znaków. Oto mały przykład:

      rok = 2003
      autor = "Cies"
      wypisuje autor + " rozpoczął projekt KTurtle w roku " + rok + " i dalej z radością nad nim pracuje!"

#### wielkość_czcionki

wielkość_czcionki

-     wielkość_czcionki X

  `wielkość_czcionki` ustawia rozmiar czcionki używany przy`wypisywaniu`. `wielkość_czcionki` przyjmuje liczbę jako argument wejściowy. Rozmiar czcionki podawany jest w pikselach.

### Komenda rzucająca kości za użytkownika

Komenda rzucająca kości za użytkownika, nazywa się `losowo`, i jest bardzo użyteczna różnych przypadkach.

losowo

-     losowo X,Y

  `losowo` przyjmuje argumenty wejściowe i daje argumenty wyjściowe. Jako argumenty wejściowe wymagane są dwie liczby, pierwsza (X) określa minimum argumentu wyjściowego, natomiast druga (Y) określa maksimum. Argument wyjściowy jest losowo wybraną liczbą z przedziału ograniczonego przez podane minimum i maksimum. Oto przykład:

      powtórz 500 [
        x = losowo 1,20
        naprzód x
        obróć_w_lewo 10 - x
      ]

  Używając komendy `losowo` można dodać odrobiny chaosu do programu.

### Argumenty wejściowe i pomoc przez okna dialogowe

Okno dialogowe jest małym wyskakującym okienkiem, które zawiera pomoc dotyczącą argumentów wejściowych. &kturtle; posiada dwie komendy do okien dialogowych, mianowicie: `wiadomość` i `okno_wejścia`

#### wiadomość

wiadomość

-     wiadomość X

  Komenda `wiadomość` przyjmuje jako argument wejściowy łańcuch znaków. Pokazuje się okno dialogowe zawierające tekst z łańcucha.

      rok = 2003
      autor = "Cies"
      wypisuje autor + " rozpoczął projekt KTurtle w roku " + rok + " i dalej z radością nad nim pracuje!"

#### okno_wejścia

okno_wejścia

-     okno_wejścia X

  `okno_wejścia` jako argument wejściowy przyjmuje łańcuch znaków. Pokazuje się wyskakujące okno dialogowe zawierające tekst z łańcucha, tak jak wiadomość. Dodatkowo dodaje to pole wejściowe do okna. Przez to pole użytkownik może wprowadzić liczbę lub łańcuch który może być przechowywany w kontenerze. Na przykład

      wejście = okno_wejścia "Jaki jest Twój wiek?"
      wyjście = 2003 - wejście
      pisz "W 2003 będziesz mieć " + wyjście + " lat."

  Gdy użytkownik kasuje okno dialogowe, lub nie wprowadza niczego kontener jest opróżniany.

## Kontenery

Kontenery są znakami bądź wyrazami używanymi przez programistów do przechowywania liczb lub tekstu. Kontenery zawierające liczby nazywane są zmiennymi, kontenery zawierające tekst nazywane są łańcuchami.

Kontenery nie używane nie zawierają niczego. Przykład:

    pisz N

Nie zostanie wyświetlone nic. Jeżeli spróbujemy wykonać jakieś działanie matematyczne z pustym kontenerem pojawi się komunikat błędu.

### Zmienne: kontenery liczbowe

Rozpoczniemy od przykładu:

    x = 3
    pisz x

W pierwszej linii litera `x` staje się zmienną (kontenerem liczbowym). Jak widać wartość zmiennej `x` ustawiona jest na 3. W drugiej linii wartość jest wypisywana.

Jeżeli chcielibyśmy wypisać znak x powinniśmy napisać

    pisz "x"

To było łatwe, teraz trudniejszy przykład:

    A = 2004
    B = 25
    C = A + B

    # kolejna komenda wyświetli "2029"
    pisz C
    wstecz 30
    # kolejna komenda wyświetli "2004 plus 25"
    pisz A + " plus " + B
    wstecz 30
    # kolejna komenda wyświetli "1979"
    pisz A - B

W dwóch pierwszych linijkach zmienne `A` i `B` zostają ustawione na 2004 i 25. W trzeciej linii `C` zostaje ustawiona jako `A + B`, co wynosi 2029. Reszta przykładu składa się z 3 komend `pisz` z `wstecz 30` pomiędzy. `wstecz 30` zapewnia, że każde wyjście drukowane jest w nowej linii. W przykładzie można zaobserwować użycie zmiennych w obliczeniach matematycznych.

### Kontenery zawierające tekst (łańcuchy)

W kodzie programistycznym zwykły tekst rozpoczyna się i kończy zazwyczaj cudzysłowami. Do tej pory widzieliśmy:

    pisz "Cześć programisto!"

Tekst jest ograniczony cudzysłowami. Kawałki tego tekstu nazywamy łańcuchami.

Łańcuchy mogą być przechowywane w kontenerach tak jak liczby. Łańcuchy są bardzo podobne do zmiennych. Największą różnicą jest to, że zamiast liczb zawierają tekst. Z tego powodu łańcuchy nie mogą być używane w wyrażeniach matematycznych i pytaniach. Przykład użycia łańcuchów:

    x = "Cześć "
    imię = okno_wejścia "Podaj swoje imię..."
    pisz x + imię + ", jak się masz?"

W pierwszej linii `x` jest ustawiane jako Cześć . W drugiej linii łańcuch `imię` jest ustawiany jako wyjście komendy `okno_wejścia`. W kolejnej linii program wypisuje kompozycję trzech linii na płótnie.

Program poprosi o podanie imienia. Po wprowadzeniu np. imienia Paweł, program wypisuje Cześć Paweł jak się masz?. Należy zauważyć, że plus (+) jest jedynym symbolem matematycznym używanym z łańcuchami.

## Czy żółw zna matematykę?

Tak, &kturtle; zna matematykę. Potrafi dodawać (+), odejmować (-), mnożyć (*), a także dzielić (/). Oto przykład, który korzysta ze wszystkich tych działań:

    a = 20 - 5
    b = 15 * 2
    c = 30 / 30
    d = 1 + 1
    pisz "a: "+a+", b: "+b+", c: "+c+", d: "+d

Czy wiesz jakie wartości mają zmienne a, b, c oraz d? Proszę zauważyć przypisanie wartości zmiennej za pomocą symbolu `=`.

Chcąc dokonać prostego obliczenia wpisujemy po prostu:

    pisz 2004-12

Teraz przykład z nawiasami:

    pisz ( ( 20 - 5 ) * 2 / 30 ) + 1

Wyrażenia wewnątrz nawiasów obliczane są najpierw. W tym przykładzie, najpierw zostanie obliczone 20-5, później pomnożone 2, podzielone przez 30, i zostanie dodane 1(co daje 2).

## Zadawanie pytań, otrzymywanie odpowiedzi...

`jeśli` i `dopóki` są instrukcjami sterującymi które będą omawiane w następnej sekcji. W tej sekcji używamy instrukcji `jeśli` by wyjaśnić zapytania.

### Zapytania

Przykład prostego pytania:

    x = 6
    jeśli x > 5 [
      pisz "cześć"
    ]

Pytaniem w tym przykładzie jest `x > 5` . Jeżeli odpowiedź jest prawdziwa wykonywany jest kod w nawiasach. Zapytania są bardzo istotną częścią częścią programowania i są często używane z instrukcjami sterującymi, jak np. `jeśli`. Wszystkie liczby i zmienne (kontenery liczbowe) mogą być porównywane ze sobą przy pomocy zapytań.

Poniżej znajdują się wszystkie możliwe pytania:

### Typy zapytań

`a == b` | równa się | odpowiedź jest prawdą gdy `a` równa się `b`
`a != b` | nie równe | odpowiedź jest prawdą gdy `a` nie równa się `b`
`a > b` | większe niż | odpowiedź jest prawdą gdy `a` jest większe niż `b`
`a < b` | mniejsze niż | odpowiedź jest prawdą gdy `a` jest mniejsze niż `b`
`a >= b` | większe lub równe | odpowiedź jest prawdą gdy `a` jest większe lub równe `b`
`a <= b` | mniejsze lub równe | odpowiedź jest prawdą gdy `a` mniejsze lub równe `b`

W edytorze kodu pytania są podświetlone na kolor jasno niebieski.

### Łączniki pytań

Wyrazy łączące pytania umożliwiają łączenie kilku małych pytań w jedno duże.

    a = 1
    b = 5
    jeśli (a < 5) i (b == 5) [
      pisz "cześć"
    ]

W tym przykładzie wyraz łączący `i` jest użyty do połączenia dwóch pytań (`a < 5`, `b == 5`). Jeżeli po jednej stronie `i` odpowiedź będzie fałszywa odpowiedź na całe pytanie będzie fałszem, gdyż używając wyrazu `i` obie strony muszą być prawdziwe by całe pytanie było prawdą. Proszę nie zapominać o użyciu nawiasów wokół pytań!

Poniżej znajduje się schematyczne wytłumaczenie:

### Wyrazy łączące pytania

`i` | By wyrażenie było prawdziwe obie strony muszą być prawdziwe
`lub` | By wyrażenie było prawdziwe, wystarczy by jedna strona była prawdziwa
`nie` | Wyjątkowy przypadek: działa jedynie z pytaniami! Zmienia prawdę na fałsz a fałsz na prawdę.

W edytorze kodu wyrazy łączące pytania są podświetlone na purpurowo.

#### i

Gdy dwa pytania są połączone za pomocą `i`, obie strony `i` muszą być prawdziwe by wynik był prawdziwy. Na przykład:

    a = 1
    b = 5
    jeśli ((a < 10) i (b == 5)) i (a < b) [
      pisz "cześć"
    ]

W tym przykładzie można zaobserwować pytanie zagnieżdżone w pytaniu.

#### lub

Gdy jedno z dwóch wyrażeń połączonych wyrazem `lub` jest prawdziwe wynik jest prawdziwy. Na przykład:

    a = 1
    b = 5
    jeśli ((a < 10) lub (b == 10)) lub (a == 0) [
      pisz "cześć"
    ]

W tym przykładzie można zaobserwować pytanie zagnieżdżone w pytaniu.

#### nie

`nie` jest specjalnym wyrazem, gdyż odnosi się tylko do jednego wyrażenia. `nie` zamienia fałsz na prawdę a prawdę na fałsz. Na przykład:

    a = 1
    b = 5
    jeśli nie ((a < 10) i (b == 5)) [
      pisz "cześć"
    ] przeciwnie [
      pisz "nie cześć ;-)"
    ]

W tym przykładzie wyrażenie jest prawdziwe, ale `nie` zamienia je na fałszywe. Więc na końcu napłótnie`"nie cześć ;-)"`.

## Kontola wykonywania

Kontrolery wykonania umożliwiają użytkownikowi sterowanie wykonywaniem programu przez —.

Komendy kontrolujące wykonanie programu podświetlone są na ciemnozielony kolor oraz mają pogrubioną czcionkę. Nawiasy kwadratowe używane są głównie z komendami kontrolującymi wykonanie i są podświetlone na jasno zielono.

### Zatrzymanie żółwia

Napisawszy jakiś program w &kturtle; można zauważyć, że żółw bardzo szybko wykonuje rysunki. Poniższa komenda zatrzymuje żółwia na określoną ilość czasu.

czekaj

-     czekaj X

  `czekaj` zatrzymuje żółwia na X sekund.

      powtórz 36 [
        naprzód 5
        obróć_w_prawo 10
        czekaj 0.5
      ]

  Kod powoduje rysowanie okręgu, ale po każdym kroku żółw zatrzymuje się na pół sekundy. Daje to wrażenie poruszania się żółwia w zwolnionym tempie.

### Instrukcja "jeśli"

jeśli

-     jeśli pytanie [ ... ]

  Kod umieszczony w nawiasach jest wykonywany jedynie wtedy gdy `jeśli` wartość wyrażenia jest prawdziwa. Więcej informacji na temat wyrażeń znaleźć można w sekcji wyrażenia.

      x = 6
      jeśli x > 5 [
        pisz "x jest większe niż pięć!"
      ]

  W pierwszej linijce `x` jest ustawiane jako 6. W drugiej linijce, znajduje się pytanie `x > 5`. Jako, że wyrażenie to jest prawdziwe kontroler wykonania `jeśli` zezwala na wykonanie kodu w nawiasie.

### Pętla "dopóki"

dopóki

-     dopóki wyrażenie [ ... ]

  Wyrażenie sterujące `dopóki` jest podobne do `jeśli`. Różnica polega na tym, że `dopóki` powtarza wykonywanie kodu między nawiasami dopóki wartość wyrażenia nie będzie fałszywa.

      x = 1
      dopóki x < 5 [
        naprzód 10
        czekaj 1
        x = x + 1
      ]

  W pierwszej linii zmienna `x` ustawiana jest na 1. W drugiej linii znajduje się wyrażenie `x < 5`. Jako, że wyrażenie to jest prawdziwe wyrażenie sterujące `dopóki` rozpoczyna wykonywanie kodu między nawiasami dopóki wartość wyrażenia nie będzie fałszywa. W tym przypadku kod w nawiasie zostanie wykonany 4 razy, gdyż po każdym wykonaniu piątej linii `x` wzrasta o 1.

### Jeżeli nie, innymi słowami: "przeciwnie"

przeciwnie

-     jeśli wyrażenie [ ... ] przeciwnie [ ... ]

  `przeciwnie` może być użyte w dodatku do wyrażenia sterującego `jeśli`. Kod pomiędzy nawiasami po `przeciwnie` zostanie tylko wtedy gdy wartość wyrażenia jest fałszywa.

      zeruj
      x = 4
      jeśli x > 5 [
        pisz "x jest większe niż pięć!"
      ] przeciwnie [
        pisz "x jest mniejsze niż 6!"
      ]

  Wyrażenie sprawdza czy `x` jest większy niż 5. Ponieważ w pierwszej linijce `x` wynosi 4, wartość wyrażenia jest fałszywa. Oznacza to, że kod w nawiasach po `przeciwnie` zostanie wykonany.

### Pętla "dla", pętla zliczająca

dla

-     dla punkt początkowy do punkt końcowy [ ... ]

  Pętla `dla` jest pętlą zliczającą, &ie; zlicza za użytkownika.

      dla x = 1 do 10 [
        pisz x * 7
        naprzód 15
      ]

  Za każdym razem gdy kod w nawiasach jest wykonywany wartość zmiennej `x` zwiększa się o 1, dopóki zmienna `x` nie osiągnie wartości 10. Kod w nawiasach wypisuje wartość zmiennej `x` pomnożonej przez 7. Po wykonaniu programu na płótnie będzie można zobaczyć tabele wielokrotności liczby 7.

## Tworzenie własnych komend za pomocą nauczyciela

`nauczyciel` jest specjalną komendą, służącą do tworzenia własnych komend. Utworzone komendy mogą przyjmować argumenty wejściowe i zwracać argumenty wyjściowe. Zobaczmy jak tworzone są nowe komendy:

    poznaj okrąg x [
      powtórz 36 [
        naprzód x
        obróć_w_lewo 10
      ]
    ]

Nowa komenda zostanie nazwana `okrąg`. `okrąg` oczekuje jednego argumentu wejściowego, liczby określającej rozmiar okręgu. `okrąg` nie zwraca żadnego argumentu wyjściowego. Komenda `okrąg` może być teraz używana jak normalna komenda w reszcie kodu. Oto przykład:

    poznaj okrąg X [
      powtórz 36 [
        naprzód X
        obróć_w_lewo 10
      ]
    ]

    idź 30,30
    okrąg 20

    idź 40,40
    okrąg 50

W następnym przykładzie tworzona jest komenda zwracająca wartość.

    zeruj

    poznaj pomnóżPrzezSiebie n [
      r = n * 1
      r = n * n
      powrót r
    ]
    i = okno_wejścia "Proszę wprowadzić liczbę i wcisnąć Enter"
    pisz i + " pomnożone przez siebie daje: " + pomnóżPrzezSiebie i

W przykładzie tworzona jest komenda `pomnóżPrzezSiebie`. Argument wejściowy komendy jest mnożony przez siebie i zwracany, za pomocą komendy `powrót`. Komenda `powrót` umożliwia zwrócenie wartość z utworzonej własnej funkcji.