3.2. Variabili e funzioni
| 3. Una guida sugli Script-Fu |

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

Ciò perché l'istruzione `let*` definisce un'area nello script in cui le variabili dichiarate sono utilizzabili; se si digita l'istruzione `(+ a b)` dopo l'istruzione `(let* ...)` si ottiene un errore poiché le variabili dichiarate sono valide unicamente nel contesto dell'istruzione `let*`, sono quelle che i programmatori chiamano variabili locali.

#### 3.2.3. La sintassi generale di `let*`

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

            (let* ( variabili )
              espressioni )

dove variabili sono dichiarate all'interno delle parentesi, per esempio `(a 2)`, e nelle espressioni vi può essere una qualsiasi espressione valida in Scheme. Si ricordi che le variabili qui dichiarate sono valide solo all'interno dell'istruzione `let*`, dato che sono variabili locali.

#### 3.2.4. Spazi bianchi

Si è menzionato precedentemente che si può utilizzare l'indentazione per rendere più chiari ed organizzare meglio i propri script. È una buona pratica da adottare e non crea problemi in Scheme -- gli spazi bianchi sono ignorati dall'interprete Scheme -- può quindi essere adottata per organizzare il codice all'interno di uno script. Tuttavia se si lavora nella finestra della console di Script-fu si deve immettere una intera espressione su un unica linea; cioè tutto ciò che sta tra la parentesi iniziale e finale di una espressione, nella finestra della console di Script-Fu deve stare su un'unica riga.

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

| Nota
La «`\`» indica che non c'è un'interruzione di riga. La si ignori (non la si digiti nella console Script-Fu e non si prema Invio) e si continui con la linea successiva.

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

- Secondo, si noti che non ci si deve preoccupare di «ritornare» il risultato della funzione -- l'ultima istruzione è il valore «ritornato» al chiamante della funzione. Si immetta la funzione nella console e poi si provi qualcosa del tipo:

      (AddXY (AddXY 5 6) 4)

3. Una guida sugli Script-Fu |  | 3.3. Liste, liste e ancora liste

Segnalate l'errore su Bugzilla