### 3.2. Varáveis e funções

Agora que você sabe que todo comando de Scheme está entre parênteses, e que o nome da função ou operador vem listado primeiro, nós precisamos saber como criar e usar variáveis, e como criar e usar novas funções. Vamos começar pelas variáveis.

#### 3.2.1. Declarando variáveis

Embora haja alguns métodos diferentes de declarar variáveis, o método preferido é usando a construção let*. Se você estiver familiarizado com outras linguagens de programação, esta construção é equivalente a definir uma lista de variáveis locais no escopo em que as mesmas estão ativas. Como um exemplo de como você pode declarar duas variáveis, "a" e "b", inicializadas para 1 e 2 respectivamente, você pode escrever:

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

ou, em uma linha só:

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

| Nota
Você terá que por tudo isso na mesma linha se você está usando a janela de terminal. Em geral, no entanto, é melhor você adotar uma prática de identação (recuos), similar a que você usa em outras linguagens, para manter seus scripts mais legíveis.

Isso declara duas variáveis locais, "a" e "b", as inicializa, e então imprime a soma das duas variáveis.

#### 3.2.2. O que é uma Variável Local?

Você notará que nós escrevemos a soma `(+ a b)` dentro dos parênteses do código da expressão `let*`, e não depois de fecha-los.

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. A sintaxe geral do comando `let*`

A forma geral de um comando `let*` é:

            (let* ( variáveis )
              expressões )

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. Espaços em branco

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. Atribuindo um novo valor a uma variável

Uma vez que você tenha inicializado uma variável, você pode precisar mudar seu valor mais tarde, dentro do script. Use o comando `set!` para mudar o valor da variável:

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

Tente adivinhar o que o comando acima vai fazer, e então, vá em frente e digite-o na janela do terminal do Script-Fu

#### 3.2.6. Funções

Agora que você entendeu como funcionam as variáveis, vamos trabalhar com algumas funções. Você declara uma função com a seguinte sintaxe:

            (define
               (
                  nome
                  lista-de-parâmetros
               )
               expressões
            )

Onde `nome` é o nome que você está dando a esta função, `lista-de-parâmetros` é uma lista separada por espaços com os nomes dos parâmetros, e `expressões` é uma série de expressões que a função executa quando é chamada. Por exemplo:

    (define (Add X Y) (+ X Y) )

`Add` é o nome da função e `X` e `Y` são as variáveis. Esta função toma dois parâmetros e os soma.

Se você já programou em linguagens de tipagem estática (como C/C++, java) você deve notar que algumas coisas estão ausentes nessa declaração de função em comparação com aquelas.

- Primeiro, note que os parâmetros não tem “tipos” (isso é, nós não os declaramos como strings, inteiros, etc...). Scheme é uma linguagem sem tipos. Isso é prático e permite a criação de scripts de forma mais rápida.

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

      (Add (Add 5 6) 4)

3. Um tutorial de Script-Fu |  | 3.3. Listas, Listas e mais Listas!

Report a bug in GIMP Report a documentation error