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

This is because the `let*` statement defines an area in your script in which the declared variables are usable; if you type the `(+ a b)` statement after the `(let* …)` statement, you'll get an error, because the declared variables are only valid within the context of the `let*` statement; they are what programmers call local variables.

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

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

            (let* ( variabelen )
              uitdrukkingen )

where variables are declared within parens, e.g., `(a 2)`, and expressions are any valid Scheme expressions. Remember that the variables declared here are only valid within the `let*` statement — they're local variables.

#### 3.2.4. Witruimte

Previously, we mentioned the fact that you'll probably want to use indentation to help clarify and organize your scripts. This is a good policy to adopt, and is not a problem in Scheme — white space is ignored by the Scheme interpreter, and can thus be liberally applied to help clarify and organize the code within a script. However, if you're working in Script-Fu's Console window, you'll have to enter an entire expression on one line; that is, everything between the opening and closing parens of an expression must come on one line in the Script-Fu Console window.

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

- Second, notice that we don't need to worry about how to “return” the result of our function — the last statement is the value “returned” when calling this function. Type the function into the console, then try something like:

      (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