## A armazenar e a manipular dados

Os programas que escrevemos até agora não tem um ponto fundamental da computação. Na verdade, é sobre processar dados através de instruções específicas. No mundo dos buggles, os dados principais estão escondidos atrás de uma representação gráfica, mas isto não é motivo para nunca manipular alguns dados explicitamente.

### Dados em [!thelang]

Num programa, pode usar vários tipos de dados, tais como números inteiros ou cadeias de caracteres, ou caracteres. Se quiser usar um dado várias vezes, precisa armazená-la numa variável, que é uma célula de memória a conter um valor: põe o seu dado (digamos o valor '5') na variável (digamos 'comprimento') e pode recuperá-la mais tarde quando precisar dela. Isto é muito similar a uma caixa com o rótulo 'presente' na qual pode pôr alguma coisa, como um perfume "Channel N°5".

### Declaração de variáveis

Declarar (ie, criar) uma variável em [!thelang], é muito simples. Simplesmente escreve [!java]o tipo dele, um espaço e o nome da variável.[/!] [!scala]a palavra-chave `var`, o nome da variável, um dois-pontos (:) e o tipo da variável, um sinal de igualdade (=) e um valor inicial.[/!] [!python]o nome da variável, um sinal de igual (=) e um valor inicial.[/!] O nome da variável é o rótulo para recuperar ela depois[!python].[/!] [!java|scala] enquanto o tipo é o tipo de dado que a variável aceita guardar.[/!] É proibido usar espaços em nomes de variáveis. Pode nomear uma variável `quantidadeDePassos` se quiser, mas `quantidade de passos` não é um nome válidos.

[!c|java]

Então, para criar uma variável chamada x para guardar inteiros, deve escrever:

    int x;

Se quiser, pode especificar o valor inicial da variável a adicionar um símbolo de igual (=) seguido do valor depois da declaração.

    int x=5;

[/!] [!python]

Então se quiser que a variável tenha o valor inicial de 5, deve digitar:

    x = 5

[/!] [!scala]

Logo, para criar uma variável chamada x que vai guardar inteiros e com 42 como valor inicial, deve escrever:

    var x:Int = 42

Na maioria dos casos, o compilador é capaz de adivinhar o tipo da variável baseado no valor inicial e pode omitir o tipo:

    var x = 42

Ainda tem que especificar se usa alguns valores genéricos como uma inicialização, tais como o valor muito especial `null`, cujo tipo parece ser ambíguo. Mesmo quando o tipo é claro, ainda pode especificar o tipo se preferir. Portanto, se quiser que a variável contenha 5 como valor inicial, deve digitar:

    var x: Int =  5 // Posso definir o tipo se quiser
    var y =  10      // ou posso omitir o tipo se preferir

[/!] [!java|scala|c]

Como pode ver, as variáveis são tipadas em [!thelang], que significa que elas são de certa forma especializadas: Uma dada variável pode armazenar apenas dados de um tipo; nem pense em guardar números numa variável que é feita para letras! Dizemos que a linguagem [!thelang] é estaticamente tipada.

Outras linguages (como Python) são menos charas e permitem que guarde qualquer tipo de dado em qualquer variável, sem restrições (estas linguagens são ditas dinamicamente tipadas). Parecem mais fáceis à primeira vista, mas este tipo de restrição permite que o compilador perceba mais erros de lógica para você, o que é bom. Num certo sentido, Python é mais fácil de escrever mas os erros surgem com mais frequencia do que em [!thelang].

Aqui estão alguns dos tipos em [!thelang]:

- [!java|c]int[/!][!scala]Int[/!], para inteiros;
- [!java|c]double[/!][!scala]Double[/!], para números com vírgula;
- [!c]int[/!][!java]boolean[/!][!scala]Boolean[/!], para booleanos, que são valores ou [!c]1[/!][!java|scala]true[/!] ou [!c]0[/!][!java|scala]false[/!];
- [!c]char*[/!][!java|scala]String[/!], para cadeias de caracteres.

[/!] [!python]

Como pode ver, as variáveis não são digitadas em Python, o que significa que elas não são especializadas em nenhum tipo de dado. Uma determinada variável armazena qualquer tipo de dado de um determinado tipo: pode armazenar um número numa variável e, mais tarde, armazenar um número na mesma variável. Os valores ainda são digitados, mas não a variável. Diz-se que Python é de tipagem dinâmica.

Outras linguagens (como Java, Scala ou C), são muito mais exigentes e impedem que misture tipos de dados numa certa variável (dizemos que elas são esticamente tipadas). Isto parece inconveniente à primeira vista, mas este tipo de restrição permite que o compilador capture mais erros de lógica para você, o que também é bom. Num certo sentido, Python é mais fácil de escrever mas erros podem surgir mais facilmente.

[/!]

Se sabe que o valor da sua "variável" nunca vai mudar (eg quando ela contém o tamanho do ecrã ou outro valor constante), então deve fazer dela um valor ao invés de uma variável. Simplesmente mude a palavra-chave `var` para `val`. O compilador pode então verificar as suas ações e capturar o seu erro quando inadvertidamente modificar o valor. Mais interessante ainda, o compilador pode produzir código mais rápido em alguns casos.

Variáveis funcionam muito parecido com cadeias, números com vírgula e valores booleanos.

    char* nome = "Martin Quinson";
    double altura=1.77; // em metros
    int casado=1;// 1 significa "verdadeiro"; false é 0

    Cadeia nome = "Martin Quinson";
    double altura=1.77; // em metros
    boolean casado=true;// o contrário se escreve "false"

    val nome:String = "Martin Quinson"; // isto não pode ser modificado (é um valor)
    var altura: Double = 1.77; // em metros
    var casado = true; // o contrário se escreve "false"
    // Scala sabe que 'true' é um valor Booleano, não precisa repetir

    firstName = "Martin"
    lastName = 'Quinson' # aspas e aspas simples funcionam aqui
    frase = "uma gota d'água é sempre melhor que nada" # uma aspas simples entre aspas duplas vale
    altura=1.77 # em metros
    casado=True # o contrário se escreve "False"

### Atribuições

Uma vez que a sua variável está declarada, pode lhe atribuir um novo valor mais tarde no programa. Isto é bem fácil:

    x = 3[!java|c];[/!]

À esquerda do símbolo de igual pode pôr uma expressão aritmética a conter constantes, variáveis e operações.

    x = 3 + 2[!java|c];[/!]
    x = 3 * x[!java|c];[/!]
    [!java|scala|python]saudação = "Oi "+nome[!java];[/!] [!python]#[/!][!scala|java]//[/!] + é (também) a operação para concatenar (ie, para juntar) cadeias[/!]

### Objetivo do exercício

Agora vamos fazer exercícios mais desafiantes, certo? O objetivo agora é mover para a frente até encontrar um baggle, apanhar-lo e mover para trás até a localização inicial antes de sotar o baggle.

### Como fazer isto?

Para resolver este problema, tem que decompor-lo em sub-partes menores. Por exemplo, pode fazer os passos seguintes:

1. Mover para a frente até se pôr sobre um baggle
2. Apanhar o baggle
3. Mover para trás a mesma quantidade de passos que deu no primeiro passo
4. Soltar o baggle de novo

Naturalmente, é impossível dar a quantidade certa de passos para trás no passo 3 se não contou a quantidade de passos dados na primeira fase. Pode usar uma variável para isto, que pode ser chamada `quantidadeDePassos`.

Crie uma variável inteira antes da fase 1, inicie ela com 0 e a cada vez que der um passo para frente, incremente ela de um (`quantidadeDePassos = quantidadeDePassos + 1;`[!java] ou `quantidadeDePassos++;`, ambas as sintaxes são equivalentes[/!]). Tais variáveis que obtèm cada valor de um dado intervalo são normalmente chamadas de stepper.

[!python|scala]

Se conhece Java ou outras linguagens, provavelmente vai tentar usar o operador `++` para incrementar a variável, mas isto não é permitido em [!thelang]. Isto é por que seria difícil definir este operador para todos os tipos de dados. Por exemplo, o que faria ++ quando aplicado a um valor complexo ou a uma cadeia? O problema não ocorre em Java, pois `int` não é um objeto e sim um tipo primitivo. (se não conhece o `++`, simplesmente ignore este parágrafo: fnão existe em [!thelang])

[/!]

Então, a fase 3 consiste em simplesmente criar uma nova variável inteira `passosDados` iniciada como 0 e dar um passos para trás enquanto `passosDados` não for igual a `quantidadeDePassos`, a aumentar `passosDados` a cada vez. O operador `!=` deve ser usado para testar a inequação (quando um valor NÃO É igual).

Agora é a sua vez!