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