Operadores

Delégua implementa todos os seguintes operadores também implementados em Égua:

• ** - Exponenciação;
• * - Multiplicação;
• / - Divisão;
• + - Adição;
• - - Subtração;
• % - Resto da divisão (módulo);
• << - Deslocamento bit a bit à esquerda;
• >> - Deslocamento bit a bit à direita;
• & - "E" bit a bit;
• ^ - "Ou exclusivo" bit a bit (xor);
• | - "Ou" bit a bit;
• >= - Maior ou igual que;
• <= - Menor ou igual que;
• > - Maior que;
• < - Menor que;
• == - Igual a;
• != - Diferente de;
• em - em;
• e - "E" lógico;
• ou - "Ou" lógico;

Prioridade dos operadores

Os operadores têm uma ordem clara de prioridade, semelhante à matemática, onde as operações são realizadas em uma ordem específica (ordenadas de cima para baixo com a maior precedência no topo).

• **
• /, * e %
• + e -
• << e >>
• &
• | e ^
• > e <
• == e !=
• em, e e ou

Operadores matemáticos

Também chamados de operadores aritméticos, implementam as operações básicas da matemática.

Adição

escreva(2 + 2); // 4

• Se ambos os operandos são inteiros, o resultado será inteiro
• Se um dos operandos é em decimal (ponto flutuante), o resultado será em ponto flutuante

Subtração

escreva(10 - 3); // 7

• Se ambos os operandos são inteiros, o resultado será inteiro
• Se um dos operandos é em decimal (ponto flutuante), o resultado será em ponto flutuante

Multiplicação

escreva(10 * 3); // 30

• Se ambos os operandos são inteiros, o resultado será inteiro
• Se um dos operandos é em decimal (ponto flutuante), o resultado será em ponto flutuante

Divisão

escreva(100 / 5); // 20

• Se o resto da divisão é zero, o valor retornado será inteiro
• Caso contrário, o valor retornado será em ponto flutuante

Resto da divisão (módulo)

escreva(25 % 4); // 1

Exponenciação (potência)

Retorna o primeiro operando elevado à potência do segundo operando.

escreva(2 ** 5); // 32

Operadores lógicos

Delégua inclui as seguintes palavras-chave para operações lógicas:

• e - Retorna verdadeiro se ambos os valores são verdadeiros. Retorna falso caso contrário.
• ou - Retorna verdadeiro se um dos valores for verdadeiro. Retorna falso caso contrário.

verdadeiro e falso; // falso
verdadeiro e verdadeiro; // verdadeiro
falso e falso; // falso

verdadeiro ou falso; // verdadeiro
verdadeiro ou verdadeiro; // verdadeiro
falso ou falso; // falso

Operadores de comparação

Em Delégua, operadores de comparação retornam sempre verdadeiro ou falso. Se os tipos de operandos são diferentes, para alguns operadores, Delégua tenta resolver a comparação. Para outros, emite erro.

São operadores tolerantes com operandos de tipos diferentes:

• == - Igual a;
• != - Diferente de;

Os operadores a seguir não são tolerantes com operadores de tipos diferentes, e requerem ambos os operadores sendo números:

• >= - Maior ou igual que;
• <= - Menor ou igual que;
• > - Maior que;
• < - Menor que;

Igual a

escreva(1 == 1); // verdadeiro
escreva(1 == 2); // falso

Diferente de

escreva(1 != 1); // falso
escreva(1 != 2); // verdadeiro

Maior ou igual que

escreva(1 >= 1); // verdadeiro
escreva(2 >= 1); // verdadeiro
escreva(2 >= 3); // falso

Maior que

escreva(1 > 1); // falso
escreva(2 > 1); // verdadeiro
escreva(2 > 2); // falso

Menor ou igual que

escreva(1 <= 1); // verdadeiro
escreva(1 <= 2); // verdadeiro
escreva(3 <= 2); // falso

Menor que

escreva(1 < 1); // falso
escreva(1 < 2); // verdadeiro
escreva(2 < 2); // falso

Avaliação da verdade em variáveis não lógicas

Todos os tipos de dados, exceto nulos e falsos, possuem valor lógico verdadeiro.

{} // verdadeiro
1 // verdadeiro
verdadeiro // verdadeiro
[] // verdadeiro

1 == '1' // falso, devido à disparidade de tipos
nulo // falso
falso // falso

Operadores de pertencimento

Delégua implementa o operador em, que funciona da seguinte forma:

• Retorna verdadeiro se o valor da esquerda estiver incluído no valor da direita, se o valor da direita é um vetor. Retorna falso caso contrário.
  • Por definição, variáveis e literais de texto são vetores.
• Retorna verdadeiro se o valor da esquerda é uma chave dentro do valor da direita, se o valor da direita é um dicionário. Retorna falso caso contrário.

'a' em ['b']; // falso
'b' em ['b']; // verdadeiro
'c' em 'abc'; // verdadeiro
'chave' em {'chave': 'valor'}; // verdadeiro
'valor' em {'chave': 'valor'}; // falso

Operadores bit a bit

Esses operadores só podem ser usados com números inteiros. Caso números de ponto flutuante sejam usados, Delégua converte ambos os operandos para números inteiros, arredondando a parte decimal sempre para baixo. O retorno é sempre um número inteiro.

"E" bit a bit (and)

escreva(8 & 2); // 1000 & 0010 = 0000, retorna 0
escreva(12 & 4); // 1100 & 0100 = 0100, retorna 4
escreva(77 & 13); // 1001101 & 0001101 = 0001101, retorna 13

"Ou" bit a bit (or)

escreva(8 | 1); // 1000 & 0001 = 1001, retorna 9
escreva(12 | 2); // 1010 & 0010 = 1010, retorna 12

"Ou exclusivo" bit a bit (xor)

escreva(8 ^ 1); // 1000 & 0001 = 1001, retorna 9
escreva(15 ^ 0); // 1111 & 0000 = 1111, retorna 15
escreva(15 ^ 2); // 1111 & 0010 = 1101, retorna 13