# Programmeren met &turtlelang;

Dit is een overzicht van &kturtle;'s &turtlelang;. In dit hoofdstuk bespreken we in het kort de verschillende instructietypen. Daarna leggen we één voor één de commando's uit. Daarna volgen de plaatshouders, rekenen, vragen en de programmastuurcommando's. Tot slot laten we je zien hoe je je eigen commando's kunt maken met het commando leer.

## Verschillende instructietypen

Zoals elke taal heeft &turtlelang; verschillende soorten woorden en symbolen. Hier worden de verschillen tussen deze soorten kort uitgelegd.

### Commando's

Met behulp van commando's vertel je de schildpad of &kturtle; om iets te doen. Sommige commando's vragen om een invoer, anderen geven een uitvoer.

    # vooruit is een commando dat invoer nodig heeft. In ons geval het getal 100:
    vooruit 100

Meer informatie over alle commando's die &kturtle; kent vind je hier.

### Getallen

Getallen ken je vast wel. De manier waarop getallen worden gebruikt in &kturtle; is niet veel anders dan in een spreektaal, of bij het rekenen.

We hebben de zogenaamde natuurlijke getallen: `0`, `1`, `2`, `3`, `4`, `5`, enz. De negatieve getallen: `-1`, `-2`, `-3`, enz. En de getallen met een komma: `0,1`, `3,14`, `33,3333`, `-5,05`, `-1,0`.

Getallen kunnen worden gebruikt in berekeningen en in vragen. Ze kunnen ook in plaatshouders worden geplaatst.

Getallen worden donkerrood geaccentueerd in de codebewerker.

### Tekenreeksen

Eerst een voorbeeld:

    schrijf "Hallo, ik ben een tekenreeks."

In dit voorbeeld is `schrijf` een commando en `"Hallo, ik ben een tekenreeks"` een tekenreeks. Een tekenreeks begint en eindigt met het teken `"`. Hierdoor "weet" &kturtle; dat dit een tekenreeks is.

Tekenreeksen kunnen in plaatshouders worden geplaatst. Maar je kunt ze niet gebruiken in berekeningen en vragen.

Tekenreeksen worden rood geaccentueerd in de codebewerker.

### Namen

Je kunt met de programmeertaal &turtlelang; nieuwe dingen maken. Als je een programma schrijft zul je vaak plaatshouders nodig hebben, en in sommige gevallen heb je het commando leer nodig om nieuwe commando's te maken. Als je een plaatshouder of een nieuw commando met behulp van leer maakt, dan moet je er een naam aan geven.

Je kunt een willekeurige naam kiezen, als die maar niet al wordt gebruikt. Bijvoorbeeld, je kunt een plaatshouder niet vooruit noemen, omdat die naam al wordt gebruikt voor een commando, en dus al een betekenis heeft.

    # hier wordt vooruit gebruikt als een plaatshouder, maar die heeft al een betekenis
    # dus komt er een foutmelding:
    $vooruit = 20

    # dit werkt echter wel (is een commando):
    vooruit 20

Namen mogen alleen letters, cijfers en onderstreepjes (_) bevatten. Ze moeten altijd met een letter beginnen.

Plaatshouders worden geaccentueerd met vet paars in de codebewerker.

Lees ook de documentatie over plaatshouders en het commando leer voor een betere uitleg en meer voorbeelden.

### Toewijzingen

Toewijzingen worden gedaan met het symbool `=`. In programmeertalen is het beter om een `=` niet te lezen als 'is', maar als 'wordt'. Het woordje 'is' past beter bij het teken `==`, dit is een vraag.

Toewijzingen worden meestal om twee redenen gebruikt: (1) om inhoud toe te voegen aan plaatshouders en (2) om de inhoud van een plaatshouder te veranderen. Bijvoorbeeld:

    $x = 10
    # de plaatshouder x bevat nu het getal 10
    $W = "Mijn leeftijd is: "
    # de plaatshouder W bevat nu de tekenreeks "Mijn leeftijd is:"
    # dit plaatst de inhoud van de plaatshouders 'W' en 'x' op het canvas
    schrijf $W + $x

Meer voorbeelden kun je vinden in het hoofdstuk waarin het begrip plaatshouders wordt uitgelegd.

### Rekensymbolen

&kturtle; kent alle basissymbolen van het rekenen: optellen (`+`), aftrekken (`-`), vermenigvuldigen (`*`), delen `/`) en de haakjes `(` en `)`.

Een complete uitleg en meer voorbeelden vind je in het hoofdstuk over rekenen.

### Vragen

We kunnen eenvoudige vragen stellen waarop het antwoord alleen maar 'waar' of 'onwaar' zal zijn.

Het gebruik van vragen wordt uitgebreid uitgelegd in het hoofdstuk over vragen.

### Lijmwoorden voor vragen

Vragen kunnen aan elkaar worden gelijmd met zogenaamde 'lijmwoorden'. De lijmwoorden zijn `en`, `of` en een speciaal lijmwoord is: `niet`.

Het gebruiken van lijmwoorden wordt uitgelegd in het hoofdstuk Vragenlijm.

### Commentaar

Commentaarregels zijn regels die beginnen met een `#`. Bijvoorbeeld:

    # dit is commentaar!
    schrijf "dit is geen commentaar"
    # de vorige regel is geen commentaar, maar de volgende regel wel:
    # schrijf "dit is geen commentaar"

In commentaarregels kunnen we aantekeningen schrijven die iets vertellen over de programmacode, voor onszelf of voor iemand anders die deze code leest. Commentaar wordt gebruikt om : (1) een kleine beschrijving van het programma toe te voegen, (2) uit te leggen hoe een stukje code werkt als dit minder duidelijk is, en (3) om regels programmacode die (tijdelijk) niet gebruikt mogen worden over te slaan (zie de laatste regel in het voorbeeld).

Commentaarregels worden geaccentueerd met lichtgrijs in de codebewerker.

## Commando's

Met behulp van commando's vertel je de schildpad of &kturtle; om iets te doen. Sommige commando's vragen om een invoer, anderen geven een uitvoer. In deze sectie zullen we alle commando's die in &kturtle; kunnen worden gebruikt, aan je uitleggen. Onthoud dat alle ingebouwde commando's die we hier bespreken geaccentueerd worden met blauw in de codebewerker. Hiermee kun je ze onderscheiden van de rest.

### De schildpad voortbewegen

Er zijn verschillende commando's waarmee je de schildpad over het scherm kunt bewegen.

#### vooruit (vt)

vooruit

      vooruit X

  `vooruit` verplaatst de schildpad X pixels vooruit. Als de pen neer is zal de schildpad een spoor achterlaten. `vooruit` kun je afkorten met `vt`

#### achteruit (at)

achteruit

      achteruit X

  `achteruit` verplaatst de schildpad X pixels achteruit. Als de pen neer is zal de schildpad een spoor achterlaten. `achteruit` kun je afkorten met `at`.

#### draailinks (dl)

draailinks

      draailinks X

  `draailinks` laat de schildpad X graden naar links draaien. `draailinks` kun je afkorten met `dl`.

#### draairechts (dr)

draairechts

      draairechts X

  `draairechts` laat de schildpad X graden naar rechts draaien. `draairechts` kun je afkorten met `dr`.

#### richting (rt)

richting

      richting X

  `richting` zet de richting van de schildpad op X graden, geteld vanaf 0. Dus niet vanuit de vorige positie van de schildpad. `richting` kun je afkorten met `rt`.

#### thuis

thuis

      thuis

  `thuis` zet de schildpad in het midden van het canvas.

#### ganaar

ganaar

      ganaar X,Y

  `ganaar X,Y` laat de schildpad naar een bepaalde plaats op het canvas gaan. De plaats is op X pixels vanaf de linkerkant en Y pixels vanaf de bovenkant van het canvas. Opmerking: de schildpad tekent met het commando `ganaar` geen lijn.

#### ganaarx

ganaarx

      ganaarx X

  `ganaarx X` laat de schildpad naar een positie gaan die X pixels vanaf de linkerkant van het canvas ligt. De hoogte blijft hetzelfde. `ganaarx` kun je afkorten met `gx`.

#### ganaary

ganaary

      ganaary Y

  `ganaary` laat de schildpad naar een positie gaan die Y pixels vanaf de bovenkant van het canvas ligt. De afstand vanaf de linkerkant van het canvas blijft hetzelfde. `ganaary` kun je afkorten met `gy`.

### De schildpad heeft een pen

De schildpad heeft een pen die een lijn tekent als de schildpad beweegt. Er zijn een aantal commando's die de pen bedienen. In deze sectie leggen we deze commando's uit.

#### penop (po)

penop

      penop

  `penop` tilt de pen van het canvas. Als de pen omhoog is, dan wordt er geen lijn getekend als de schildpad beweegt. Kijk ook bij `penneer`. `penop` kun je afkorten met `po`.

#### penneer (pn)

penneer

      penneer

  `penneer` zet de pen op het canvas. Als de pen op het canvas drukt, dan wordt er een lijn getekend als de schildpad beweegt. Zie ook `penop`. `penneer` kun je afkorten met `pn`.

#### pendikte (pd)

pendikte

      pendikte X

  `pendikte` X stelt de dikte van de pen (de breedte van de lijn) op X pixels. `pendikte` kun je afkorten met `pd`.

#### penkleur (pk)

penkleur

      penkleur R,G,B

  `penkleur` bepaalt de kleur van de pen. `penkleur` vraagt om een RGB-combinatie (drie getallen tussen 0 en 256) als invoer. `penkleur` kun je afkorten met `pk`.

### Commando's om schoon te maken

Er zijn twee commando's waarmee je het canvas kunt schoonmaken nadat je er een bende van hebt gemaakt.

#### schoon

schoon

      schoon

  Met `schoon` kun je alle tekeningen op het canvas wissen. De rest blijft staan, de positie en de hoek van de schildpad, de kleur van het canvas, de zichtbaarheid van de schildpad en de grootte van het canvas blijven zoals ze waren.

#### alsnieuw

alsnieuw

      alsnieuw

  `alsnieuw` maakt nog meer schoon dan het commando `schoon`. Na het commando `alsnieuw` is alles zoals het was toen je &kturtle; net had opgestart. De schildpad wordt in het midden van het scherm gezet, de canvaskleur is wit en de schildpad tekent een zwarte lijn op het canvas.

### De schildpad is een sprite (zeg maar: sprait)

Eerst volgt hier een korte uitleg van wat sprites zijn: sprites zijn kleine plaatjes die je kunt rondbewegen op het scherm, zoals je vaak in computerspelletjes ziet. Onze schildpad is zo'n sprite. Voor meer info, zie de woordenlijst bij linkend="sprites" >sprites.

Noot vertaler: eigenlijk zijn sprites zoiets als geesten, feeën of kabouters.

Hierna volgt een volledig overzicht van alle commando's die je kunt gebruiken bij sprites.

[De huidige versie van &kturtle; heeft alleen een schildpad als sprite. Andere sprites zijn er dus niet. In toekomstige versies van het programma zul je de schildpad kunnen veranderen in je eigen ontwerp]

#### toon

toon (ts)

      toon

  `toon` maakt de schilpad weer zichtbaar nadat hij is verborgen. `toon` kun je afkorten met `ts`.

#### verberg (vs)

verberg

      verberg

  `verberg` verbergt de schildpad. Dit is handig als je de schildpad niet in je tekening wilt zien. `verberg` kun je afkorten met `vs`.

### Kan de schildpad schrijven?

Het antwoord is: ja. De schildpad kan schrijven. Hij schrijft zo'n beetje alles wat je hem opdraagt.

#### schrijf

schrijf

      schrijf X

  Het commando `schrijf` kun je gebruiken om de schildpad iets op het canvas te laten schrijven. `schrijf` vraagt om letters en/of cijfers als invoer. Je kunt verschillende getallen en stukken tekst `laten schrijven` met behulp van het +-symbool. Hier is een klein voorbeeld:

      $jaar = 2003
      $auteur = "Cies"
      schrijf $auteur + " begon het KTurtle-project in " + $jaar + " en vindt het nog steeds leuk om er aan te werken!"

#### lettermaat

lettermaat

      lettermaat X

  `lettermaat` bepaalt de grootte van de letters die wordt gebruikt door het commando `schrijf`. `lettermaat` vraagt om een getal als invoer. De grootte geef je op in pixels.

### Een commando dat een dobbelsteen voor je gooit

Er is een commando dat dobbelstenen voor je gooit. Dit commando heet `gok`, en is erg handig als je wat onverwachte resultaten wilt hebben.

gok

      gok X,Y

  `gok` is een commando dat invoer vraagt en uitvoer geeft. Als invoer vraagt het commando twee cijfers, het eerste cijfer (X) zet de minimum uitvoer, en het tweede (Y) zet de maximum. De uitvoer is een willekeurig gekozen getal dat gelijk is aan of groter dan het minimum en gelijk aan of kleiner dan het maximum. Hier is een klein voorbeeld:

      herhaal 500 [
       $x = gok 1,20
       vooruit $x
       draailinks 10 - $x
      ]

  Met het commando `gok` kun je wat chaos aan je programma toevoegen.

### Invoer en terugkoppeling met behulp van dialogen

Een dialoog is een klein venstertje waarmee enige terugkoppeling wordt verkregen of waarin om enige invoer wordt gevraagd aan de gebruiker. &kturtle; kent twee opdrachten voor een dialoog, namelijk `bericht` en `invoervenster`

#### bericht

bericht

      bericht X

  De opdracht `bericht` heeft als invoer een tekenreeks. Er wordt een venstertje getoond waarin een dialoog met de tekst van deze tekenreeks.

      bericht "Cies begon het KTurtle-project in 2003 en vindt het nog steeds leuk om er aan te werken!"

#### vraag

vraag

      vraag X

  `vraag` heeft als invoer een tekenreeks. Er wordt een venstertje getoond met de tekst van deze tekenreeks, net als bij het commando bericht. Maar in deze dialoog is ook een invoerveld. In dit invoerveld kan een gebruiker een getal of een tekenreeks invoeren die in een plaatshouder kan worden opgeslagen. Bijvoorbeeld

      $in = vraag "Hoe oud ben je?"
      $uit = 5 + $in
      schrijf "Over 5 jaar ben je " + $uit + " jaar."

  . Als de gebruiker de invoerdialoog annuleert of er niets in invult wordt de plaatshouder leeg gemaakt.

## Plaatshouders

Plaatshouders zijn letters of woorden die door de programmeur kunnen worden gebruikt om daarin een getal of tekst op te slaan. Plaatshouders die een getal bevatten heten variabelen, plaatshouders die tekst bevatten heten tekenreeksen. Plaatshouders kun je herkennen aan het $-teken dat ervoor wordt geplaatst.

Plaatshouders die niet worden gebruikt zijn leeg. Een voorbeeld:

    schrijf $N

Er wordt niets op het canvas geschreven. Als we proberen met lege plaatshouders te rekenen krijgen we foutmeldingen.

### Variabelen: plaatshouders voor getallen

Laten we beginnen met een voorbeeld:

    $x = 3
    schrijf $x

Op de eerste regel wordt de letter `x` omgevormd tot een variabele (plaatshouder van een getal). Zoals je ziet wordt de waarde van de variabele `x` op 3 gesteld. Op de tweede regel wordt de waarde geschreven.

Merk op dat als we een x hadden willen schrijven, we het volgende zouden hebben geschreven

    schrijf "x"

Dat was gemakkelijk. Nu een wat moeilijker voorbeeld:

    $A = 2004
    $B = 25
    $C = $A + $B

    # het volgende commando schrijft "2029"
    schrijf $C
    achteruit 30
    # het volgende commando schrijft "2004 plus 25"
    schrijf $A + " plus " + $B
    achteruit 30
    # het volgende commando schrijft "1979"
    schrijf $A - $B

Op de eerste twee regels krijgen de variabelen `A` en `B` de waarden 2004 en 25 toegekend. Op de derde regel krijgt de variabele `C` de waarde `A + B`, en dat is 2029. De rest van het voorbeeld bestaat uit 3 `schrijf`-commando's met `achteruit 30` ertussen in. De `achteruit 30` staat er om er voor te zorgen dat elke uitvoer op een nieuwe regel komt. In dit voorbeeld zie je ook dat variabelen kunnen worden gebruikt om ermee te rekenen.

### Plaatshouders die tekst bevatten (tekenreeksen)

In programmacode begint en eindigt gewone tekst vaak met aanhalingstekens. Zoals we eerder al hebben gezien:

    schrijf "Hallo programmeur!"

De gewone tekst staat tussen aanhalingstekens. Dit soort stukjes tekst noemen we tekenreeksen.

Ook tekenreeksen kunnen worden opgeslagen in plaatshouders, net zoals getallen. Tekenreeksen lijken veel op variabelen. Het grootste verschil met getallen is dat je met tekenreeksen niet kunt rekenen. Een voorbeeld van het gebruik van tekenreeksen:

    $x = "Hallo "
    $naam = vraag "Voer je naam in..."
    schrijf $x + $naam + ", hoe gaat het met je?"

Op de eerste regel wordt `x` gesteld op Hallo . Op de tweede regel wordt de tekenreeks `naam` gesteld op de uitvoer van de opdracht `vraag`. Op de derde regel schrijft het programma een samenstelling van de drie tekenreeksen op het canvas.

Dit programma vraagt je je naam in te voeren. Als je bijvoorbeeld de naam Paul invoert, dan schrijft het programma Hallo Paul, hoe gaat het met je?. Houd er rekening mee dat de plus (+) het enige rekenkundige teken is dat je kunt gebruiken met tekenreeksen. Hierdoor worden tekenreeksen als het ware aan elkaar geplakt.

## Kan de schildpad rekenen?

Ja, &kturtle; kan voor jou rekenen, namelijk optellen (+), aftrekken (-), vermenigvuldigen (*) en delen (/). Dit is een voorbeeld waarin dit alles wordt gebruikt:

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

Weet je welke waarden a, b, c, en d hebben? Merk in het voorbeeld het gebruik op van het toewijs-symbool

    =

.

Als je een eenvoudige rekensom wilt laten doen, dan kan dat bijvoorbeeld zo:

    schrijf 2004-12

Nu een voorbeeld met haakjes:

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

Het gedeelte tussen de binnenste haakjes zal als eerste worden uitgerekend. In dit voorbeeld wordt 20 - 5 berekend, dan wordt de uitkomst vermenigvuldigd met 2, en daarna wordt er gedeeld door 30. Tot slot wordt er 1 bij opgeteld (het antwoord is 2).

## Stel vragen en krijg antwoorden...

`als` en `terwijl` zijn programmastuurcommando's die we in de volgende sectie zullen bespreken. In deze sectie gaan we het commando `als` gebruiken om vragen uit te leggen.

### Vragen

Een voorbeeld van een vraag:

    $x = 6
    als $x > 5 {
     schrijf "hallo"
    }

In dit voorbeeld is de vraag het gedeelte `x > 5`. Als het antwoord op deze vraag 'waar' is, dan wordt de programmacode tussen de accolades uitgevoerd. Vragen zijn een belangrijk onderdeel van het programmeren en worden vaak gebruikt in combinatie met programmastuurcommando's, zoals `als`. Alle getallen en variabelen (getalplaatshouders) kunnen met elkaar worden vergeleken met behulp van vragen.

Hier zijn alle mogelijke vragen:

#### Soorten van vragen

`a == b` | gelijk aan | het antwoord is waar als `a` gelijk is aan `b`
`a != b` | ongelijk aan | het antwoord is waar als `a` niet gelijk is aan `b`
`a > b` | groter dan | het antwoord is waar als `a` groter is dan `b`
`a < b` | kleiner dan | het antwoord is waar als `a` kleiner is dan `b`
`a >= b` | groter dan of gelijk aan | het antwoord is waar als `a` groter is dan of gelijk aan `b`
`a <= b` | kleiner dan of gelijk aan | het antwoord is waar als `a` kleiner is dan of gelijk aan `b`

### Vragenlijm

Vragen kunnen aan elkaar geplakt worden met vragenlijm. Zo kun je van een paar kleine vragen een grote vraag maken.

    $a = 1
    $b = 5
    als ($a < 5) en ($b == 5) {
     schrijf "hallo"
    }

In dit voorbeeld is het lijmwoord `en` gebruikt om twee vragen (`a < 5`, `b == 5`) aan elkaar te plakken. Als een zijde van de `en` onwaar als antwoord heeft, dan zal de hele vraag onwaar zijn, omdat bij het lijmwoord `en` beide zijden waar moeten zijn om het antwoord waar te krijgen. Vergeet de haakjes om de vragen niet!

Hier is een schematisch overzicht, een meer gedetailleerde uitleg volgt hieronder:

#### Lijmwoorden voor vragen

`en` | beide zijden moeten 'waar' zijn voor het antwoord 'waar'
`of` | als een van de, of beide, zijden 'waar' is, dan is het antwoord 'waar'
`niet` | Een speciaal geval: werkt alleen op één vraag! Verandert 'waar' in 'onwaar' en 'onwaar' in 'waar'.

#### en

Als twee vragen aan elkaar zijn gelijmd met `en`, dan moeten beide zijden van de `en` 'waar' zijn om 'waar' als resultaat te krijgen. Een voorbeeld:

    $a = 1
    $b = 5
    als (($a < 10) en ($b == 5)) en ($a < $b) {
     schrijf "hallo"
    }

In dit voorbeeld zie je een gelijmde vraag vastgelijmd aan nog een andere vraag.

#### of

Als één van de, of beide, vragen die aan elkaar zijn geplakt met `of` 'waar' is, dan is het antwoord 'waar'. Een voorbeeld:

    $a = 1
    $b = 5
    als (($a < 10) of ($b == 10)) of ($a == 0) {
     schrijf "hallo"
    }

In dit voorbeeld zie je een gelijmde vraag vastgelijmd aan nog een andere vraag.

#### niet

`niet` is een speciaal lijmwoord omdat het alleen met één vraag tegelijk werkt. `niet` verandert 'waar' in 'onwaar' en 'onwaar' in 'waar'. Voorbeeld:

    $a = 1
    $b = 5
     als niet (($a < 10) en ($b == 5)) {
     schrijf "hallo"
    }
    anders
    {
     schrijf "niet hallo ;-)"
    }

In dit voorbeeld is de gelijmde vraag 'waar', maar de `niet` verandert dit in 'onwaar`. Dus uiteindelijk wordt` "niet hallo ;-)" afgedrukt op het canvas.

## Sturen van het programma

De programmastuurcommando's maken het mogelijk, —zoals de naam al zegt— het verloop van een programma te sturen.

Commando's die het programmaverloop sturen worden geaccentueerd met donkergroen in een vet lettertype. De accolades worden meestal samen met de programmastuurcommando's gebruikt en worden geaccentueerd met vet zwart.

### De schildpad laten wachten

Als je al wat hebt geprogrammeerd in &kturtle;, dan heb je vast gemerkt dat de schildpad erg snel is met tekenen. Dit commando laat de schildpad steeds een opgegeven tijdsduur te wachten.

wacht

      wacht X

  `wacht` X laat de schildpad steeds X seconden wachten.

      herhaal 36{
       vooruit 5
       draairechts 10
       wacht 0,5
      }

  Deze programmacode tekent een cirkel, maar de schildpad zal na elke stap een halve seconde wachten. Hier door lijkt het net of de schildpad kruipt.

### Doe "als"

als

      als vraag { ... }

  De programmacode die tussen de accolades staat wordt alleen uitgevoerd `als` het antwoord op de vraag waar is. Lees voor meer informatie over vragen het gedeelte over vragen.

      $x = 6
      als $x > 5 {
       schrijf "x is groter dan vijf!"
      }

  Op de eerste regel krijgt `x` de waarde 6. Op de tweede regel wordt de vraag `x > 5` gesteld. Omdat het antwoord op deze vraag waar is zal door het programmastuurcommando `als` de programmacodecode tussen de haakjes worden uitgevoerd

### De lus "terwijl"

terwijl

      terwijl vraag { ... }

  Het programmastuurcommando `terwijl` lijkt veel op als``. Het verschil is dat `terwijl` de programmacode tussen de accolades blijft herhalen totdat het antwoord op de vraag onwaar wordt.

      $x = 1
      terwijl $x < 5 {
        vooruit 10
        wacht 1
        $x = $x + 1
      }

  Op de eerste regel krijgt `x` de waarde 1. Op de tweede regel wordt de vraag `x < 5` gesteld. Omdat het antwoord op deze vraag waar is start de programmabesturing `terwijl` het uitvoeren van de code tussen de accolades totdat het antwoord op de vraag onwaar is geworden. In dit voorbeeld wordt de code tussen de accolades 4 keer uitgevoerd, omdat telkens als de vijfde regel wordt uitgevoerd de waarde `x` met 1 wordt vermeerderd.

### Als niet, of in andere woorden: "anders"

anders

      als vraag { ... } anders { ... }

  `anders` kan worden gebruikt als aanvulling op het programmastuurcommando `als`. De programmacode tussen de accolades na `anders` wordt alleen uitgevoerd als het antwoord op de gestelde vraag 'onwaar' is.

      alsnieuw$x = 4
      als $x > 5 {
        schrijf "x is groter dan vijf!"
      }
      anders
      {
        schrijf "x is kleiner dan zes!"
      }

  Met de vraag wordt gevraagd of `x` groter is dan 5. Omdat `x` op op de eerste regel de waarde 4 krijgt is het antwoord onwaar. Dit betekent dat de code tussen de accolades achter `anders` zal worden uitgevoerd.

### De lus "voor", een tellende lus

voor

      voor startpunt tot eindpunt { ... }

  De lus `voor` is een tellende lus, dus die houdt de telling voor je bij.

      voor $x = 1 tot 10 {
       schrijf $x * 7
       vooruit 15
      }

  Telkens als de programmacode tussen de accolades wordt uitgevoerd wordt de waarde `x` met 1 vermeerderd (dit gaat dus van zelf), totdat `x` de waarde 10 heeft bereikt. De code tussen de accolades schrijft de waarde van `x` vermenigvuldigd met 7. Nadat deze commando's zijn uitgevoerd zie je de tafel van 7 op het canvas staan.

## Maak je eigen commando's met leer

`leer` is een nogal apart commando, omdat die kan worden gebruikt om je eigen commando's te maken. Het commando dat je maakt kan om invoer vragen en uitvoer geven. Laten we eens kijken hoe je een nieuw commando kunt maken:

    leer cirkel $x {
     herhaal 36 {
       vooruit $x
       draailinks 10
     }
    }

Het nieuwe commando heet `cirkel`. `cirkel` vraagt om een invoer, een getal, om de grootte van de cirkel te bepalen. `cirkel` geeft geen uitvoer. Het commando `cirkel` kan nu worden gebruikt als een normaal commando in de rest van de programmacode. Hier een voorbeeld:

    leer cirkel $x {
      herhaal 36 {
        vooruit $x
        draailinks 10
      }
    }

    ganaar 30,30
    cirkel 20

    ganaar 40,40
    cirkel 50

In het volgende voorbeeld maken we een commando met een uitvoerwaarde.

    alsnieuw

    leer vermenigvuldigMetZichzelf $n {
      $r = $n * 1
     $r = $n * $n
      geefdoor $r
    ]
    $i = vraag "Voer een getal in en klik op OK"
    schrijf $i + " vermenigvuldigd met zichzelf is " + vermenigvuldigMetZichzelf  $i

In dit voorbeeld wordt een nieuw commando met de naam `vermenigvuldigMetZichzelf` gemaakt. De invoer van dit commando wordt vermenigvuldigd met zichzelf en daarna doorgegeven met behulp van het commando `geefdoor`. Het commando `geefdoor` is een manier om de waarde van een functie die je hebt gemaakt als antwoord te geven.

Commando's kunnen meer dan een invoer nodig hebben. In het volgende voorbeeld wordt een commando gemaakt dat een rechthoek tekent.

    leer rechthoek $X, $Y {
      vooruit $Y
      draairechts 90
      vooruit $X
      draairechts 90
      vooruit $Y
      draairechts 90
      vooruit $X
      draairechts 90
    }