3.2. Varáveis e funções
| 3. Um tutorial de Script-Fu |

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

Isso ocorre por que o comando `let*` define uma área no seu script em que as variáveis declaradas são usáveis. Se você digitar a expressão `(+ a b)` depois de digitar a expressão anterior, você verá um erro - por que as variáveis declaradas só eram válidas no contexto do comando `let*`; Elas são o que os programadores chamam de variáveis locais.

#### 3.2.3. A sintaxe geral do comando `let*`

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

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

Onde as variáveis são definidas dentro de parênteses, por exemplo `(a 2)`, e expressões são quaisquer expressões válidas em Scheme. Lembre-se de que as variáveis declaradas aqui só são válidas dentro do código do `let*`: elas são variáveis locais.

#### 3.2.4. Espaços em branco

Previamente, mencionamos o fato de que provavelmente você vai querer usar identação para ajudar a clarear e organizar seus scripts. Isso é uma boa poĺítica, e não é um problema em Scheme — espaços em branco a mais (incluindo caracteres de tabulação e nova linha) são ignorados pelo interpretador de Scheme, e então podem ser usados liberalmente para tornar o script mais legível. Entretanto, se você está trabalhando na janela interativa do Script-fu, você terá que colocar sempre uma expressão inteira em uma única linha — isso é, a abertura e o fechamento dos parenteses mais externos da expressão tem que estar na mesma linha.

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

| Nota
A contrabarra - “`\`” indica para você que não há quebra de linha. Ignore-a (não digite esse sinal na sua linha no terminal interativo, e não aperte enter, somente continue digitando o que aparece na próxima linha)

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

- Segundo, perceba que nós não precisamos nos preocupar em “retornar” o resultado de nossa função — a última expressão será o valor “retornado” quando essa função for chamada. Digite a função no terminal, e então tente algo como:

      (Add (Add 5 6) 4)

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

Crie um relato de erro no Bugzilla