3.2. Variables i funcions
| 3. Programa d'aprenentatge de l’Script-Fu |

### 3.2. Variables i funcions

Ara que sabem que totes les declaracions en Scheme estan entre parèntesis, i que el nom de la funció o operador va primer, hem d'aprendre a crear i utilitzar variables, i com crear i utilitzar funcions. Començarem amb les variables.

#### 3.2.1. Declaració de variables

Encara que hi ha un parell de mètodes diferents per declarar variables, el preferit és l'ús de l'estructura let*. Si esteu familiaritzats amb altres llenguatges de programació, aquesta construcció és equivalent a definir una llista de variables locals i una extensió en la qual estan actives. Com a exemple, per a declarar dues variables, a i b, inicialitzades respectivament a 1 i 2, escriviu:

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

o, en una línia:

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

| Nota
Haureu de posar tot això en una línia si esteu utilitzant la finestra de la consola. Tanmateix, voldreu adoptar una pràctica similar de sagnat per ajudar a fer els vostres scripts més llegibles. Parlarem una mica més d'això en la secció sobre l'espai blanc.

Això declara dues variables locals, a i b, inicialitzades, que mostren la suma de les dues variables.

#### 3.2.2. Que és una variable local?

Notareu que escrivim la suma `(+ a b)` dins el parèntesi de l'expressió `let*`, i no després d'ella.

Això es deu al fet que la declaració `let*` defineix una àrea en el vostre script on les variables són utilitzables; si teclegeu la declaració `(+ a b)` després de la declaració `(let* …)`, obtindreu un error, ja que les variables declarades són només vàlides en el context de la declaració `let*`. Això és el que els programadors en diuen variables locals.

#### 3.2.3. La sintaxi general del `let*`

La forma general d'una declaració `let*` és:

            (let* ( variables )
              expressions )

on les variables es declaren entre parèntesis, per exemple, `(a 2)`, i les expressions són qualsevol expressió vàlida de l'Scheme. Recordeu que les variables declarades són només vàlides dins la declaració `let*`, aquestes són variables locals.

#### 3.2.4. Espai blanc

Anteriorment hem esmentat que probablement vulgueu utilitzar el sagnat per ajudar a aclarir i organitzar els vostres scripts. Això és una bona política a adoptar, i no és un problema per a l'Scheme, ja que l'intèrpret Scheme ignora l'espai en blanc, i es pot aplicar per ajudar a aclarir i organitzar el codi dins un script. Però si esteu treballant en la finestra de la consola de Script-Fu, haureu d'introduir una expressió sencera en una línia, entre l'obertura i el tancament del parèntesi.

#### 3.2.5. Assigna un valor nou a una variable

Una vegada que heu iniciat una variable, podríeu necessitar canviar aquest valor més endavant en l'script. Utilitzeu la declaració `set!` per canviar el valor de la variable:

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

Intenteu endevinar què farà la declaració, llavors, introduïu-la en la consola de Script-Fu.

| Nota
La «`\`» indica que no hi ha una línia trencada. Ignoreu-la (no ho escriviu en la consola de Script-Fu i no premeu Retorn), continueu amb la línia següent.

#### 3.2.6. Funcions

Ara que entenem les variables, treballem amb algunes funcions. Declareu una funció amb la següent sintaxi:

            (define
               (
                  name
                  param-list
               )
               expressions
            )

on el `nom` és el nom assignat a aquesta funció, `llista de paràmetres` és una llista limitada de noms de paràmetres, i `expressions` és una sèrie d'expressions que la funció executa quan la crida. Per exemple:

    (defineix (AddXY inX inY) (+ inX inY) )

`AddXY` és el nom de la funció, `inX` i `inY` són les variables. Aquesta funció agafa els dos paràmetres i els suma.

Si heu programat en un altre llenguatge (com C/C++, Java, Pascal, etc.), haureu notat un parell de coses que no hi són en la definició d'aquesta funció en comparació amb altres llenguatges de programació.

- Primer, observeu que els paràmetres no tenen un «tipus» (és a dir, no es declaren com a cadenes, o enters, etc.). Scheme és un llenguatge sense tipus. Això és pràctic i permet una escriptura més ràpida dels scripts.

- Segon, no hem de preocupar-nos de com «retornar» els resultats de la nostra funció — l'última declaració és el valor «retornat» quan es crida la funció. Escriviu la definició de la funció en la consola, llavors intenteu alguna cosa com:

      (AddXY (AddXY 5 6) 4)

3. Programa d'aprenentatge de l’Script-Fu |  | 3.3. Llistes, llistes i més llistes

Report an error in the bug tracker