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/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