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

EXPRESSÕES


Tudo sobre Expressões no Vizzcode





Sobre Expressões

Uma expressão é uma combinação de uma ou mais operações e valores que resulta em um único valor.

Por exemplo, o número 1 no código seguinte é uma expressão literal de inteiro:
main
:: () {
    var :=
1
;
}

O que é uma Expressão

Você pode combinar diversas expressões para criar um único valor.
O exemplo a seguir contém uma operação aritmética de soma da expressão literal inteira de valor 10 e uma expressão de chamada de procedimento.
main
:: () {
    var :=
10
+
scan_int
(
"Digite um numero :"
);
}

Combinando Expressões no Painél Visual

Note que o Painel Visual sempre mostra as expressões com uma estrutura parecida com uma árvore , criando ramificações a partir da sua única saída até outras expressões:

Nós de expressões são conectados pela linha de não execução. As linhas de execução são as brancas, mais grossas. Então as outras linhas (quase sempre coloridas) representam os tipos diferentes sendo usados como entradas e saídas de expressões:

Expressões são executadas numa certa ordem, de acordo com seus precedentes.




Tipos de Expressões

Aqui estão todos os tipos de expressões e uma explicação básica de cada tipo.
Você pode navegar para os seus links para aprender mais sobre cada tipo:

Uma expressão de nome é uma referência para uma variável.
No exemplo a seguir, alguma_var é uma expressão de nome que referência o valor guardado dentro da variável:
var := alguma_var;
O que é uma expressão de nome (get de uma variável) no Vizzcode


Uma expressão de chamada de procedimento executa o código do procedimento e possivelmente usa o valor retornado do procedimento, quando disponível.
Por exemplo:
var :=
algum_procedimento_que_retorna_alguma_coisa
();
Um expressão de Chamada de Procedimento

Uma expressão literal de inteiros é um número inteiro que é colocado explicitamente no código, se opondo a um número que vem de uma variável(expressão de nome) ou o retorno de uma chamada de procedimento.
var :=
10
;
Expressão literal de inteiro

Da mesma forma, uma expressão literal de float é um número fracionário que é colocado explicitamente no código.
var :=
10.5
;
Expressão literal de float

Uma expressão literal de string é um texto colocado no código. É sempre especificado entre aspas “ ”, dessa forma:
var :=
"Ola!"
;
Expressão literal de string

Uma expressão literal de booleano é um valor verdadeiro ou falso colocado no código.
var :=
true
;
Expressão literal de bool

Expressões aritméticas podem adicionar, subtrair, multiplicar, dividir, fazer o módulo e negar valores.
var := (
4
+
6
) * -(
26
/
2
);
Expressões aritméticas

Expressões de comparação testam dois valores do tipo bool. A comparação pode ser uma dessas: igual a, diferente de, maior que, maior ou igual que, menor que ou menor ou igual que.
var :=
56
>=
10
;
Expressões de comparação

Expressões booleanas podem fazer operações lógicas em bools. Existem três operadores: e (and), ou (or) e não (not).
var :=
true
&& (
false
|| !
true
);
Expressões booleanas

Expressões de array podem ser usadas para acessar elementos individuais no array (através da expressão de array subscrito) e o tamanho (ou contador) do array com a expressão ‘count’ do array.
arr : [
10
]
int
;
var1 := arr.count;
var2 := arr[
0
];

Expressões de array




Expressões de Nós

Expressões existem em diversos nós visuais diferentes no Painel Visual.
Eles podem ser combinados arbitrariamente combinados com base nos seus tipos, formando expressões complexas:
Combinando várias expressões no Painél Visual

Entender os tipos de expressões, que você pode usar e como usar eles é muito importante para expressar suas ideias e soluções em forma de programação.
Você pode ler mais sobre a ordem de execução dos nós aqui e conferir essa ótima informação sobre precenência para aprender a ler expressões mais complexas.

Você também pode escrever uma expressão em texto dentro do campo de texto de um . Por exemplo:

Digitando uma expressão de texto dentro de um nó no Vizzcode

Essas expressões em texto podem ser complexas, e são avaliadas como se tivessem sido escritas no Painel de Texto. Pode ser mais rápido escrever algumas expressões do que criar nós para elas:

Programe mais rápido digitando expressões em texto no Vizzcode





Chamada de Procedimentos

Como já falamos antes, procedimentos são blocos de códigos que podem ser chamados para ter seu código executado, possivelmente retornando valores para quem chamou.
Quando o valor retornado por um procedimento é ignorado (ou não existe), essa chamada funciona como um simples construtor. Se, entretanto, esse valor retornado for usado, ele se torna uma expressão, possivelmente sendo combinadas com outras expressões:

proc
:: () ->
float
{
    
return
5.6
;
}

main
:: () {
    
proc
();
    var :=
proc
();
    var =
proc
() + (
5
*
proc
());
}

Chamadas de procedimentos no Painel Visual são discutidas na próxima seção.




Chamada de Procedimentos com Nós

Chamadas de Procedimentos funcionam da mesma forma no Painel Visual e no Painel de Texto (descrito na seção anterior).
Quando o valor retornado de um procedimento não é usado (ou não existe), o procedimento precisa ser chamado como um construtor, usando a conexão branca mais grossa no nó:
Quando conectar o pino branco de execução em uma chamada de procedimento

De forma alternativa, quando o valor retornado de uma chamada é usado, eles precisam ser conectados como uma expressão (com as outras linhas):

Usando chamadas de procedimentos como expressões

De qualquer forma, o código do procedimento é executado.
Você pode ler mais sobre valores de retorno aqui, incluindo como receber mais de um retorno de um procedimento.







Expressões Constantes

Os valores de algumas expressões são constantes, o que significa que eles não dependem da execução do programa e portanto podem ser conhecidos pelo compilador em tempo de compilação.
Por exemplo, quando você cria uma variável, por definição, seu valor pode ser mudado durante a execução do programa, portanto ele não é constante.
Literais, entretanto, (ints, floats, strings e bools literais), são sempre constantes.

Operar em valores constantes também resulta em um valor constante.
Por exemplo, no código seguinte, a expressão atribuída para var1 é constante (porque é uma expressão aritmética de duas expressões constantes), mas a expressão atribuída para var2 não é, porque ela usa o valor de uma variável:
main
:: () {
    var1 :=
4
+
5
*
8
;
    var2 := var1 *
2
;
}


Quando tiver declarando variáveis globais o valor que você atribui para elas na declaração precisa ser constante. Isso acontece porque o escopo global é independente da ordem , possibilitando que você use uma variável antes da sua declaração.
Por essa razão, você não pode atribuir valores não constantes (como uma outra variável) para a declaração de uma variável global.

Outro caso onde é necessário uma expressão constante é numa especificação do tamanho de um array na declaração (porque o tamanho dos arrays precisam ser conhecidos em tempo de compilação):
main
:: () {
    array : [
10
]
int
;
}





Expressões Aritméticas

Expressões Aritméticas são expressões que realizam alguma operação matemática em valores.
Elas podem ser:
  • Adição
  • Subtração
  • Multiplicação
  • Divisão
  • Módulo
Todas as operações aritméticas (tirando o módulo) são auto explicativas.

Essas operações trabalham apenas com ints e floats - com exceção do operador módulo, que trabalha apenas com ints.
Você pode operar apenas com valores do mesmo tipo.

Esses são alguns exemplos desses operadores em ação:
main
:: () {
    a :=
4
+
6
;
    b := a * (
8
-
2
);
    a += b-
2
;
}

Usando matemática no Vizzcode

Uma observação importante é que divisão de inteiros tem como saída um inteiro, ignorando a parte decimal. Por exemplo:
#import
"Print"


main
:: () {
    div :=
13
/
5
;
    
if
div ==
2
  
print
(
"True"
);
}





Módulo

O operador modulo calcula o resto de uma divisão entre dois inteiros.
O modulo é representado pelo símbolo %.

Por exemplo, se você dividir 13 por 5 você tem como resultado 2 e o resto é 3.
Nesse exemplo, o módulo de 13 por 5 seria igual a 3 (o resto da divisão).

#import
"Print"


main
:: () {
    divisao :=
13
/
5
;
    modulo :=
13
%
5
;
    
    
if
divisao ==
2
  
print
(
"True"
);
    
if
modulo ==
3
  
print
(
"True"
);
}

O módulo é bem útil para saber se um número é divisível por outro. No caso do número ser divisível, o resultado do módulo é igual a 0.
Isso resultada em outro uso bem comum: saber se o número é par ou ímpar.
Por conta de todos os números pares serem divisíveis por 2, você pode saber se o número é par testando se seu módulo por 2 é zero:
#import
"Print"


main
:: () {
    
if
(
4
%
2
==
0
)  
print
(
"4 e par"
);
    
if
(
7
%
2
!=
0
)  
print
(
"7 e impar"
);
    
if
(
180
%
2
==
0
)  
print
(
"180 e par"
);
    
if
(
351
%
2
!=
0
)  
print
(
"351 e impar"
);
}





Expressões Atribuíveis

Expressões atribuíveis (também conhecidas como expressões ou valores do lado esquerdo (lvalues)) são expressões que resultam em valores que podem ser atribuídos.

O caso mais simples é uma expressão de nome: uma referência a uma variável.
Nesse caso, você pode atribuir um valor pra ela escrevendo o nome da variável à esquerda da atribuição e o valor à direita:
var =
5
;

No Painel Visual, expressões atribuíveis são a prmeira expressão no nó de Atribuição:
Expressões atribuíveis no Painel Visual

Entretanto, podem ter expressões mais elaboradas que resultam em valores de atribuição.
Por exemplo, a expressão de subscript é usada para acessar um elemento do array, que é um valor que pode ser atribuído. O código a seguir mostrar uma atribuição de uma expressão de array subscript (o array arr, indexado na posição algum_int + 5):
main
:: () {
    algum_int :=
4
;
    arr : [
10
]
int
;
    
    arr[algum_int +
5
] =
10
;
}

Expressões atribuíveis mais complexas





Expressões de Comparação

Expressões de Comparação são expressões que comparam dois valores diferentes do mesmo tipo, resultado em um booleano.
Essas são as possíveis comparações:

Igual a
O operador igual a é representado pelo símbolo dos dois iguais ==. (Não confunda com o operador de um único igual = que representa atribuições).
#import
"Print"


main
:: () {
    a :=
45
;
    b :=
45
;

    
if
a == b  
print
(
"True"
);
}

Comparando se valores são iguais no Vizzcode

Diferente que
#import
"Print"


main
:: () {
    a :=
45
;
    b :=
19
;

    
if
a != b  
print
(
"True"
);
}

Comparando se valores são diferentes no Vizzcode

Maior que
#import
"Print"


main
:: () {
    a :=
45
;
    b :=
19
;

    
if
a > b  
print
(
"True"
);
}

Comparando se um valor é maior que outro no Vizzcode

Maior ou igual que
#import
"Print"


main
:: () {
    a :=
45
;
    b :=
19
;

    
if
a >= b  
print
(
"True"
);
}

Comparando se um valor é maior que or igual a outro no Vizzcode

Menor que
#import
"Print"


main
:: () {
    a :=
7
;
    b :=
20
;

    
if
a < b  
print
(
"True"
);
}

Comparando se um valor é menor que outro no Vizzcode

Menor ou igual que
#import
"Print"


main
:: () {
    a :=
7
;
    b :=
20
;

    
if
a <= b  
print
(
"True"
);
}

Comparando se um valor é menor que ou igual a outro no Vizzcode

Aqui estão todos os operadores de comparação juntos:
#import
"Print"


main
:: () {
    
if
(
9
==
4
)  
print
(
"false"
);
    
if
(
9
!=
4
)  
print
(
"true"
);
    
if
(
9
>  
4
)  
print
(
"true"
);
    
if
(
9
>=
4
)  
print
(
"true"
);
    
if
(
9
<  
4
)  
print
(
"false"
);
    
if
(
9
<=
4
)  
print
(
"false"
);

    
if
(
5
==
5
)  
print
(
"true"
);
    
if
(
5
!=
5
)  
print
(
"false"
);
    
if
(
5
>  
5
)  
print
(
"false"
);
    
if
(
5
>=
5
)  
print
(
"true"
);
    
if
(
5
<  
5
)  
print
(
"false"
);
    
if
(
5
<=
5
)  
print
(
"true"
);
}

Todos os operadores de comparação funcionam em ints e floats.
Os operadores igual e diferente também funcionam em strings e bools.




Comparando Strings

Em algumas outras linguagens de programação, existem formas especiais de testar a igualdade de strings.
No Vizzcode, é tão fácil quanto usar o operador de comparação de igualdade para testar elas.

Você pode comparar qualquer tipo de string (literal ou variável) da mesma forma:
main
:: () {
    mensagem :=
scan
(
"Ola? "
);
    
if
(mensagem ==
"oi"
)  
print
(
"Como voce esta?"
);
    
else
if
(mensagem ==
"quem e voce?"
)  
print
(
"Eu sou um programa de computador!"
);
}

Como comparar strings no Vizzcode

O operador de diferente que também funciona em strings:
main
:: () {
    mensagem :=
scan
(
"Ola? "
);
    
if
(mensagem !=
"sair"
) {
        
print
(
"Vamos programar!"
);
    }
}


Usando o operador diferente de em strings


As outras expressões de comparação (<, <=, > e >=) não funcionam em strings.




Operadores Booleanos

Existem operadores lógicos (ou operadores booleanos) que funcionam especificadamente em booleanos.
Eles são muito usados para criar condições mais complexas.
Existem três operadores booleanos:
  • AND “e” &&: o resultado é verdadeiro apenas se ambos os operadores forem verdadeiros
  • OR “ou” ||: o resultado é verdadeiro se qualquer operador for verdadeiro
  • NOT “não” !: o resultado é verdadeiro apenas se o operador for falso
Esses são os nós destes operadores no Painel Visual:
Expressões Booleanas no Painel Visual

Aqui estão alguns exemplos:
main
:: () {
    verdadeiro1 :=
true
&&
true
;
    falso1 :=
true
&&
false
;

    verdadeiro2 :=
true
||
false
;
    falso2 :=
false
||
false
;

    verdadeiro3 := !
false
;
    falso3 := !
true
;
}

Expressões Booleanas em ação

Eles podem ser combinados para criar expressões booleanas mais complexas:
main
:: () {
    verdadeiro1 := (
5
==
4
) || (!(
7
>
10
) && (
"Cachorro"
!=
"Lobo"
));
    verdadeiro2 := (
true
||
false
) && !(!
true
||
false
);

    falso1 := (
8.8
<
10
||
8.8
<
-50.0
) && (!(
5
!=
5
)) && (
5
<
5
||
8
>
10
);
    falso2 := (
true
&& (
false
||
true
)) || !(
false
&& !
false
);
}

É importante notar que o lado direito de uma expressão de AND (e) ou OR (ou) só é avaliada se necessário. Veja os casos a seguir:
if
(
false
&&
algum_procedimento_que_retorna_bool
()) {
    ...
}

if
(
true
||
algum_procedimento_que_retorna_bool
()) {
    ...
}

Em ambos “if”, o procedimento algum_procedimento_que_retorna_bool não é chamado porque o resultado da expressão não depende do seu valor. Isso também é conhecido como curto-circuito.




Expressões de Array

Existem duas expressões que foram feitas para trabalhar com arrays.

Subscript (subscrito) é uma expressão usada para acessar um elemento do array em um determinado índice.
O operador subscript é representado por um inteiro entre colchetes [ ] depois do nome de um array.
No exemplo abaixo, arr é um array de 10 inteiros. Se você quiser mudar a referência de algum dos elementos do array, você precisa sobrescrever “subscript” o array dessa forma:
main
:: () {
    arr : [
10
]
int
;
    arr[
0
] =
5
;
    arr[
5
] =
8
;
}

O que o subscrito do array e como usá-lo

O primeiro subscript no exemplo anterior (arr[0]) acessa o primeiro elemento do array (o elemento com o índice 0). O segundo subscript acessa o elemento no índice 5 (o sexto elemento).

A expressão subscript pode ser usada para preencher arrays manualmente (ou dentro de loops for) e também consultar ou mudar os valores no array. Os. The exercícios de programação possuem diversos exemplos e explicações de seu uso.
Por conta do subscript ser usado para acessar a memória do array em uma localização específica, ela pode ser usada para acessar um elemento fora dos limites do array. Por exemplo, no exemplo do array de 10 ints , se você tentar acessar o array com um índice inválido (<= -1 ou >= 10, por exemplo) você arrisca acessar uma memória inválida e derrubar “crashar” o programa. Você pode ler mais sobre isso aqui.


A outra expressão de array é a expressão Array Count “Contador”. Ela também é referida como tamanho do array ou length “comprimento”.
Ela pode ser criada escrevendo o nome do array e colocando .count, dessa forma
#import
"Print"


main
:: () {
    arr : [
15
]
string
;
    count := arr.count;
    
if
count ==
15
  
print
(
"Verdadeiro"
);
}

Pegando o tamanho do array no Vizzcode

Se você quiser saber o último índice do tamanho “count”, você precisa apenas subtrair um do tamanho (porque os índices dos arrays começam do zero).
Por exemplo, um array de 10 ints possui índices de 0 até (e incluindo) 9.
Isso é bem útil quando tiver iterando pelo array, porque usar a expressão .count garante que se o tamanho do array for alterado mais para frente, o loop continua iterando de forma correta até o fim do array, dessa forma:
#import
"Random"


main
:: () {
    arr : [
10
]
float
;

    
for
0
.. arr.count-
1
{
        arr[it] =
random_float_in_range
(
0
,
1
);
    }
}

main
:: () {
    arr : [
1000
]
float
;

    
for
0
.. arr.count-
1
{
        arr[it] =
random_float_in_range
(
0
,
1
);
    }
}





Precedência de Operadores

Assim como na matemática, uma expressão é resolvida com base na precedência dos operadores.
Por exemplo, por conta das multiplicações possuírem uma precedência maior que adições, a expressão a seguir tem como resultado 13 (Primeiro, 5 * 2 é resolvido, depois o valor 3 é adicionado ao resultado):
#import
"Print"


main
:: () {
    expr :=
3
+
5
*
2
;
    
if
expr ==
13
  
print
(
"Verdadeiro"
);
}

No Painel Visual, a ordem das operações seguem a partir do nó do construtor caminhando para a esquerda.
Entendendo em qual ordem os operadores são executados no Vizzcode

Por exemplo, você deve ler a expressão anterior deve ser lida assim:

Somar:
  • 3
  • Ao resultado da multiplicação de 5 por 2
Outro exemplo:

Lendo expressões complexas naturalmente

Somar
  • O resultado da multiplicação de:
    • A divisão de 10 por 2
    • E 5
  • Ao resultado da subtração de 6 por 7;
Você pode usar parênteses para impor uma ordem específica de operação.
Se você colocar parênteses em 3 + 5, parte da expressão 3 + 5 * 2, a adição vai ser resolvida primeiro, resultando em 16;
#import
"Print"


main
:: () {
    expr := (
3
+
5
) *
2
;
    
if
expr ==
16
  
print
(
"Verdadeiro"
);
}

Note que no Painel Visual, os operadores dos nós mudam de lugar comparado com o primeiro exemplo nessa seção.

Mudando a ordem das operações

Mesmo que você saiba qual operação vai ser executada primeiro, pode ser útil que você adicione parênteses nas expressões para ficar mais claro:
main
:: () {
    primeiro :=
5
*
2
+
7
*
3
;
    segundo := (
5
*
2
) + (
7
*
3
);
    
if
(primeiro == segundo)  
print
(
"Verdadeiro"
);
}

Você poder escrever uma expressão de texto mais complexa no campo de texto de um nó e ela será resolvida como se você tivesse escrito no Painel de Texto:

Escrevendo expressões complexas diretas no textbox


Aqui está todas as precedências de operadores no Vizzcode, mostrando a ordem que as expressões vão ser resolvidas a partir das que são resolvidas primeiro até aquelas que são resolvidas por último:
(Operadores no mesmo nível de precedência são resolvidos da esquerda para direita, como são encontradas na expressão)
  • Valores Literais e Expressões de Nome
  • Chamadas de Procedimentos, Array Subscript e Array Count
  • Negações e Não de Booleanos
  • Multiplicações, Divisões e Módulos
  • Adições e Subtrações
  • Comparações (Igual que, Diferente que, Maior que, Maior ou Igual que, Menor que, Menor ou Igual que)
  • Ands “e”
  • Ors “ou^