### 3.2. Variables et fonctions

Maintenant que nous savons que toute déclaration Scheme est incluse entre parenthèses, et que le nom de fonction ou l’opérateur vient en premier, nous devons apprendre à créer et utiliser les variables. Commençons par les variables.

#### 3.2.1. Déclaration de Variables

Bien qu’il existe deux méthodes pour déclarer des variables, la préférée est l’utilisation de la structure let*. Si vous connaissez d’autres langages de programmation, cette structure équivaut à définir une liste de variables locales et un champ d’application pour ces variables. Par exemple, pour déclarer deux variables, a et b, initialisées respectivement à 1 et 2, vous écrirez :

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

ou, sur une ligne :

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

| Note
Avec la Console pour Script-Fu, vous ne pourrez utiliser que l’écriture sur une ligne. Mais nous continuerons à employer les indentations pour que le script soit plus clair. Nous aurons plus de détails en abordant la section sur l’Espace Blanc.

Ceci déclare deux variables locales, a et b, les initialise, puis affiche leur somme.

#### 3.2.2. Qu’est-ce qu’une Variable Locale ?

Vous remarquerez que nos avons écrit l’addition `(+ a b)` à l’intérieur des parenthèses de l’expression `let*` et non pas après elles.

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. Syntaxe générale de `let*`

La forme générale d’une déclaration `let*` est :

            (let* ( variables )
              expressions )

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

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. Attribuer une nouvelle valeur à une variable

Après avoir initialisé une variable, il se peut que vous ayez besoin d’en changer la valeur plus loin dans le script. Utilisez la déclaration `set!` pour changer la valeur d’une variable :

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

Essayez de deviner ce que fait cette déclaration, puis entrez-la dans la console pour Script-Fu.

#### 3.2.6. Fonctions

Maintenant que nous savons manipuler les variables, passons aux fonctions. Vous déclarez une fonction avec la syntaxe suivante :

            (define
               (
                  name
                  param-list
               )
               expressions
            )

où `nom` est le nom donné à la fonction, `liste de paramètres` est une liste délimitée de noms de paramètres, et `expressions` est une série d’expressions que la fonction exécute quand elle est appelée. Par exemple :

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

`AddXY` est le nom de la fonction, `inX` et `inY` sont les variables. Cette fonction prend ses deux paramètres et les additionne.

Si vous avez programmé dans d’autres langages (comme C/C++, Java, Pascal…etc.), vous aurez noté que plusieurs choses sont absentes dans la définition de cette fonction comparée aux autres langages.

- Premièrement, notez que les paramètres n’ont pas de « type » (c.-à-d. que nous ne les avons pas déclarés comme chaîne, ou entiers… etc.). Scheme est un langage sans-type. C’est pratique et cela permet une écriture rapide des scripts.

- 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. Didacticiel pour Script-Fu |  | 3.3. Listes, des listes et encore des listes

Report a bug in GIMP Report a documentation error