### 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/operador se listan primero, necesitamos saber como crear y usar variables, y como crear y usar funciones. Comenzaremos con las funciones.

#### 3.2.1. Declarar 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 línea:

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

| Nota
Tendrá que poner todo esto en una línea si está usando la ventana de la consola. En general, sin embargo, querrá adoptar una práctica similar de sangrado para ayudar a hacer sus scripts más legibles. Hablaremos un poco más de esto en la sección sobre el espacio en 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.

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 sintaxis general de `let*`

La forma general de una declaración `let*` es:

            (let* ( variables )
              expresiones )

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. Espacio en blanco

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. Asignar un valor nuevo a una variable

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

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

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

#### 3.2.6. Funciones

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

            (define
               (
                  nombre
                  lista de parámetros
               )
               expresiones
            )

donde `nombre` es el nombre asignado a esta función, `lista de parámetros` es una lista de espacio limitado de nombres de parámetros, y `expresiones` son una serie de expresiones que la función ejecuta cuando se la 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 las compara con otros lenguajes de programación.

- Primero, tenga en cuenta que los parámetros no tienen unos “tipos” (es decir, 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 escribir un 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. Un tutorial de Script-Fu |  | 3.3. Listas, listas y más listas

Report a bug in GIMP Report a documentation error