3.2. Variables et fonctions
| 3. Didacticiel pour Script-Fu |

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

C'est parce que la déclaration `let*` définit un domaine dans le script où ces variables sont utilisables ; si vous aviez placé la déclaration (+ a b) après la déclaration (let* …) , vous auriez obtenu une erreur, car les variables déclarées ne sont valables qu'à l'intérieur de la déclaration `let*`. C'est ce que les programmeurs appellent des variables locales.

#### 3.2.3. Syntaxe générale de `let*`

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

            (let* ( variables )
              expressions )

où les variables sont déclarées entre parenthèses, p. ex. `(a 2)`, et les expressions sont une/des expression(s) Scheme valide(s). Rappelez-vous que les variables déclarées ne sont valables qu'à l'intérieur d'une déclaration `let*` : ce sont des variables locales.

#### 3.2.4. Espace Blanc

Précédemment, nous avons mentionné le fait que vous voudriez certainement utiliser des indentations pour clarifier votre programme. C'est une bonne méthode de présentation et ce n'est pas un problème pour Scheme, car l'interpréteur ignore les espaces blancs. Mais si vous utilisez la Console pour Script-Fu, une expression devra tenir sur une seule ligne entre les parenthèses d'ouverture et de fermeture.

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

| Note
Les « `\` » indiquent qu'il n'y a pas de retour à la ligne. Ignorez-les (ne les inscrivez pas dans votre script-fu et ne tapez pas la touche Entrée), et tapez au kilomètre sans vous préoccuper des fins de ligne.

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

- Ensuite, que nous n'avons pas à nous préoccuper de la façon de « retourner » le résultat de notre fonction ; la dernière déclaration est la valeur retournée quand on appelle la fonction. Tapez la définition de la fonction dans la console, puis essayez quelque chose comme :

      (AddXY (AddXY 5 6) 4)

3. Didacticiel pour Script-Fu |  | 3.3. Listes, des listes et encore des listes

Envoyez un rapport d'anomalie à Bugzilla