3.2. Variables y funciones
| 3. Un tutorial de Script-Fu |

### 3.2. Variables y funciones

Ahora que sabemos que todas las declaraciones en Scheme están entre paréntesis, y que el nombre de función/operadores se listan primero, necesitamos saber como crear y usar variables, y como crear y usar funciones. Comenzaremos con las funciones.

#### 3.2.1. Declarando variables

Aunque hay un par de métodos diferentes para declarar variables, el método preferido es usar la construcción let*. Si está familiarizado con otros lenguajes de programación, esta construcción es equivalente a definir una lista de variables locales y una extensión en la cual están activas. Como ejemplo, para declarar dos variables, a y b, inicializadas a 1 y 2, respectivamente, escriba:

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

o, en una linea:

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

| Nota
Tendrá que poner todo esto en una linea si está usando la ventana de la consola. En general, querrá adoptar una práctica similar para ayudar a hacer sus scripts más legibles. Hablaremos un poco más de esto en la sección espacio blanco.

Esto declara dos variables locales, a y b, inicializados, que muestra la suma de las dos variables.

#### 3.2.2. ¿Que es una variable local?

Notará que escribimos la suma (+ a b) bajo los paréntesis de la expresión let* , no después de ella.

Esto es porque la declaración let* define un area en su script en el que se declaran las variables que serán utilizables; si teclea (+ a b) y después (let* ...), obtendrá un error, porque las variables declaradas son, solo, válidas bajo el contexto de la declaración let* ; son lo que los programadores llaman variables locales.

#### 3.2.3. La sintaxis general de `let*`

la forma general de una declaración `let*`:

            (let* ( variables )
              expressions )

donde las variables son declaradas bajo paréntesis, p. e. (a2), y expresiones son cualquier expresión válida de Scheme. Recuerde que las variables declaradas aquí son solo válidas bajo la declaración `let*`, son variables locales..

#### 3.2.4. Espacio blanco

Previamente, mencionamos el hecho de que, probablemente, quiere usar indetation para ayudar a clarificar y organizar sus scripts. Esto es una buena politica a adoptar, y no es un problema en Scheme, espacio en blanco es ignorado por el interprete Scheme, y se puede aplicar para ayudar a clarificar y organizar el código bajo un script. , si está trabajando en la ventana de la consola de Script-Fu, tendrá que entrar una expresión entera en una linea; todo, entre los paréntesis de inicio y fin de una expresión, debe venir en una linea en la ventana de la consola de Script-Fu.

#### 3.2.5. Asignando un nuevo valor a una variable

Una vez que ha inicializado una variable, podría necesitar cambiar este valor, más tarde en el script. Usa la declaración set! para cambiar el valor de la variable:

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

Intente adivinar lo que la declaración de arriba hará, entonces, adelante e introdúzcalo en la ventana de la consola de Script-Fu.

| Nota
La "\" indica que allí no hay una linea rota. Ignórelo (no lo escriba en su consola de Script-Fu y no pulse Enter), justo continue con la siguiente linea.

#### 3.2.6. Funciones

Ahora que entendemos las variables, trabajemos con algunas funciones. Declare una función con la siguiente sintaxis:

            (define
               (
                  name
                  param-list
               )
               expressions
            )

donde `name` es el nombre asignado a esta función, `param-list` es una lista espacio -delimitada de nombres de parámetros, y `expressions` son una serie de expresiones que las funciones ejecutan cuando se las llama. Por ejemplo:

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

`AddXY` es el nombre de función y `inX` y `inY` son las variables. Esta función toma los dos parámetros y los suma juntos.

Si ha programado en otro lenguaje imperativo (como C/C++, Java, Pascal, etc.), podría notar que un par de cosas no están presentes en esta definición de función, cuando la comparas con otros lenguajes de programción.

- Primero, nota que los parámetros no tienen un "tipo" (no se declaran como cadenas, o íntegros, etc.). Scheme es un lenguaje sin tipos. Esto es práctico y permite una escritura más rápida de scripts.

- Segundo, nota que no necesitamos preocuparnos de como devolver los resultados de nuestra función, la última declaración es el valor devuelto cuando llama a esta función. Escriba la función en la consola, entonces intente algo como:

      (AddXY (AddXY 5 6) 4)

3. Un tutorial de Script-Fu |  | 3.3. Listas, listas y más listas