### 3.2. Variabelen en functies

Nu we weten dat elk argument voor Scheme wordt omsloten door haakjes en dat de functienaam/operator als eerste wordt vermeld, moeten we weten hoe variabelen te maken en te gebruiken, en hoe functies te maken en te gebruiken. We zullen beginnen met de variabelen.

#### 3.2.1. Variabelen declareren

Hoewel er een aantal verschillende methoden zijn voor het declareren van variabelen, is de voorkeursmethode om de constructie let* te gebruiken. Als u bekend bent met andere programmeertalen is deze constructie equivalent aan het definiëren van een lijst met lokale variabelen en het bereik waarin ze actief zijn. Als een voorbeeld, om twee variabelen te declareren, a en b, respectievelijk te initialiseren tot 1 en 2, zou u schrijven:

            (let*
               (
                  (a 1)
                  (b 2)
               )
               (+ a b)
            )

of, als een regel:

    (let* ( (a 1) (b 2) ) (+ a b) )

| Opmerking
U zult dit allemaal op een regel moeten plaatsen als u het venster van de console gebruikt. In het algemeen zult u echter een soortgelijke werkwijze voor inspringen willen adopteren, om u te helpen uw scripts beter leesbaar te maken. We zullen daar iets meer over vertellen in het gedeelte over witruimte.

Dit declareert twee lokale variabelen, a en b, initialiseert ze en drukt dan de som van de twee variabelen af.

#### 3.2.2. Wat is een lokale variabele?

U zult opmerken dat we de optelling `(+ a b)` binnen de haakjes van de uitdrukking `let*` schreven, niet erachter.

Dat is omdat het argument `let*` een gebied definieert in uw script waarin de gedeclareerde variabelen te gebruiken zijn; als u het argument `(+ a b)` typt na het argument `(let* …)`, zult u een fout krijgen, omdat de gedeclareerde variabelen alleen geldig zijn binnen de context van het argument `let*`; ze zijn wat programmeurs lokale variabelen noemen.

#### 3.2.3. De algemene syntaxis van `let*`

De algemene vorm van een argument `let*` is:

            (let* ( variabelen )
              uitdrukkingen )

waar variabelen worden gedeclareerd binnen haakjes, bijv. `(a 2)` en uitdrukkingen geldige uitdrukkingen voor Scheme zijn. Onthoud dat de hier gedeclareerde variabelen alleen geldig zijn binnen het argument `let*` — het zijn lokale variabelen.

#### 3.2.4. Witruimte

Eerder vertelden we al het feit dat u waarschijnlijk inspringen wilt gebruiken om uw scripts te verduidelijken en te organiseren. Dat is een goede werkwijze om te adopteren en is geen probleem in Scheme — witruimte wordt door de interpreter van Scheme genegeerd en kan dus vrij worden toegepast om de code binnen een script te helpen verduidelijken en te organiseren. Als u echter werkt in het venster Script-Fu's Console zult u een gehele uitdrukking op een regel moeten invoeren; dat is: alles tussen het openings- en sluithaakje van een uitdrukking moet op een regel worden gezet in het venster Script-Fu Console.

#### 3.2.5. Toewijzen van een nieuwe waarde aan een variabele

Als u eenmaal een variabele hebt geïnitialiseerd, zou u misschien de waarde ervan later in het script moeten wijzigen. Gebruik het argument `set!` om de waarde van de variabele te wijzigen:

            (let* ( (theNum 10) ) (set! theNum (+ theNum theNum)) )

Probeer te raden wat het bovenstaande argument zal doen, en ga door en voer het in het venster Script-Fu Console in.

#### 3.2.6. Functies

Nu het gevoel voor variabelen hebt, laten we eens aan het werk gaan met enkele functies. U declareert een functie met de volgende syntaxis:

            (define
               (
                  naam
                  parameter-lijst
               )
               uitdrukkingen
            )

waar `naam` de naam is die aan deze functie is toegewezen, `parameter-lijst` is een door spaties gescheiden lijst met namen van parameters en `uitdrukkingen` is een reeks uitdrukkingen die de functie uitvoert als die wordt aangeroepen. Bijvoorbeeld:

    (define (TelOpXY inX inY) (+ inX inY) )

`TelOpXY` is de naam van de functie en `inX` en `inY` zijn de variabelen. Deze functie neemt zijn twee parameters en telt die bij elkaar op.

Als u in andere imperatieve talen hebt geprogrammeerd (zoals C/C++, Java, Pascal etc), zou u een paar dingen kunnen opmerken die afwezig zijn in deze definitie voor de functie, vergeleken met de andere programmeertalen.

- Als eerste, merk op dat de parameters geen “types” hebben (dat is, we hebben ze niet gedeclareerd als strings, of integers etc). Scheme is een taal zonder types. Dat is handig en maakt sneller schrijven van scripts mogelijk.

- Ten tweede, merk op dat we ons geen zorgen hoeven te maken over hoe het resultaat van onze functie “terug te geven” — het laatste argument is de “teruggegeven” waarde bij het aanroepen van deze functie. Type de functie in de console, en probeer iets als:

      (TelOpXY (TelOpXY 5 6) 4)

3. Een handleiding voor Script-Fu |  | 3.3. Lijsten, lijsten en nog meer lijsten

Report a bug in GIMP Rapporteer een fout in de documentatie