# Programmeren met &turtlescript;

Dit is het overzicht van &turtlescript; van &kturtle;. In het eerste deel van dit hoofdstuk kijken we naar enkele aspecten van de grammatica van &turtlescript;-programma's. Het tweede deel behandelt uitsluitend rekenkundige bewerkingen, booleaanse (waar/onwaar) bewerkingen en vergelijkingsbewerkingen. Het derde deel is eigenlijk een enorme lijst van alle commando's, die een voor een worden uitgelegd. In deel vier wordt uitgelegd hoe waarden kunnen worden toegekend (gegeven) aan variabelen. Tenslotte leggen we uit hoe de uitvoering van de commando's kan worden gestuurd met programmastuurcommando's in deel vijf en hoe zelf commando's te maken met leer in deel zes.

## De grammatica van &turtlescript;

Zoals elke taal heeft ook &turtlescript; verschillende soorten woorden en tekens. In het Nederlands kennen we werkwoorden (zoals 'lopen' of 'zingen') en zelfstandige naamwoorden (zoals 'zuster' of 'huis'), zij worden verschillend gebruikt. &turtlescript; is een programmeertaal, en wordt gebruikt om &kturtle; te vertellen wat er moet gebeuren.

In dit deel worden de verschillende soorten woorden en tekens in &turtlescript; kort uitgelegd. We leggen uit wat commentaar is, commando's en de drie verschillende soorten van waarden: getallen, tekenreeksen en booleaanse (waar/onwaar) waarden.

### Commentaar

Een programma bestaat uit instructies die worden uitgevoerd als het programma loopt, én zogenoemd commentaar. Commentaar wordt niet uitgevoerd, maar wordt door &kturtle; domweg genegeerd bij het uitvoeren van het programma. Commentaar dient om andere programmeurs (en je zelf, op een later tijdstip) je programma beter te laten begrijpen. Alles dat op een regel volgt na een hekje (`#`), wordt in &turtlescript; opgevat als commentaar.

    # Dit kleine programma bevat alleen commentaar en doet dus helemaal niets!

. Het is wat nutteloos, maar geeft een en ander goed weer.

Commentaar is erg nuttig wanneer een programma wat ingewikkelder gaat worden. Hierin kan aan andere programmeurs iets worden verteld. In het volgende programma zie je hoe commentaar wordt gebruikt bij het commando druk.

    # dit programma werd gemaakt door Cies Breijs.
    druk "deze tekst wordt op het canvas afgedrukt"
    # de vorige regel was geen commentaar,maar de volgende wel:
    # druk "deze tekst wordt niet afgedrukt!"

. De eerste regel geeft wat toelichting bij het programma. De tweede wordt door &kturtle; uitgevoerd, en drukt `deze tekst wordt op het canvas afgedrukt` af op het canvas. De derde regel bevat commentaar. En de vierde regel bevat commentaar meteen stukje &turtlescript;. Als het teken `#` dat ervoor staat wordt weggehaald, zal &kturtle; ook deze regel uitvoeren, maar met het hekje ervoor niet. Door een hekje ervoor wordt een programmaregel dus uitgeschakeld.

Commentaarregels worden geaccentueerd met lichtgrijs in de codebewerker.

### Commando's

Met commando's kun je de schildpad of &kturtle; opdragen iets te doen. Bij sommige commando's is invoer nodig, en andere geven uitvoer.

    # vooruit is een commando dat invoer nodig heeft, in dit geval het getal 100:
    vooruit 100

De eerste regel is commentaar. De tweede bevat het commando `vooruit`, en de invoer is het getal `100`. Het getal wordt niet beschouwd als een deel van het commando, maar als invoer.

Voor sommige commando's ⪚ `ganaar` zijn meerdere invoerwaarden nodig. Deze moeten door een `,` (komma) worden gescheiden.

Meer informatie over alle commando's die &kturtle; van huis uit kent vind je hier. Deze ingebouwde commando's worden met donkerblauw geaccentueerd

### 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. Maar er is wel een verschil: ze worden niet met komma's, maar met punten geschreven. Dit is omdat met een komma twee getallen van elkaar worden gescheiden, zodat 2,5 twee getallen, 2 en 5, zijn. Je moet dus 2.5 schrijven, als je maar één getal bedoelt.

We kennen de zogenaamde natuurlijke getallen: `0`, `1`, `2`, `3`, `4`, `5`, enz. Verder de negatieve getallen: `-1`, `-2`, `-3`, enz. En ook die met decimalen, of kommagetallen, die echter niet met een komma, maar met een punt worden geschreven, zoals : `0.1`, `3.14`, `33.3333`, `-5.05`, `-1.0`. De `.` (punt) wordt dus gebruikt in plaats van de in ons land gebruikelijke komma, als scheidingsteken tussen het gehele gedeelte en de decimalen of cijfers achter de komma. Dit kan niet anders omdat de komma al wordt gebruikt als scheidingsteken tussen twee of meer invoerwaarden.

Getallen kunnen worden gebruikt in rekenkundige bewerkingen en vergelijkingsbewerkingen. Ze kunnen ook worden bewaard in variabelen. Getallen worden geaccentueerd in donkerrood.

### Tekenreeksen

Eerst een voorbeeld:

    druk "Hallo, ik ben een tekenreeks."

In dit voorbeeld is `druk` 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 variabelen worden bewaard, net zoals getallen. Maar, anders dan getallen, kunnen tekenreeksen niet in berekeningen of vergelijkingsbewerkingen worden gebruikt. Tekenreeksen worden met rood geaccentueerd.

### Booleaanse waarden (waar/onwaar)

Er zijn slechts twee booleaanse waarden: `waar`
en `onwaar`
. Soms worden ze ook wel eens genoemd: aan en uit, ja en nee, een en nul. Maar in&turtlescript; worden zij steeds `waar` en `onwaar` genoemd. Kijk eens naar dit stukje code in &turtlescript;:

    $a = true

In de inspector kun je zien dat de variabele `$a` de waarde `waar` heeft gekregen, met als type: booleaans.

Vaak zijn booleaanse waarden het resultaat van vergelijkingsbewerkingen, zoals in het volgende stukje &turtlescript;:

    $antwoord = 10 > 3

De variabele `$antwoord` krijgt de waarde `waar` omdat `10` inderdaad groter is dan `3`.

Booleaanse waarden, `waar` en `onwaar`, worden met donkerrood geaccentueerd.

## Rekenkundige, booleaanse en vergelijkingsbewerkingen

De naam van dit deel klinkt misschien moeilijk, maar het valt allemaal best mee.

### Rekenkundige bewerkingen

Dit zijn de basisbewerkingen van het rekenen: optellen (`+`), aftrekken (`-`), vermenigvuldigen (`*`), delen (`/`) en machtsverheffen (`^`).

Hier is een klein voorbeeld van het gebruik van rekenkundige bewerkingen in &turtlescript;:

    $optellen                = 1 + 1
    $aftrekken              = 20 - 5
    $vermenigvuldigen = 15 * 2
    $delen                    = 30 / 30
    $machtsverheffen   = 2 ^ 2

De waarden die deze bewerkingen opleveren worden toegekend aan de verschillende variabelen (die je willekeurige $namen kunt geven). In de inspectie kun je deze waarden zien.

Als je alleen maar een eenvoudige berekening wilt laten doen, dan kan dat bijvoorbeeld zo:

    druk 2010-12

Nu een voorbeeld met haakjes:

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

Het gedeelte tussen de binnenste haakjes wordt het eerst 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). Haakjes kunnen ook in andere gevallen worden gebruikt.

&kturtle; heeft ook nog wat wiskundige eigenschappen in de vorm van commando's. Kijk maar eens naar de volgende commando's, die, let op, wel wat gevorderd zijn: afronden, gok, wortel , pi, sin, cos, tan, arcsin, arccos, arctan.

### Booleaanse bewerkingen (waar/onwaar)

Waar wiskundige bewerkingen vooral werken metgetallen, werken booleaanse bewerkingen met de booleaanse waarden (`waar` en `onwaar`). Er zijn slechts drie booleaanse bewerkingen, namelijk: `en`
, `of`
, en `niet`
. In het volgende stuk &turtlescript; kan je zien hoe dit te gebruiken:

    $and_1_1 = waar en waar          # -> waar
    $and_1_0 = waar en onwaar      # -> onwaar
    $and_0_1 = onwaar en waar      # -> onwaar
    $and_0_0 = onwaar en onwaar  # -> onwaar

    $or_1_1 = waar of waar              # -> waar
    $or_1_0 = waar of onwaar          # -> waar
    $or_0_1 = onwaar of waar          # -> waar
    $or_0_0 = onwaar of onwaar      # -> onwaar

    $not_1 = niet waar      # -> onwaar
    $not_0 = niet onwaar  # -> waar

Met behulp van de inspector kan je de waarden zien, maar we geven toch de resultaten aan als commentaar aan het einde van de regels. `en` wordt alleen `waar` als beide booleaanse waarden`waar` zijn. `of` wordt alleen `onwaar`als beide booleaanse waarden `onwaar` zijn. En `niet` verandert een `waar` in `onwaar` en een `onwaar` in `waar`.

Booleaanse bewerkingen worden geaccentueerd met roze.

#### Enkele meer gevorderde voorbeelden

Kijk naar het volgende voorbeeld met `en`:

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

In dit stukje &turtlescript; worden de antwoorden van drie vergelijkingsbewerkingen samengevoegd door bewerkingen met `en`. Dit betekent dat ze alle drie "waar" moeten zijn, voordat de tekst "hallo" wordt afgedrukt (op het scherm).

Een voorbeeld met `of`:

    $n = 1
    if ($n < 10) or ($n == 2) {
      print "hallo"
    }

In dit stukje &turtlescript; is links van `of` de vergelijking 'waar', en rechts 'onwaar'. Omdat één van de twee zijden van `of` 'waar' is, is hier het resultaat van `of` de waarde 'waar'. En dus wordt "hallo" afgedrukt (op het scherm).

En tenslotte een voorbeeld met `niet`, die de waarde 'waar' verandert in 'onwaar', en omgekeerd. Kijk maar even:

    $n = 1
    als niet ($n == 3) {
      druk "hallo"
    } anders {
      druk "niet hallo ;-)"
    }

### Vergelijkingsbewerkingen

Kijk naar deze eenvoudige vergelijking:

    $antwoord = 10 > 3

Hier wordt `10` vergeleken met `3` met de bewerking 'groter dan'. Het resultaat van deze vergelijking, de booleaanse waarde `waar` wordt bewaard in de variabele `$antwoord`.

Alle getallen en variabelen (die getallen bevatten) kunnen met deze vergelijkingsbewerkingen met elkaar worden vergeleken.

Hier volgen alle vergelijkingsbewerkingen:

### Typen van vragen

`$A == $B` | is gelijk aan | antwoord is waar als `$A` gelijk is aan `$B`
`$A != $B` | niet gelijk aan | antwoord is waar als `$A` niet gelijk is aan `$B`
`$A > $B` | groter dan | antwoord is waar als `$A` groter is dan `$B`
`$A < $B` | kleiner dan | antwoord is waar als `$A` kleiner is dan `$B`
`$A >= $B` | groter dan of gelijk aan | antwoord is waar als `$A` groter is dan of gelijk aan `$B`
`$A <= $B` | kleiner dan of gelijk aan | antwoord is waar als `$A` kleiner is dan of gelijk aan `$B`

Let er wel op dat $A en $B getallen moeten zijn, of variabelen die getallen bevatten.

## Commando's

Met behulp van commando's vertel je de schildpad of &kturtle; iets te doen. Sommige commando's hebben een invoer nodig, anderen geven een uitvoer. In dit deel zullen we alle ingebouwde commando's die in &kturtle; kunnen worden gebruikt, uitleggen. Met het commando leer kunnen overigens zelf commando's worden gemaakt. De hier besproken ingebouwde (dus oorspronkelijke) commando's worden met donkerblauw geaccentueerd

### De schildpad bewegen

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

vooruit (vt)

-     vooruit X

  `vooruit X` verplaatst de schildpad X pixels vooruit. Als de pen neer is laat de schildpad een spoor achter. `vooruit` kan worden afgekort met `vt`

achteruit (at)

-     achteruit X

  `achteruit X` verplaatst de schildpad X pixels achteruit. Als de pen neer is laat de schildpad een spoor achter. `achteruit` kan worden afgekort met `at`.

draailinks (dl)

-     draailinks X

  `draailinks X` laat de schildpad X graden naar links draaien. `draailinks` kan worden afgekort met `dl`.

draairechts (dr)

-     draairechts X

  `draairechts X` laat de schildpad X graden naar rechts draaien. `draairechts` kan worden afgekort met `dr`.

richting (rt)

-     richting X

  `richting X` zet de richting van de schildpad op X graden, geteld vanaf 0 (recht naar boven). Dus niet ten opzichte van de vorige positie van de schildpad. `richting` kan worden afgekort met `rt`.

haalrichting

-     haalrichting

  `haalrichting X` geeft de ricting terug van de schildpad, in de vorm van een aantal graden, geteld vanaf nul. Nul is de richting recht naar boven, dus als de schildpad recht naar boven loopt.

thuis

-     thuis

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

ganaar

-     ganaar X,Y

  `ganaar` plaatst de schildpad op een bepaalde plaats op het canvas. De plaats is op X pixels vanaf de linkerkant en Y pixels vanaf de bovenkant van het canvas.

ganaarx

-     ganaarx X

  `ganaarx X` laat de schildpad naar een positie gaan op X pixels vanaf de linkerkant van het canvas. De hoogte blijft hetzelfde. `gox` kan wordenafgekort tot `gx`.

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` kan wordenafgekort tot `gy`.

Met de commando's `ganaar`, `ganaarx`, `ganaary` en `thuis` tekent de schildpad geen lijn, onafhankelijk van of de pen op is of neer.

### Waar is de schildpad?

Er zijn twee commando's die de positie van de schildpad op het scherm doorgeven (teruggeven).

haalx

- `haalx` geeft het aantal pixels door dat de huidige positie van de schildpad is vanaf de linkerkant van het scherm.

haaly

- `haaly` geeft het aantal pixels door dat de huidige positie van de schildpad is vanaf de bovenkant van het scherm.

### De schildpad heeft een pen

De schildpad heeft een pen die een lijn tekent als de schildpad beweegt. Er zijn een aantal commando's voor het besturen van de pen. In dit deel leggen we deze commando's uit.

penop (po)

-     penop

  `penop` tilt de pen op van het canvas. Als de pen op is, wordt er geen lijn getekend als de schildpad beweegt. Kijk ook bij `penneer`. `penop` kan worden afgekort met `po`.

penneer (pn)

-     penneer

  `penneer` zet de pen neer op het canvas. Als de pen neer is op het canvas, wordt er een lijn getekend als de schildpad beweegt. Zie ook `penop`. `penneer` kan worden afgekort met `pn`.

pendikte (pd)

-     pendikte X

  `pendikte X` stelt de dikte van de pen (de breedte van de lijn) op X pixels. `pendikte` kan worden afgekort met `pd`.

penkleur (pk)

-     penkleur R,G,B

  `penkleur` stelt de kleur in van de pen. `penkleur` heeft een RGB-combinatie (drie getallen tussen 0 en 255) nodig als invoer. `penkleur` kan worden afgekort met `pk`.

### Commando's voor het canvas

Er zijn verschillende commando's voor de besturing van het canvas

canvasmaat (cm)

-     canvasmaat X,Y

  Met het commando `canvasmaat` kan de grootte van het canvas worden ingesteld. Invoer is X en Y, waarbij X is de nieuwe canvasbreedte is in pixels, en Y de nieuwe hoogte van het canvas, ook in pixels. `canvasmaat` kan worden afgekort tot `cs`.

canvaskleur (ck)

-     canvaskleur R,G,B

  `canvaskleur` stelt de kleur in van het canvas. `canvaskleur` heeft een RGB-combinatie (drie getallen tussen 0 en 255) nodig als invoer. `canvaskleur` kan worden afgekort met `ck`.

### 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 (cs)

-     schoon

  Met `schoon` kunnen alle tekeningen op het canvas worden gewist. 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` maakt nog meer schoon dan het commando `schoon`. Na het commando `alsnieuw` is alles weer zoals het was direct na het starten van &kturtle;. De schildpad wordt in het midden van het scherm gezet (met de neus naar boven), de canvaskleur is wit, de schildpad tekent een zwarte lijn op het canvas, en de grootte van het canvas is weer 400 x 400 pixels.

### 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 verplaatsen 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 (ts)

-     toon

  `toon` maakt de schilpad weer zichtbaar nadat die is verborgen. `toon` kan worden afgekort met `ts`.

verberg

-     verberg

  `verberg` verbergt de schildpad. Dit is handig als de de schildpad niet in de tekening past. `verberg` kan worden afgekort met `vs`.

### Kan de schildpad schrijven?

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

druk

-     druk X

  Het commando `druk` kan worden gebruikt om de schildpad iets op het canvas te laten schrijven. `druk` heeft getallen en tekenreeksen nodig 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"
      druk $auteur + " begon het KTurtle-project in " + $jaar + " en vindt het nog steeds leuk om er aan te werken!"

lettermaat

-     lettermaat X

  `lettermaat` bepaalt de grootte van de letters voor het commando `druk`. `lettermaat` heeft een getal nodig als invoer. De grootte geef je op in pixels.

### Wiskundige commando's

Hier volgen de wiskundige commando's die &kturtle; kent.

afronden

-     afronden X

  `afronden` van het gegeven getal naar het dichtstbijzijnde gehele getal.

      druk afronden 10.8		#denk erom: een punt
         vooruit 20
      druk afronden 10.3

  Hiermee drukt de schildpad de getallen 11 en 10 af.

gok (gk)

-     gok X,Y

  `gok` is een commando met invoer en uitvoer. Als invoerheeft het commando twee getallen nodig, het eerste getal (X) is de minimum grootte van de uitvoer, en het tweede (Y) de maximum grootte. De uitvoer is een willekeurig 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 10,200
       vooruit $x
       draailinks 10 - $x
      ]

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

mod

-     mod X,Y

  Met het commando `mod` wordt de rest berekend vande deling van het eerste getal door het tweede getal.

wortel

-     wortel X

  Met het commando `wortel X` wordt de wortel van het getal X berekend.

pi

-     pi

  Dit commando geeft de constante pi, `3.14159`, door.

sin
, cos
, tan

-     sin X
      cos X
      tan X

  Met deze drie commando's worden de welbekende goniometrische functies `sinus`, `cosinus` en `tangens` berekend. De invoer van deze commando's, X, is eengetal (in graden).

arcsin
, arccos
, arctan

-     arcsin X
      arccos X
      arctan X

  Deze commando's zijn de inverse (dat is hier: terug-) functies van sin, cos en tan. De invoer van deze functies, X, is een getal. Die kan overigens niet elke waarde hebben, alléén die waarden die sin X, cos X en tan X kunnen hebben.

### Invoer en terugkoppeling met behulp van dialogen

Een dialoog is een venstertje met daarin een boodschap, of waarin om invoer wordt gevraagd. &kturtle; kent twee opdrachten voor een dialoog, namelijk `bericht` en `vraag`

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 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 variabele kan worden opgeslagen, of aan een commando kan worden doorgegeven. Bijvoorbeeld

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

  . Als de gebruiker de invoerdialoog annuleert of niets invult wordt de variabele leeg gemaakt.

## Toewijzingen aan variabelen

Eerst bekijken we variabelen, daarna hoe we daar waarden aan kunnen toewijzen.

Variabelen zijn woorden die met een $ beginnen, in de codebewerker worden ze met paars geaccentueerd.

In een variabele kan elk getal, tekenreeks of booleaanse waarde (waar/onwaar) worden bewaard. Met behulp van de toewijzing, `=`, kan de variabele zijn inhoud krijgen. Die inhoud blijft hierin aanwezig, totdat het programma eindigt, of als de variabele een andere waarde krijgt.

Variabelen, mits met inhoud, kunnen in de plaats van hun inhoud worden gebruikt. Zie bijvoorbeeld het volgende stukje &turtlescript;:

    $x = 10
    $x = $x / 3
    print $x

Eerst krijgt de variabele `$x` de waarde`10`. Daarna krijgt `$x` een nieuwe waarde, van zichzelf, gedeeld door `3` — dit betekent dus dat `$x` daarna de waarde `10 / 3` heeft. Tenslotte wordt `$x` afgedrukt (op het scherm). In regels 2 en 3 zie je dat `$x` in de plaats van zijn inhoud wordt gebruikt.

Variabelen meten een waarde hebben gekregen voordat ze kunnen worden gebruikt. Bijvoorbeeld:

    druk $n

zal een foutmelding geven.

Beschouw het volgende stukje &turtlescript;:

    $a = 2004
    $b = 25

    # Het volgende commando drukt "2029" af
    druk $a + $b
    achteruit 30
    # Het volgende commando drukt "2004 plus 25 is gelijk aan 2029" af
    print $a + " plus " + $b + " is gelijk aan " + ($a + $b)

In de eerste twee regels krijgen de variabelen `$a` en `$b` de waarden 2004 en 25. Daarna volgen twee `druk`-commando's met daartussen in een `achteruit 30`. In het commentaar voor de `druk`- commando's wordt uitgelegd wat er gebeurt. Zoals je ziet worden variabelen precies zo gebruikt als hun inhoud, je kunt ze met elke soort bewerkingen gebruiken, of als invoer voor commando's.

Nog een voorbeeld:

    $naam = vraag "Hoe heet je?"
    print "Ha die " + $naam + "! Veel plezier met het leren programmeren..."

Tamelijk recht zo die gaat. Ook hier kun je zien dat de variabele `$naam` precies als zijn inhoud, een tekenreeks, wordt gebruikt.

Bij het gebruik van variabelen is de inspectie erg nuttig. Hierin kun je de inhoud zien van alle huidige variabelen.

## 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 zwart.

### De schildpad laten wachten

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

wacht

-     wacht X

  `wacht X` laat de schildpad X seconden wachten.

      herhaal 36{
       vooruit 5
       draairechts 10
       wacht 0.5           # Denk erom: een punt
      }

  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 boolean { ... }

  De programmacode tussen de accolades wordt alleen uitgevoerd `als` de booleaanse waarde de waarde waar krijgt.

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

  Op de eerste regel krijgt `$x` de waarde 6. Op de tweede regel wordt een vergelijkingsbewerking gebruikt om de waarde van `$x > 5` te bepalen. Omdat die waar is, 6 is groter dan 5, zal het programmastuurcommando `als` de programmacode tussen de accolades laten uitvoeren.

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

anders

-     als booleaanse waarde { ... } anders { ... }

  `anders` kan worden gebruikt bij het programmastuurcommando `als`. De programmacode tussen de accolades na `anders` wordt alleen uitgevoerd als de booleaanse waarde de waarde onwaar heeft.

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

  De vergelijkingsbewerking bepaalt de waarde van `$x > 5`. Omdat 4 niet groter is dan 5 is die waarde onwaar. Dit betekent dat de programmacode tussen de accolades na `anders` wordt uitgevoerd.

### De lus "terwijl"

terwijl

-     terwijl booleaanse bewerking { ... }

  Het programmastuurcommando `terwijl` lijkt veel op als``. Het verschil is dat `terwijl` de programmacode tussen de accolades blijft herhalen totdat de booleaanse waarde onwaar is geworden.

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

  Op de eerste regel krijgt `$x` de waarde 1. Op de tweede regel wordt de waarde bepaald van`$x < 8`. Omdat die waarde waar is, start het programmastuurcommando`terwijl` het uitvoeren van de code tussen de accolades totdat de waarde van `$x < 8` onwaar is geworden. In dit voorbeeld wordt de code tussen de accolades 7 keer uitgevoerd, omdat telkens als de vijfde regel wordt uitgevoerd de waarde `$x` met 1 wordt vermeerderd.

### De lus "herhaal"

herhaal

-     Herhaal getal { ... }

  Het programmastuurcommando `herhaal` lijkt veel op `terwijl`. Het verschil is dat `herhaal` de programmacode tussen de accolades het in het getal opgegeven aantal keren blijft herhalen

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

voor

-     voor variabele = getal tot getal { ... }

  De lus `voor` is een tellende lus, en telt dus voor jou.

      voor $x = 1 tot 10 {
       druk $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 programmacode tussen de accolades schrijft de waarde van `$x` (op het scherm), vermenigvuldigd met 7. Nadat deze commando's zijn uitgevoerd zie je de tafel van 7 op het canvas staan.

  De standaard stapgrootte in een lus is 1, maar een andere waarde kan worden ingesteld met

      voor variabele = getal tot getal  stap getal { ... }

### Een lus verlaten

kap

-     kap

  Stopt onmiddellijk met het uitvoeren van de huidige lus en ga verder met het uitvoeren van de programmaregel direct na de lus.

### Het uitvoeren van je programma stoppen

afsluiten

-     afsluiten

  Beëindigt het uitvoeren van je programma.

### Invoer testen

test

-     test boolean { ... }

  Kan worden gebruikt voor het beredeneren van de juistheid van het programma of van de invoer.

      $in = ask "In welk jaar ben je geboren?"
      # het jaartal moet positief zijn
      test $in
      > 0

## Eigen commando's maken met leer

`leer`
is een erg leuk commando, omdat die kan worden gebruikt om je eigen commando's te maken. Commando's die je maakt kunnen invoer nodig hebben en uitvoer teruggeven. Laten we eens kijken hoe je een nieuw commando kunt maken:

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

Het nieuwe commando heet hier dus `cirkel`. `cirkel` heeft een invoer nodig, een getal, dat de grootte van de cirkel bepaalt. `cirkel` geeft geen uitvoer terug. 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 200,200
    cirkel 20

    ganaar 300,200
    cirkel 40

In het volgende voorbeeld maken we een commando met een
.

    leer faculteit $x {
        $r = 1
        voor $i = 1 tot $x {
            $r = $r * $i
        }
      geefdoor $r
    }

    druk faculteit 5

In dit voorbeeld maken we een nieuw commando met de naam `faculteit`. Als de invoer van dit commando `5` is, dan is de uitvoer `5*4*3*2*1`, en dat is 120. Door `geefdoor` wordt de waarde van de uitvoer doorgegeven (of ook wel: teruggegeven), zodat die bijvoorbeeld kan worden afgedrukt op het scherm, zoals in de laatste regel.

Commando's kunnen meer dan een invoer nodig hebben. In het volgende voorbeeld maken we een commando dat een rechthoek tekent:

    leer rechthoek $x, $y {
      vooruit $y
      draairechts 90
      vooruit $x
      draairechts 90
      vooruit $y
      draairechts 90
      vooruit $x
      draairechts 90
    }

Nu kun je `rechthoek 50, 100` doen, waarna de schildpad een rechthoek tekent op het canvas.