### 3.2. Variabili e funzioni

Ora che si sa che ogni istruzione Scheme va racchiusa tra parentesi e che il nome della funzione/operatore viene per primo si deve conoscere come creare ed usale le variabili e come creare ed invocare le funzioni. Si inizia con le variabili.

#### 3.2.1. Dichiarare le variabili

Anche se ci sono un paio di metodi diversi per dichiarare le variabili, il metodo preferito è quello di utilizzare il costrutto let*. Se si conoscono altri linguaggi di programmazione si noterà che questo costrutto equivale alla dichiarazione di una lista di variabili locali e di un intervallo di visibilità in cui esse sono utilizzabili. Ad esempio per dichiarare due variabili, a e b, inizializzate rispettivamente a 1 e 2 si scrive:

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

oppure su una sola linea

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

| Nota
Se si sta utilizzando la finestra della console è necessario mettere tutto ciò su una singola riga. In generale tuttavia si potrebbe voler adottare una forma di indentazione per rendere i propri script più leggibili. Si approfondirà quest'argomento nel capitolo dedicato agli spazi bianchi.

Questo dichiara due variabili, a e b, le inizializza poi stampa la somma delle due variabili.

#### 3.2.2. Cos'è una variabile locale?

Si noterà che l'addizione `(+ a b)` è stata scritta all'interno delle parentesi dell'espressione `let*` e non dopo di essa.

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. La sintassi generale di `let*`

La forma generale dell'istruzione `let*` è:

            (let* ( variabili )
              espressioni )

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

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. Assegnare un nuovo valore ad una variabile

Una volta che si è inizializzata una variabile, può essere necessario doverne cambiare il valore più avanti nello script. In tal caso si usi l'istruzione `set!` per cambiare il valore della variabile:

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

Si indovini cosa fa l'istruzione riportata sopra poi la si immetta nella finestra della console Script-Fu.

#### 3.2.6. Funzioni

Ora che si è appreso l'uso delle variabili si proceda con le funzioni. Le funzioni si dichiarano con la seguente sintassi:

            (define
               (
                  nome
                  elenco parametri
               )
               espressioni
            )

dove `name` è il nome assegnato alla funzione, `param-list` è una lista di parametri separati da spazi e `expressions` è una serie di espressioni che la funzione esegue quando viene chiamata. Ad esempio:

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

`AddXY` è il nome della funzione e `inX` e `inY` sono le variabili. Questa funzione prende i suoi due parametri e li somma.

Se si è programmato in altri linguaggi imperativi (come C/C++, Java, Pascal, ecc.), si può notare come manchino un paio di cose a questa definizione di funzione rispetto agli altri linguaggi di programmazione.

- Per prima cosa si noti che i parametri non hanno un «tipo» (non si devono dichiarare come stringhe o interi, ecc.). Scheme è un linguaggio non tipizzato. Questo risulta più comodo e permette una scrittura veloce degli script.

- 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. Una guida sugli Script-Fu |  | 3.3. Liste, liste e ancora liste

Report a bug in GIMP Segnalate l'errore sulla piattaforma apposita