## Armazenando e manipulando 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 programas, você pode usar vários tipos de dados, tais como números inteiros ou cadeias de caracteres ou caracteres. Se você quiser usar um dado várias vezes, você precisa armazenar ele numa variável, que é uma célula de memória contendo um valor: você bota seu dado (digamos o valor '5') na variável (digamos 'comprimento'), e você pode recuperá-la mais tarde quando precisar dela. Isto é muito similar a uma caixa com o rótulo 'presente' na qual você pode colocar alguma coisa, como um perfume "Channel N°5".

### Declaração de variáveis

Declarar (ie, criar) uma variável em [!thelang], é muito simples. Você simplesmente escreve [!java]seu tipo, 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. Você pode nomear uma variável `quantidadeDePassos` se você 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, você deve escrever:

    int x;

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

    int x=5;

[/!] [!python]

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

    x = 5

[/!] [!scala]

Logo, para criar uma variável chamada x que vai guardar inteiros e com 42 como valor inicial, você 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 você pode omitir o tipo:

    var x = 42

Você ainda tem que especificar se você 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, você ainda pode especificar o tipo se preferir. Portanto, se você quiser que a variável contenha 5 como valor inicial, você deve digitar:

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

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

Como você 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 em uma variável que é feita para letras! Dizemos que a linguagem [!thelang] é estaticamente tipada.

Outras linguages (como Python) são menos charas e permitem que você 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]

As you can see, the variables are not typed in Python, which means that they are not specialized in any type of data. A given variable store any type of data of a given type: you can store a number in a variable and later on store a number in the same variable. The values themselves are still typed, but not the variable. Python is said to be dynamically typed.

Outras linguagens (como Java, Scala ou C), são muito mais exigentes e impedem que você 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 você sabe que o valor de sua "variável" nunca vai mudar (eg quando ela contém o tamanho da tela ou outro valor constante), então você 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 suas ações e capturar seu erro quando você 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 strings, números com vírgula e valores booleanos.

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

    String 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 sua variável está declarada, você pode atribuir um novo valor para ela mais tarde no programa. Isto é bem fácil:

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

À esquerda do símbolo de igual você pode colocar uma expressão aritmética contendo 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) strings[/!]

### Objetivo do exercício

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

### Como fazer isto?

Para resolver este problema, você tem que docompor ele em sub-partes menores. Por exemplo, você pode querer fazer os passos seguintes:

1. Mover para a frente até se colocar sobre um baggle
2. Pegar 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 você não contou a quantidade de passos dados na primeira fase. Você 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 pegam cada valor de um dado intervalo são normalmente chamadas de stepper.

[!python|scala]

Se você conhece Java ou outras linguagens, você 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 String? O problema não ocorre em Java pois `int` não é um objeto e sim um tipo primitivo. (se você não conhece o `++`, simplesmente ignore este parágrafo: ele nã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`, aumentando `passosDados` a cada vez. O operador `!=` deve ser usado para testar a inequação (quando um valor NÃO É igual).

É sua vez agora!