Introdução Bem-vindo Como Começar Meu Primeiro Programa     Resolvendo Problemas e Distribuindo Tranformando Dados Programas Interativos     Exercícios de Programação     Fazendo Games
Documentação Declarações     Procedimentos     Variáveis Construtores     Controle de Fluxo Expressões Bibliotecas     Print     IO     Random     Game Engine
Tutoriais Tutoriais Completos     Introdução à Programação     Guia Rápido     Exercícios de Programação     Programando Games

TRANSFORMANDO DADOS


Armazenando e operando com dados





Como Computadores Guardam Dados

Nós já vimos que computadores são máquinas que guardam e operam com dados conforme instruído por nós – as pessoas que estão programando. Nós instruímos o computador para mostrar uma mensagem na tela e agora queremos fazer um programa mais elaborado, um que lida com dados: recebendo dados (input), processando e retornando (output) os dados.
Então vamos aprender como os computadores guardam os dados!

Computadores lidam com dados de forma binária - ou bits: um único valor que pode ser ligado ou desligado, verdadeiro ou falso, 1 ou 0. Como você pode imaginar, não é possível guardar coisas muito interessantes dentro de um único bit, mas quando computadores começam a combinar esses bits mais coisas se tornam possíveis. Quando 8 bits são combinados, nós temos um byte.Um byte é suficiente para guardar 256 estados diferentes, então ele pode ser usado para guardar números pequenos, por exemplo.
Aqui você pode ver como é transformar o formato binário que o computador entende para o formato decimal que nós usamos.
000000000     0
000000001     1
000000010     2
000000011     3
000000100     4
000000101     5
000000110     6
000000111     7
000001000     8
...

É dessa forma que os computadores entendem os números! (se você não estiver entendendo muito bem, não se preocupe, teremos outras oportunidades para entender cada bit da programação!)

Você provavelmente já ouviu falar de um KB (kilobyte) ou MB (megabyte) ou GB (gigabyte) e assim por diante. Isso simplesmente significa que um certo número de bytes: por exemplo, 1 KB é 1024 Bytes; 1 MB é 1024 KB (ou 1,048,576 bytes). Os computadores de hoje em dia possuem tanta memória que é possível guardar uma infinidade de coisas como imagens, vídeos, jogos, documentos, e assim por diante. Tudo isso está disponível para todas as pessoas que programam!

Imagine a memória do computador – todos os bits que ela tem disponível – como uma ENORME fileira de armários.
Muito parecido com aqueles que você encontra numa biblioteca ou no vestiário de uma academia.

A memória do computador é uma fileira de armários

Nós podemos designar armários para guardar certos valores e referir a esses pedaços de memória usando um nome arbitrário.

Os armários podem ser referidos por nomes e contém um valor

Lembra anteriormente quando eu dei um exemplo de instruções necessárias para ler e somar dois números. Deixa eu refrescar sua memória:
ler_número
   lugar1
ler_número
   lugar2
somar_números
   lugar1, lugar2, lugar3
escrever_número
  lugar3

Agora sabemos de onde lugar1, lugar2 e lugar3 vêm: eles são identificadores de pedaços de memória que estão guardando números.
Esses identificadores também podem ser chamados de variáveis.
Então, uma variável é simplesmente um pedaço de memória (que guarda dados) que nós referimos por um nome.
Dessa forma, nós podemos declarar essas variáveis para fazer o computador saber que vamos usar a memória dele.




Declarando e Atribuindo Variáveis

Se nós queremos operar em dados, nós temos que pedir para o computador por um armário para guardar os dados dentro.
Esse processo é chamado de declarar uma variável.

Vamos criar um projeto em branco e adicionar o ponto de entrada.
Para declarer uma variável, simplesmente arraste do pino Executar e crie um nó de Nova Variável.

Como declarar uma variável no Vizzcode

Esse nó reserva um pedaço de memória (ou armário, segundo nossa analogia) que podemos usar para guardar dados e operar com ele.
Além de reservar, esse nó também está atribuindo um valor para a variável (ou colocando algumas coisas dentro do armário). Nesse caso, o número zero.
A variável veio com o nome padrão var, mas podemos mudar ele para qualquer nome que quisermos, simplesmente dando dois cliques no nome e escrevendo um novo nome.
Note que o nome dos identificadores (variáveis) podem conter somente letrar (A-Z, a-z), número (0-9) ou linha sublinhada “_” mas não pode começar com números.
Você pode aprender mais sobre identificadores aqui.

Assim como no mundo real, onde os armários podem possuir tamanhos diferentes, você pode guardar dados com tamanhos diferentes nas variáveis. Por conta disso, o compilador precisa de saber o tipo de dado que está sendo guardado dentro da variável.
Você pode aprender sobre tipos em detalhe aqui.

Por conta do valor 0 ter sido atribuído para a variável e o tipo da variável ter sido colocado como auto o compilador atribuiu automaticamente o tipo correto de inteiro (ou int) para a variável. Você também pode colocar o tipo manualmente para inteiro.





Imprimindo Variáveis

Agora vamos começar a fazer uma coisa interessante com essa variável.
Você já sabe como imprimir uma mensagem na tela, certo? Então vá em frente e importe a biblioteca "Print" como fizemos anteriormente, mas dessa vez, em vez de chamar o print, tente chamar o print_int, desse jeito:
Imprimindo inteiros no Vizzcode

O chamado para print_int está esperando um valor para imprimir. Podemos tanto escrever o nome da variável ou arrastar o pino de conexão e criar um nó com o nome da nossa variável.

Imprimindo variáveis no Vizzcode Imprimindo variáveis no Vizzcode conectando nós


Dessa forma, estamos pedindo para o computador mostrar na tela o valor da variável (ou o conteúdo do armário, se você ainda estiver seguindo essa analogia...).

ANTES DE RODAR O PROGRAMA... Deixa eu te fazer uma pergunta: qual valor você espera que o computador imprima e porque?
Pense nisso: “execute” as instruções na sua cabeça (ou pedaço de papel, onde você pode escrever o valor da variável em cada momento) e me diga.
Hm… boa resposta. Vamos compilar e executar para ver o que o programa escreve.
0
**** Fim do programa. Aperte qualquer tecla para sair ****

Zero!
Quando declaramos a variável, o valor 0 foi atribuído para ela. Tente mudar o valor e compilar e rodar o programa novamente.

Uma nota: Se você tentar imprimir mais que uma vez, você vai notar que os valores estão imprimindo lado a lado o que pode ser bastante confuso. Tente adicionar mais um print_int no seu programa para que você possa observar esse comportamento.
Se você quiser adicionar uma quebra de linha, simplesmente adicione um print e peça para ele imprimir um "\n". Dessa forma:

Usando \n para quebrar linhas

Isso vai imprimir a primeira vez, adicionar uma nova linha e imprimir de novo.
Os caracteres \n representam uma nova linha no código e o prompt de comando vai quebrar a linha sempre quando ver um.




Atribuindo Variáveis

Agora as possibilidades estão emergindo!
Podemos mudar o valor de uma variável depois de ver ele?
Sim! Você pode criar um nó de atribuição. Ele pega a variável que você quer atribuir para e o valor que que você quer atribuir para a variável

Como atribuir um valor a uma variável no Vizzcode

O que acontece agora quando você tenta imprimir a variável antes e depois da atribuição?
Lembre-se que você pode esperar que as instruções executem uma de cada vez e em ordem, para que então você saiba o resultado simplesmente lendo os nós você mesmo.

Você consegue me dizer o que esse programa vai imprimir?
#import
"Print"


main
:: () {
    var :=
1
;
    
print_int
(var);
    
print
(
"\n"
);
    var =
2
;
    
print_int
(var);
    
print
(
"\n"
);
    
print_int
(var);
    
print
(
"\n"
);
    var =
3
;
    var =
4
;
    
print_int
(var);
    
print
(
"\n"
);
}

Se você estiver tendo dificultado ou quiser conferir, apenas copie e cole esse código dentro do painel de Texto no Vizzcode. Lembre-se que você pode programar tanto escrevendo texto ou conectando nós ao mesmo tempo!

E esse aqui? (É disso que eu estou falando!)
#import
"Print"


main
:: () {
    var1 :=
43
;
    
print_int
(var1);
    
print
(
"\n"
);
    var2 :=
21
;
    
print_int
(var2);
    
print
(
"\n"
);
    var1 = var2;
    
print_int
(var1);
    
print
(
"\n"
);
    var2 =
1
;
    
print_int
(var1);
    
print
(
"\n"
);
    
print_int
(var2);
    
print
(
"\n"
);
}





Operando com Dados

Por fim, mas, com certeza, não menos importante, podemos operar com dados.
Os tipos mais básicos de operação que podemos fazer são arithmetic expressions:
main
:: () {
    adicao :=
123
+
456
;
    subtracao :=
123
-
456
;
    multiplicacao :=
123
*
456
;
    divisao :=
123
/
456
;
    modulo :=
123
%
456
;
}

No painel Visual, você pode tanto escrever a expressão dentro da caixa de texto ou arrastar do pino e criar um nó de operação.

Operando em dados no Vizzcode Operando em dados com nós no Vizzcode


Da mesma forma que números literais (números como 123 ou 456 escritos diretamente no código), variáveis também podem sofrer operações:

main
:: () {
    primeiro :=
10
-
6
;
    segundo := primeiro +
9
-
2
;
    primeiro = segundo*segundo;
    primeiro = segundo*primeiro;
    segundo = segundo+1;
}
Operando em variáveis


Assim como em matemática, operadores possuem precedência e você pode usar parênteses para mudar isso.

main
:: () {
    a :=
10
;
    b :=
6
;
    um_resultado := a - b *
100
;
    outro_resultado := (a - b) *
100
;
}
Operando em variáveis



Note como a ordem da operação no painel Visual é espelhado pelo uso do parêntesis do painel de Texto. Tente mudar de um e depois de outro para ver como atualizam.

Fique mais um tempo brincando com os operadores e imprimindo os resultados. Certifique-se que você esteja entendendo porque o computador está mostrando cada valor e tente saber antes de executar o programa qual resultado vai ser!




Uma Nota Sobre Execução de Nós

Agora que você está usando vários operadores, pode começar a se confundir um pouco sobre a ordem de execução dos nós.
Uma conversa complete sobre escopos (e o que são... :P ) está disponível aqui mas a ideia mais importante é que a conexão branca (ou conexão de execução) é o que dita a ordem de execução das instruções. Então, seguindo elas sabemos as ações principais (ou construções) de um programa.

A partir desse ponto, as conexões de expressões são executadas começando do nó main, dessa forma:

Entendendo o fluxo de execução no Vizzcode

Note que cada nó precisa estar conectado com outro (para que todos conectem de alguma forma com o Início do Escopo Global).
Uma vez que você começar a acostumar com isso, vai perceber que vai se tornar totalmente natural. ;)
Por isso é importante criar (e entender) vários programas. O hábito de tentar descobrir qual vai ser o output (ou saída) do programa antes de executar vai fortalecer seus músculos da programação, porque o programa inteiro vai estar executando na sua cabeça: pegar os bugs antes deles acontecerem!

Agora que você processou e fez a saída dos dados, está na hora da última parte do quebra-cabeça do Entrada -> Processamento -> Saída: fazendo um programa interativo.