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.
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".
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.
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]:
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"
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[/!]
Para resolver este problema, tem que decompor-lo em sub-partes menores. Por exemplo, pode fazer os passos seguintes:
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.
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!