3.2. Variabler och funktioner
| 3. En Script-Fu-handledning |

### 3.2. Variabler och funktioner

Nu då vi vet att varje Scheme-sats omsluts av parenteser, och att funktionsnamnet/operatorn listas först, behöver vi veta hur vi skapar och använder variabler, och hur vi skapar och använder funktioner. Vi börjar med variablerna.

#### 3.2.1. Deklarera variabler

Även om det finns några olika metoder för att deklarera variabler så är den föredragna metoden att använda konstrukten let*. Om du är bekant med andra programspråk så är denna konstrukt ekvivalent med att definiera en lista med lokala variabler och en räckvidd i vilken de är aktiva. För att exempelvis deklarera två variabler, a och b, initierade till 1 respektive 2, skulle du skriva:

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

eller som en rad:

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

| Notera
Du kommer behöva stoppa allt detta på en rad om du använder konsolfönstret. Allmänt kommer du dock vilja adoptera en liknande indentering för att hjälpa till göra dina skript mer läsliga. Vi kommer prata lite mer om detta i avsnittet om blanktecken.

Detta deklarerar två lokala variabler, a och b, initierar dem, och skriver sedan ut summan av de två variablerna.

#### 3.2.2. Vad är en lokal variabel?

Du kommer se att vi skrev summeringen `(+ a b)` inuti parenteserna för `let*`-uttrycket, inte efter det.

Detta är för att `let*`-satsen definierar ett område i ditt skript i vilken de deklarerade variablerna går att använda. Om du skriver satsen `(+ a b)` efter `(let* …)`-satsen så kommer du få ett fel, för de deklarerade variablerna är endast giltiga inom `let*`-satsens kontext, de är vad programmerare kallar lokala variabler.

#### 3.2.3. Allmän syntax för `let*`

Den allmänna formen för en `let*`-sats är:

            (let* ( variabler )
              uttryck )

där variabler deklareras inuti parenteser, t.ex. , `(a 2)`, och uttryck är alla giltiga Scheme-uttryck. Kom ihåg att variablerna som deklareras här endast är giltiga inuti `let*`-satsen — de är lokala variabler.

#### 3.2.4. Blanktecken

Tidigare nämnde vi faktum att du troligen kommer vilja använda indentering för att hjälpa till att tydliggöra och organisera dina skript. Detta är en bra policy att anamma, och är inte ett problem i Scheme — blanktecken ignoreras av Scheme-tolken, och kan därmed tillämpas rikligt för att hjälpa till att tydliggöra och organisera koden i ett skript. Om du arbetar i Script-Fu-konsolfönstret kommer du dock behöva mata in ett helt uttryck på en rad, det vill säga att allt mellan start- och slutparenteserna för ett uttryck måste komma på en rad i Script-Fu-konsolfönstret.

#### 3.2.5. Tilldela ett nytt värde till en variabel

När du har initierat en variabel kan du senare behöva ändra dess värde i skriptet. Använd satsen `set!` för att ändra variabelns värde:

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

Försök gissa vad satsen ovan kommer göra, och mata sedan in den i Script-Fu-konsolfönstret.

#### 3.2.6. Funktioner

Nu då du har koll på variabler ska vi börja arbeta med några funktioner. Du deklarerar en funktion med följande syntax:

            (define
               (
                  namn
                  param-lista
               )
               uttryck
            )

där `namn` är namnet som denna funktion tilldelas, `param-lista` är en blankstegsseparerad lista över parameternamn, och `uttryck` är en serie uttryck som funktionen exekverar när den anropas. Till exempel:

    (define (AddXY inX inY) (+ inX inY) )

`AddXY` är funktionens namn och `inX` samt `inY` är variablerna. Denna funktion tar sina två parametrar och adderar dem.

Om du programmerat i andra imperativa språk (som C/C++, Java, Pascal och så vidare), så kanske du lägger märke till att några saker saknas i denna funktionsdefinition i jämförelse med andra programspråk.

- Notera först att parametrarna inte har några ”typer” (det vill säga, vi deklarerade dem inte som strängar, heltal och så vidare.). Scheme är ett typlöst språk. Detta är praktiskt och tillåter snabbare skriptskrivande.

- Se sedan att vi inte behöver oroa oss om hur vi ska ”returnera” resultatet av vår funktion — den sista satsen är värdet som ”returneras” vid anrop av denna funktion. Skriv in funktionen i konsolen, prova sedan med något som:

      (AddXY (AddXY 5 6) 4)

3. En Script-Fu-handledning |  | 3.3. Listor, listor och åter listor

Report a bug in GIMP Rapportera ett dokumentationsfel