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

[/!] [!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!