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

VARIÁVEIS


Tudo Sobre Variáveis no Vizzcode





O que são Variáveis e Como Criar Elas?

Uma variável é uma associação de um nome com um pedaço de memória com um tipo seguro.

Você pode encontrar uma introdução mais detalhada sobre variáveis aqui e também nos tutoriais completos se você precisar de uma introdução mais amigável sobre o tópico.

Você pode declarar uma variável dessa forma:

Como declarar uam variável no Vizzcode
var :
int
;
Uma variável é declarada em texto digitando o nome seguido por dois pontos :
Depois, pode vir um tipo explicito ou implícito e depois disso a atribuição.
As diferentes maneiras de declarar variáveis no Vizzcode
var1 :
int
;
var2 :
int
=
5
;
var3 :=
5
;
No Vizzcode, todas as variáveis precisam ter seu tipo definido em tempo de compilação. Isso é conhecido como tipo estático ou fortemente tipificado.
Variáveis podem ser globais ou apenas disponíveis no escopo em que foram declaradas.




Tipos

No Vizzcode, as variáveis podem ser de um desses tipos: No código de texto, você pode especificar os tipos de forma explicita na declaração da variável:
var1 :
int
;
var2 :
float
;
var3 :
string
;
var4 :
bool
;

A mesma coisa pode ser feita no Painel Visual:

Como especificar o tipo de uma variável no Vizzcode
O tipo da variável também pode ser implícito (ou auto, no painel Visual) para que o compilador possa resolver automaticamente o tipo baseado na expressão que a variável está sendo atribuída um valor na declaração.

A seção a seguir explica cada um dos tipos do Vizzcode em detalhe.




Tipos: Inteiros

No Vizzcode, inteiros são números inteiros de 64-bit com sinal, indo de −9,223,372,036,854,775,808 até 9,223,372,036,854,775,807.
(Sim, isso é um monte de números)

Você pode declarar uma variável inteira especificando seu tipo int ou deixando seu tipo implícito e atribuindo para ele um número inteiro:

Como declarar números inteiros no Vizzcode
int_var :
int
;
outro_int :
int
=
10
;
mais_um :=
20
;
Se você declarar uma variável int mas não atribuir nenhum valor para ela, é atribuído por padrão o valor zero.

Você pode usar expressões aritméticas para operar com ints bem como operações de comparação




Tipos: Floats

No Vizzcode, floats são tipos usados para guardar número decimais. Eles são de precisão única com 32-bit de números de ponto flutuante. Você pode pesquisar mais sobre o formato de ponto flutuante de precisão única se você quiser aprender mais sobre isso.
Uma declaração de float pode ser escrita especificando o tipo float ou deixando o tipo implícito e atribuindo para ele um número decimal:

Como declarar números decimais (float) no Vizzcode
float_var :
float
;
outro_float :
float
=
10
;
mais_um :=
10.0
;
O valor de um float é inicializado como zero se você não atribuir um valor explicitamente para ele.

Você pode usar operações aritméticas para operar com floats bem como operações de comparação.




Tipos: Bools

O tipo booleano é um valor de 8-bit que pode guardar tanto o valor falso ou verdadeiro.
O valor falso é representado na memória pelo valor zero, e todo o resto é considerado verdadeiro.

Você pode declarar uma variável booleana especificando o tipo bool ou deixando o tipo implícito e atribuindo a ela tanto um valor literal de verdadeiro ou falso (como o exemplo a seguir), ou uma expressão que resolve para um booleano:

Como declarar variáveis booleanas no Vizzcode
bool_var :
bool
;
outro_bool :
bool
=
true
;
mais_um :=
false
;
Bools são o resultado de operações de comparação que você pode aplicar a outros tipos. Por exemplo, comparar se um int é maior que outro resulta em um bool: tanto verdadeiro ou falso.

Examplo de criar uma variável booleana baseado no resultado de uma comparação
primeiro_int :=
5
;
segundo_int :=
7
;

resultado_comparacao :
bool
= primeiro_int > segundo_int;
Se você declarar uma variável bool mas não atribuir um valor para ela, é atribuído o valor falso como padrão.

Bools podem sofrer operação com o tipo especial de operadores lógicos descritos com detalhe aqui.




Types: Strings

No Vizzcode, o tipo string é usado para guardar e operar com texto. Elas são representadas internamente por ponteiros para inteiros de 8-bit guardando caracteres e um inteiro com sinal de 64-bit contendo o número de caracteres naquela string.
Você pode declarar uma string especificando o tipo da string ou deixando seu tipo implícito e atribuindo para ela uma string (tanto um texto literal - textos literais são especificados entre aspas "" – ou uma expressão que resulta em uma string – como chamar um procedimento)

Como declarar strings (variáveis de texto) no Vizzcode
string_var :
string
;
outra_string :
string
=
"Essa é uma string literal"
;
mais_uma :=
"Mais um texto bacana"
;
O valor de uma string pode ser inicializado como uma cadeia de texto vazia (ou "" ) se você não atribuir algum valor para ela de forma explícita.

Você pode comparar string usando esses operadores.




Tipos Implícitos

Por conveniência, você pode deixar o tipo de uma variável implícito quando tiver declarando variáveis. O compilador vai, em seguida, usar o tipo da expressão atribuída a ela na declaração para determinar o tipo da variável.

Em código de texto, você pode deixar o tipo escondido na declaração:
var1 :
int
=
10
;
var2 : =
10
;
var3 :=
10
;

Pela razão do tipo da variável precisar ser conhecido em tempo de compilação, você não pode declarar uma variável sem tipo e sem expressão.

Tipos implícitos funcionam da mesma forma em declarações compostas. Na verdade, se você tiver recebendo múltiplos valores de retorno de tipos diferentes, você precisa usar tipos implícitos, por conta de você estar criando variáveis de múltiplos tipos diferentes na mesma declaração.
proc1
:: () ->
int
,
int
{}
proc2
:: () ->
int
,
float
{}

main
:: () {
    isso_e_um_int1, isso_e_um_int2 :
int
=
proc1
();
    isso_e_um_int3, isso_e_um_float :
float
=
proc2
();
}

A seção a seguir fala sobre como deixar o tipo implícito no Painel Visual.




O Tipo Auto de Nós

Como falamos na seção anterior, você não precisa especificar o tipo de todas as variáveis na declaração: você pode deixar o computador descobrir o tipo automaticamente baseado no valor da expressão.
Você pode fazer isso simplesmente especificando o tipo para auto no nó de declaração variável:

Como declarar uma variável do tipo 'auto' no Vizzcode
Por conta do compilador precisar de uma expressão para resolver o tipo da variável, você precisa especificar um valor na declaração da variável quando tiver usando o tipo auto.




Arrays

Você pode fazer variáveis guardar valores de um mesmo tipo específico, fazendo essa variável ser um array.
Para fazer isso, você pode simplesmente especificar um tamanho (ou sua contagem) entre colchetes [ ] antes do tipo da variável, dessa forma:

array_de_ints : [
6
]
int
;
dez_strings_de_texto : [
10
]
string
;

Para fazer isso usando nós visuais, tudo que você precisa fazer é selecionar os quadradinhos próximos do tipo da variável:

Como declarar um array no Vizzcode

Os elementos do array podem ser acessados como uma variável normal, usando o operador subscrito. Você pode atribuir valor aos elementos e ler eles normalmente:
main
:: () {
    array_de_ints : [
6
]
int
;
    
    array_de_ints[
0
] =
6
;
    array_de_ints[
1
] = array_de_ints[
0
];
}

É dessa forma que eles funcionam com nós visuais:

Como pegar e atribuir valores de elementos específicos de um array no Vizzcode

Você pode consultar a contagem (ou tamanho) do array usando o operador .count, dessa forma:
#import
"Print"


main
:: () {
    array_de_ints : [
6
]
int
;
    
    
if
array_de_ints.count ==
6
print
(
"True"
);
}

Aqui está o operador .count no painel Visual:

Como usar o operador de arrays '.count' no Vizzcode

Se você criar um array de 5 ints, por exemplo, você pode acessar todos esses cinco inteiros dentro dos limites do array usando o operador subscrito e indexar o array da posição 0 até 4.
Note que o primeiro índice do array sempre vai ser zero, portanto, os arrays possuem índices baseados em zero . Por exemplo, esse código define todos os cinco elementos no array para um número aleatório.
#import
"Random"


main
:: () {
    arr: [
5
]
int
;
    arr[
0
] =
random_int_in_range
(
-10
,
10
);
    arr[
1
] =
random_int_in_range
(
-10
,
10
);
    arr[
2
] =
random_int_in_range
(
-10
,
10
);
    arr[
3
] =
random_int_in_range
(
-10
,
10
);
    arr[
4
] =
random_int_in_range
(
-10
,
10
);
}

Se você tentar acessar um elemento do array fora dos limites do array você arrisca de derrubar (crashar) o programa. Isso é explicado com mais detalhes aqui.

Você pode ver como arrays podem ser usados em programas reais nessa seção dos exercícios de programação.




Arrays: Fora dos Limites

Por conta de um array ser apenas uma variável, seu tamanho é conhecido e especificado em tempo de compilação.
Isso significa que é um pedaço de memória especificado e se você tentar acessar memória for dos seus limites você está acessando outros pedaços de memória.

Por exemplo, se você criar um array de 10 ints, e tentar acessar o índice 10 (note que a última posição válida do array é 9 porque seus índices vão de 0 to 9) você arrisca de acessar memória com dados inválidos ou memória inacessível e derrubar (crashar) o programa.

Tente garantir que seu programa apenas acesse arrays usando índices válidos.




Variáveis Globais

Como conversado na seção dos escopos, você pode criar variáveis dentro de escopos locais (e apenas acessar ela dentro daquele escopo e seus sub-escopos) ou no escopo global.
Se você criar uma variável no escopo global (ou uma variável global), você pode acessar ela em qualquer lugar do programa, independente da localização da sua declaração.
Por exemplo:
variavel_global :=
5
;

main
:: () {
    variavel_local := variavel_global;
}

Isso pode ser bem útil e conveniente para que você não precise passar os valores como parâmetros se vários procedimentos precisarem de acessar aquele valor.
Entretanto, por conta de identificadores de nomes poderem colidir, você precisa tomar cuidar para não criar muitas variáveis globais e poluir o escopo global (impedindo que variáveis locais sejam criadas com esses nomes).




Inicialização Padrão

Como foi dada a dica anteriormente nessa página, quando você cria uma variável e não atribui nenhum valor para ela, é automaticamente atribuído o valor padrão: zero no caso de ints e floats, falso nos booleanos e texto vazio nas strings.
#import
"Print"


main
:: () {
    int_var :
int
;
    
if
int_var ==
0
  
print
(
"true"
);

    float_var :
float
;
    
if
float_var ==
0.0
  
print
(
"true"
);

    bool_var :
bool
;
    
if
bool_var ==
false
  
print
(
"true"
);

    string_var :
int
;
    
if
string_var ==
""
  
print
(
"true"
);
}