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

DECLARAÇÕES


Tudo Sobre Declarações no Vizzcode





O que são Declarações?

Declarações são um recurso de linguagem no Vizzcode. Elas possibilitam que nomes sejam associados com identificadores e depois sejam referenciados no programa.

Por exemplo: você pode declarar um procedimento e depois referenciar esse procedimento usando seu nome (como se tivesse chamando ele):

Como fazer uma declaração no Vizzcode

proc
:: () {

}
Declaracao de um procedimento chamado "proc"


Como chamar procedimentos no Vizzcode

...
proc
();
Chamando o procedimento pelo seu nome




Tipos de Declarações

Existem alguns tipos de declarações dentro do Vizzcode.
Conhecer esses tipos vai te proporcionar a expressar suas ideias e soluções de uma forma melhor enquanto tiver programando.

Esses são os tipos de declarações:

Declarações de Variáveis

Uma declaração de variável é a associação do nome com um pedaço de memória de fortemente tipificado.
Em texto, declarações de variáveis contém um nome e depois pontos :
Com nós visuais, as declarações de variáveis são os nós verdes.
Por exemplo, você pode declarer uma variável do tipo inteiro chamada var dessa forma:

Como declarar uma variável no Vizzcode
var :
int
;


No Vizzcode, todas as variáveis precisam ter seu tipo conhecido no tempo de compilação. Isso significa que o compilador precisa saber o tipo de todas as variáveis na declaração. Isso é chamado de fortemente tipificado ou tipo estático.
Você também pode atribuir um valor para a variável na declaração, dessa forma:

Como declarar uma variável e atribuir um valor a ela
var :
int
=
7
;

Se você está atribuindo uma valor para uma variável, você pode deixar o tipo implícito e o compilador vai automaticamente definir seu tipo baseado no tipo do valor que você está atribuindo para ela.
O código a seguir declara a variável do tipo int e valor 7.

Como declarar uma variável com o tipo implícito no Vizzcode
var :=
7
;


Variáveis podem ser declaradas no escopo global ou um escopo local.

Você pode aprender tudo sobre variáveis aqui.


Declarações de Procedimentos

Procedimentos são pedaços de código que você pode chamar pelo nome. Ao chamar um procedimento, você começa a executar as instruções dentro do procedimento.
Aqui está um exemplo de um procedimento chamado proc:

Como declarar um procedimento no Vizzcode

proc
:: () {

}
E a mesma coisa em nós Visuais:

Esse procedimento também pode ser chamado dentro de outro procedimento, dessa forma:


Como chamar um procedimento no Vizzcode

outro_proc
:: () {
    
proc
();
}

Você pode passar múltiplos parâmetros bem como receber múltiplos valores de retornos quando chamando um procedimento:

Declarando e chamando procedimentos com parâmetros e retornos

proc
:: (a :
int
, b :=
5.6
) ->
int
,
float
{

}

outro_proc
:: () {
    
proc
(
0
);
}

Procedimentos devem ser declarados dentro do escopo global e chamados dentro de escopos locais.

Você pode acessar a página da documentação completa de procedimentos aqui.


Declaração com Hash: Importando Bibliotecas

Declarações com Hash são um tipo especial de declaração que você faz usando o símbolo # no código de texto.
Você pode fazer declarações com hash especificando que você gostaria de importar as declarações de uma biblioteca já feita.

Por exemplo, ao importar a biblioteca Print você pode acessar seus procedimentos declarados (print, print_int, print_float e print_bool):
Como usar Declarações com Hash para importar uma biblioteca no Vizzcode

#import
"Print"

Como usar Declarações com Hash em programas reais

#import
"Print"


main
:: () {
    
print
();
}

Bibliotecas precisam ser incluídas no escopo global.

Você aprender tudo sobre as bibliotecas que estão disponíveis no Vizzcode aqui.




Declarações de Nós

É muito fácil criar declarações no Painel Visual. Você pode arrastar a partir do pino de execução de outro nó e inserir tanto uma Variável, Procedimento ou declarações de Bibliotecas Importas.

Todas as declarações precisam ser devidamente nomeados, assim:

Diagrama mostrando o nome das declarações
(Você pode aprender sobre como nomear identificadores aqui).




Declarações com Hash

Declarações com Hash são um tipo especial de declaração feitas no escopo global.
They always contain a # in the beginning of the declaration in the text code.

Você pode usar Declarações com Hash de Importar Bibliotecas para importar bibliotecas já feitas no seu programa. Como essa:

Como usar Declarações com Hash para importar uma biblioteca no Vizzcode

#import
"Print"




Nomeando Declarações

Todos os nomes de declarações precisam seguir a seguinte regra:
Um nome precisa contem apenas as letras A-Z e a-z, os números 0-9 e linha sublinhada _
Um nome não pode começar com números.

Um nome não pode ser o mesmo que palavras chaves pré-definidas na linguagem:
  • true
  • false
  • if
  • else
  • while
  • for
  • break
  • continue
  • return
Um nome não pode ser o mesmo que um tipo. Esses são os tipos padrões da linguagem:
  • void
  • int
  • float
  • string
  • bool
Por exemplo, essas são declarações de nomes válidas:
  • var
  • essa_variavel
  • minhaVariavel
  • TUDOMAIUSCULO
  • __muito_importante
  • var5
Essas são declarações de nomes inválidas:
  • 4var (começa com um número)
  • A Variável(contém um 'espaço')
  • variável (contém um caractere que não seja A-Z e a-z: á – não pode ter acentos na declaração de variáveis)
  • break (uma palavra chave reservada)
  • string (é um tipo)
Mesmo você podendo usar qualquer convenção de declaração de nomes que você quiser, costuma ser uma boa estratégia ser consistente na nomeação (pelo menos entre os mesmos tipos de declaração).
Algumas das convenções de nomes mais utilizadas são: caso_cobra, CasoComLetraMaiuscula e casoComLetraMinuscula. Escolha a que você achar mais legível.




Redefinição

Quando você faz uma declaração, ela existe enquanto seu escopo existir.

Com isso em mente, se você nomear uma declaração da mesma forma que outra declaração válida (acessível a partir daquele lugar no código) for nomeada, terá um erro de redefinição de identificador porque o compilador não vai saber a qual declaração você está referindo com esse nome.

Os seguintes exemplos são inválidos porque eles redefinem um identificador válido:
main
:: () {
    var :=
4
;
    var :=
6
;
}
var :=
4
;
main
:: () {
    var :=
6
;
}
main
:: () {
    var :=
4
;
    
if
true
 var :=
6
;
}


Os seguintes exemplos são válidos porque eles não usam um nome que já está sendo usado no escopo:

main
:: () {
    var :=
4
;
    var2 :=
6
;
}
var :=
4
;
main
:: () {
    var1 :=
6
;
}
main
:: () {
    
if
true
 var :=
6
;
    var :=
4
;
}

Você pode ler mais sobre escopos na seção seguinte.




Escopos

Um escopo é um bloco de declarações e construtores.
Eles costumam ser definidos por { } em código texto.
A seguinte seção fala sobre escopos de nós.

Todas as declarações criadas dentro de um certo escopo podem ser acessadas dentro desses mesmo escopo (e seus sub-escopos).

O escopo global cobre o programa inteiro. Todas as declarações feitas diretamente dentro do escopo global são acessíveis em qualquer lugar do programa. A ordem das declarações dentro do escopo global não importa.
Considere o seguinte programa:
main
:: () {

}

variavel_global :=
23
;
outra_variavel:
string
=
"Ola!"
;

proc
:: () {

}
Todas os identificadores declarados dentro do escopo global (variavel_global , main, outra_variavel e proc) estão disponíveis em todos os lugares no programa. Isso acontece porque declarações no escopo global são independentes da ordem.
Esse programa é válido independente de usar o identificador antes de serem declarados:
main
:: () {
    
proc
();
    a := outra_variavel;
    b :=
5
+ variavel_global;
}

variavel_global:=
23
;
outra_variavel :
string
=
"Ola!"
;

proc
:: () {
    variavel_global +=
4
;
    outra_variavel =
"Mudada!"
;
}
Escopos Locais são escopos definidos dentro de outros escopos.
Por exemplo, quando você declara um procedimento, seu bloco é um escopo local. Se você criar mais blocos dentro dele, eles vão ser escopos locais próprios.

No código abaixo, existem três escopos: o escopo global, o o bloco do escopo do procedimento main e o escopo do if.
main
:: () {
    var1 :=
3
;
    
if
true
{
        var2 := var1;
    }
}

O procedimento main é declarado no escopo global, então ele está disponível nesse escopo (e em todos os seus sub-escopos), ou seja, em qualquer lugar do programa.
A variável var1 é declarada no escopo do main, então ela só está disponível nesse escopo (e em todos os seus sub-escopos).
A variável var2 é declarada no escopo do bloco do if, então ela só está disponível nesse escopo (e em todos os seus sub-escopos).

O código abaixo contém um erro, você consegue identificar esse erro?
main
:: () {
    var1 :=
3
;
    
if
true
{
        var2 := var1;
    }
    var1 = var2;
}

O erro é que a var2 não é aceita fora do escopo que foi criada. Então você não pode atribuir seu valor para var1 depois de ter saído do escopo do bloco do if.

Quando você cria um bloco e adiciona apenas um construtor ou declaração dentro dele, você não precisa colocar esse construtor ou declaração dentro de { }.
Por exemplo:
main
:: () {
    
if
true

        var1 :=
5
;
    var2 :=
6
;
}
A variável var1 é criada dentro do escopo do bloco do if (e portanto só vai ser executado se a condição for true) e var2 é criada dentro do escopo do main (e portanto vai ser executado independente da condição).
Isso é porque o bloco do if não continha o símbolo {, sinalizando que a próxima declaração ou construtor pertence aquele escopo.
Isso é o exatamente o equivalente de escrever:
main
:: () {
    
if
true
{
        var1 :=
5
;
    }
    var2 :=
6
;
}
Notas adicionais:




Escopos de Nós

Escopos no Painel Visual funcionam da mesma forma que escopos normais.
É dessa forma que o escopo global é representado no painel Visual: (Você pode apenas seguir a linha branca a partir do seu começo no nó do Início do Escopo Global)

Como que é o Escopo Global no Vizzcode

Escopos locais são linhas brancas que começam a direita de certos nós e andam para baixo:

Como que são os Escopos Locais no Vizzcode

As mesmas regras dos escopos em texto se aplicam: independente da ordem no escopo global, variáveis sendo acessíveis apenas dentro do escopo que foram criadas (e seus sub-escopos) e assim por diante.

No exemplo abaixo, existem três escopos: o escopo global, o escopo do bloco do procedimento main e o escopo de caso verdadeiro do if.

Um programa exemplificando os diferentes escopos no Código Visual

O procedimento main é declarado no escopo global, então ele está disponível dentro desse escopo (e em todos os seus sub-escopos), portanto em qualquer lugar do programa.
A variável var1 é declarada no escopo do main, então ela está disponível dentro desse escopo (e em todos os seus sub-escopos).
A variável var2 é declarada dentro do escopo do bloco do if, então ela só está disponível dentro desse escopo (e em todos os seus sub-escopos).

O código abaixo contém um erro, você consegue identificar esse erro?

Um programa contendo um erro causdo pelo uso errado do escopo de uma variável

O erro é que a var2 não é acessível fora do escopo que foi criada. Então você não pode atribuir seu valor para var1 depois de ter saído do escopo do bloco do if.





Declarações Compostas

Você pode declarar (e atribuir) várias variáveis de uma vez dessa forma:

Como usar Declarações Compostas no Vizzcode
var1, var2, var3 :=
10
;

Esse exemplo declara três variáveis independentes var1, var2 e var3; e atribuir o valor 10 para todas elas.

Declarações compostas são especialmente úteis quando está lidando com procedimentos que possuem múltiplos valores retornados.
No exemplo a seguir, o procedimento proc retorna três valores (um int, uma string e um float):

Um procedimento que retorna vários valores
proc
:: () ->
int
,
string
,
float
{
    
return
10
,
"Hello!"
,
3.14
;
}


Você pode chamar um procedimento ignorando seus valores retornados:

Chamando um procedimento e ignorando os valores retornados
proc
();


Ou você também pode declarar variáveis e atribuir a elas os valores retornados:

Chamando um procedimento e usando o primeiro valor retornado com uma declaração normal
var1 :=
proc
();



Chamando um procedimento e usando os dois primeiros valores retornados com uma Declaração Composta
var1, var2 :=
proc
();



Chamando um procedimento e usando todos os valores retornados om uma Declaração Composta
var1, var2, var3 :=
proc
();


Nesses exemplos, var1 é um int, var2 é uma string e var3 um float.
Por conta de você estar criando variáveis de tipos diferentes na mesma declaração composta, você precisa deixar seus tipos implícitos.




Declarações Deletadas em Nós

Alguns nós se referem a um declaração.
Por exemplo, nesse código, o nó var faz referência a declaração da variável var:

Um exemplo de um nó que depende de outro

Se você deletar a declaração, você torna inválido o nó da variável e ele também precisará ser deletado.

Um programa com um nó que tem uma dependência inválida

A mesma coisa acontece se você deletar uma biblioteca importada. Ao fazer isso, você invalida todas as chamadas aos procedimentos declarados naquela biblioteca:

Um programa com um nó que tem uma dependência inválida por causa de um bilioteca