3.2. Variablen und Funktionen
| 3. Ein Skript-Fu-Tutorial |

### 3.2. Variablen und Funktionen

Jetzt, wo wir wissen, dass jede Scheme-Anweisung von Klammern umgeben ist und dass der Funktionsname/-operator als erstes aufgeführt wird, müssen wir sehen, wie man Variablen oder Funktionen erzeugt und benutzt. Wir fangen mit den Variablen an.

#### 3.2.1. Variablen deklarieren

Es gibt mehrere verschiedene Methoden, um Variablen zu deklarieren, aber die bevorzugte Methode ist das `let*`-Konstrukt. Wenn Sie mit anderen Programmiersprachen vertraut sind: Dieses Konstrukt ist äquivalent dazu, eine Liste lokaler Variablen mit zugehörigem Gültigkeitsbereich zu definieren. Um beispielsweise zwei Variablen a und b zu deklarieren und mit den Werten 1 beziehungsweise 2 zu initialisieren, würden Sie folgendes schreiben:

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

oder, als Einzeiler:

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

| Anmerkung
Sie müssen dies alles in eine Zeile schreiben, wenn Sie das Konsolenfenster benutzen. Im Allgemeinen sollten Sie allerdings einen ähnlichen Einrückungsstil wie oben übernehmen, um Ihre Skripte lesbarer zu gestalten. Wir werden im Abschnitt über Leerzeichen noch ein wenig mehr dazu sagen.

Das deklariert zwei lokale Variablen a und b, initialisiert sie, und gibt dann die Summe der beiden Variablen aus.

#### 3.2.2. Was ist eine lokale Variable?

Sie werden bemerkt haben, dass wir die Summe `(+ a b)` innerhalb der Klammern des `let*`-Ausdrucks und nicht außerhalb geschrieben haben.

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. Die allgemeine Syntax von `let*`

Die allgemeine Form der `let*`-Anweisung ist:

            (let* ( variablen )
              ausdrücke )

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

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. Einer Variablen einen neuen Wert zuweisen

Wenn Sie eine Variable initialisiert haben, müssen Sie ihren Wert vielleicht später im Skript verändern. Verwenden Sie dafür die `set!`-Anweisung:

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

Überlegen Sie sich, was die obige Anweisung tun wird, und dann probieren Sie es aus und geben Sie sie in der Skript-Fu-Konsole ein.

#### 3.2.6. Funktionen

Nachdem Sie nun den Dreh mit den Variablen raushaben, lassen Sie uns ein wenig mit Funktionen arbeiten. Sie deklarieren eine Funktion gemäß der folgenden Syntax:

            (define
               (
                  name
                  param-list
               )
               ausdrücke
            )

wobei `name` der der Funktion zugewiesene Name ist, `param-list` eine durch Leerzeichen getrennte Liste von Parameternamen und `ausdrücke` eine Folge von Ausdrücken, die die Funktion bei ihrem Aufruf ausführt. Zum Beispiel:

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

`AddXY` ist der Funktionsname, und `inX` und `inY` sind die Variablen. Die Funktion erwartet zwei Parameter und addiert sie.

Wenn Sie bereits in anderen imperativen Sprachen programmiert haben (z.B. in C/C++, Java, Pascal, etc.), dann werden Sie vielleicht bemerkt haben, dass im Vergleich zu anderen Programmiersprachen einige Dinge in dieser Funktionsdefinition fehlen.

- Als erstes beachten Sie, dass die Parameter keinen „Typ“ haben (d.h. wir haben sie nicht als Zeichenketten, Ganzzahlen etc. deklariert). Scheme ist eine typfreie Sprache. Das ist ganz praktisch und erlaubt es uns, Skripte sehr viel schneller zu schreiben.

- 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. Ein Skript-Fu-Tutorial |  | 3.3. Listen, Listen und noch mehr Listen

Report a bug in GIMP Report a documentation error