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

PROCEDIMENTOS


Tudo sobre procedimentos no Vizzcode





O que são Procedimentos e Como Criar Eles?

Procedimentos (também conhecidos como sub-rotinas, funções ou métodos em outras linguagens de programação) são um pedaço de código que é referido por nome.
Eles são muito úteis para reutilizar pedaços de código, porque você executar todos os comandos dentro do procedimento, simplesmente chamando seu nome.
Procedimentos podem receber valores de quem o chamou e dar valores para eles também.

Esse é um exemplo de criar um procedimento chamado proc:

Declarando um procedimento no Vizzcode
proc
:: () {

}
Procedimentos são declarados escrevendo seu nome e depois colocando dois ‘dois pontos’ ::
Você pode colocar os parâmetros dentro de parênteses () e os valores retornados depois de uma opcional ->
Depois disso vem o bloco a ser executado.

É dessa forma que um procedimento é chamado (e suas instruções executadas):
Chamando um procedimento no Vizzcode
...
proc
();
É tão simples quanto escrever o nome do procedimento e os parâmetros opcionais dentro de ().

Note que um procedimento só pode ser declarado dentro do escopo global e só pode ser chamado em escopos locais. Aprenda mais sobre escopos aqui.

O ponto de entrada do programa (o código que é automaticamente executado no início do programa) é um procedimento chamado main. Você pode aprender mais sobre o ponto de entrada aqui.




Porque Usar Procedimentos

A medida que você cria um programa, você pode perceber alguns códigos começam a repetir múltiplas vezes, algumas vezes com pouco modificação ou até mesmo nenhuma modificação.
Além de precisar de escrever (ou copiar) a mesma coisa várias vezes, você está fazendo o programa ficar maior e mais difícil de entender; você também pode ter a necessidade de mudar aquela funcionalidade. Se você precisar de mudar essa funcionalidade, você vai precisar de lembrar de todos os lugares onde esse código foi duplicado e mudar todos eles. Como você pode imaginar, isso pode ser muitopropenso ao erro .
Procedimentos também podem ser usados para se chamarem de forma recursiva se tornando uma ferramenta bem útil para resolver alguns tipos de problemas.

Nesse exemplo, um procedimento é chamado para calcular o fatorial de um número. Esse procedimento é chamado de vários lugares diferentes no programa que não precisam se preocupar em como o fatorial é calculado – porque ele foi abstraído dentro do procedimento.

#import
"IO"


fatorial
:: (valor :
int
) ->
int
{
    resultado :=
1
;
    
for
2
..var resultado *= it;
    
return
resultado;
}

main
:: () {
    
print_int
(
fatorial
(
12
));
    
print_int
(
fatorial
(
5
));
    
print_int
(
fatorial
(
scan_int
(
"Digite um numero para ter seu fatorial calculado "
)));
}




Parâmetros

Parâmetros são valores fornecidos ao procedimento por quem o chamou.
Eles funcionam essencialmente como uma variável sendo declarada no início do seu escopo e recebendo o valor de quem o chamou.

Eles são especificados dentro dos parêntesis () na declaração do procedimento ou (no Pinel Visual) especificados como declaração de variáveis a partir do pino de Parâmetros no Nó de Declaração de Procedimento.

Por exemplo, nesse código, o procedimento ”mostrar” recebe um int como parâmetro.

Um programa que usa procedimentos para simplificar o código
#import
"Print"


mostrar
:: (numero :
int
) {
    
print
(
"O numero e: "
);
    
print_int
(numero);
    
print
(
"\n"
);
}

main
:: () {
    
mostrar
(
-10
);
    
mostrar
(
-5
);
    
for
0
..
10
  
mostrar
(it);
    
mostrar
(
1000
);
}


A saída do programa é a seguinte:
O numero e: -10
O numero e: -5
O numero e: 0
O numero e: 1
O numero e: 2
O numero e: 3
O numero e: 4
O numero e: 5
O numero e: 6
O numero e: 7
O numero e: 8
O numero e: 9
O numero e: 10
O numero e: 1000

Você pode específicar quantos parâmetros precisar:

Como especificar vários parâmetros no Vizzcode
proc
:: (a :
int
, b :
int
, c :
string
, d :
bool
) {

}

Parâmetros podem ter valores padrões ao simplesmente especificar valores na declaração do parâmetro.
Se o parâmetro tiver um valor padrão, que o chamou pode escolher ignorar ele: se quem o chamou não fornecer um valor, o padrão ‘um’ é usado.
Isso pode ser combinado com parâmetros sem valores padrões.

Como usar parâmetros com valores padrão no Vizzcode
proc
:: (a :
int
, b := 123, c :
string
= "Ola") {

}

main
:: () {
    
proc
(
3
,
5
,
"Tchau"
);
    
proc
(
1
,
7
);
    
proc
(
0
);
}

Pela razão de parâmetros possuírem nomes, eles podem ser usados por quem o chamou para mudar a ordem ou simplesmente deixar mais claro quais valores estão sendo passados para cada argumento.
proc
:: (a :
int
, b := 123, c :
string
= "Ola") {

}

main
:: () {
    
proc
(a =
3
, b =
5
, c =
"Tchau"
);
    
proc
(b =
10
, a =
9
, c =
"Tchau"
);
    
proc
(c =
"Teste"
, a =
7
);
    
proc
(a =
0
);
}





Retornos

Valores retornados são valores devolvidos pelo procedimento para quem o chamou.
Eles são especificados depois dos parâmetros na declaração do procedimento, seguidos por um ->
No Painel Visual, eles são especificados como declaração de variáveis conectado ao pino de Retornos de um procedimento.

Um programa que mostra parâmetros e retornos
#import
"IO"


soma
:: (a :=
0
, b :=
0
) ->
int
{
    
return
a + b;
}

main
:: () {
    
print_int
(
soma
(
5
,
6
));
    
print_int
(
soma
(
1
,
1
));
    
print_int
(
soma
(
100
,
scan_int
(
"Digite um numero para ser somado com 100: "
)));
}

Assim como com parâmetros, você pode retornar quantos valores precisar:

Como retornar vários valores no Vizzcode
multiplicar_e_somar
:: (a :=
0
, b :=
0
) ->
int
,
int
{
    
return
a*b, a+b;
}

main
:: () {
    
multiplicar_e_somar
(
10
,
20
);
    mul1 :=
multiplicar_e_somar
(
5
,
10
);
    mul2, add2 :=
multiplicar_e_somar
(
2
,
5
);
}
Para recuperar mais que um valor, quem chamou o procedimento precisa usar a declaração composta. Você pode aprender sobre isso aqui.

Você também pode nomear os valores retornados e referenciar eles no construtor de retorno.

Como nomear valores de returno no Vizzcode
a
:: () -> (a :
int
, b :
float
) {
    
return
b =
5.6
, a =
4
;
}

Você também pode especificar um valor padrão de retorno que vai ser usado sempre quando você retornar da função sem especificar esse valor:

Como especificar valores de retorno padrão no Vizzcode
proc
:: () -> (a :
int
=
4
, b :
float
) {
    
return
b =
5.6
;
}

Procedimentos que não retornam nenhum valor, podem deixar a parte da declaração de retorno em branco ou especificar um retorno void (no Painel de Texto):
proc
:: () {

}

proc
:: () ->
void
{

}





Procedimentos Recursivos

Procedimentos Recursivos são procedimentos que chamam eles mesmos dentro do seu próprio escopo.
Eles podem ser bem úteis para resolver alguns problemas.
Por exemplo, você pode calcular um fatorial usando loops dessa forma:
fatorial
:: (value :
int
) ->
int
{
    resultado :=
1
;
    
for
2
..var resultado *= it;
    
return
resultado;
}

O mesmo algoritmo pode ser implementado usando recursão:
fatorial
:: (valor :
int
) ->
int
{
    
if
n <=
1
return
1
;
    
return
valor *
fatorial
(valor-
1
);
}

Note como o procedimento possui um caso que não entra em recursão. Isso garante que o procedimento não vai entrar em loop infinitamente.