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