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.

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. Allmän syntax för `let*`

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

            (let* ( variabler )
              uttryck )

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

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

- 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:

      (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