Skip to content

Operadores

Jump to bottom
Leonel Sanches da Silva edited this page Dec 13, 2023 · 17 revisions

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

  • = – Atribuição;
  • ** – 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.

E alguns operadores adicionais:

  • \ - Divisão inteira;
  • *= – Multiplicação com atribuição;
  • /= – Divisão com atribuição;
  • += – Adição com atribuição;
  • -= – Subtração com atribuição;
  • %= – Resto da divisão (módulo) com atribuição;
  • ++ - Incremento de literal ou variável;
  • -- - Decremento de literal ou variável.

Prioridade dos operadores

Os operadores têm uma ordem clara de prioridade, semelhante à matemática, na qual as operações são realizadas em uma ordem específica (ordenadas de cima para baixo com a maior precedência no topo). A resolução de prioridade é implementada no avaliador sintático:

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

Prioridade de operadores de incremento/decremento

Operadores de incremento e decremento são um caso especial. Por serem operadores unários, podem aparecer antes da variável ou literal:

var a = 2
escreva(++a) // Escreve 3

Mas também podem aparecer depois:

var a = 2
escreva(a++) // Escreve 2
escreva(a) // Escreve 3

Em resumo, quando o operador aparece antes da variável, o incremento/decremento é feito antes de o valor da variável ou literal ser resolvido. Quando aparece depois, o valor é resolvido primeiro e o incremento ocorre depois.

Por isso, especificamente para literais, a construção abaixo não existe:

var b = 3++

Mas a construção abaixo é válida:

var b = ++3

Operador de atribuição

Usado para atribuir valores a variáveis. É representado pelo símbolo =.

Os operandos do lado esquerdo precisam ser variáveis. Os operandos do lado direito podem ser literais, variáveis, chamadas de função, operações matemáticas, etc.

var numero;
escreva(numero); // nulo
numero = 1;
escreva(numero); // 1
numero = numero + 1;
escreva(numero); // 2

Para atribuir múltiplos valores na mesma linha, separe os valores por vírgula.

var a, b, c = 1, 2, 3
a, b, c = '3', 4 + 5, leia('Digite c:')

Desestruturação

Delégua suporta desestruturação para objetos e dicionários. Em outras palavras, desestruturação é uma operação que atribui a diferentes variáveis ou constantes valores de métodos e propriedades de um dicionário ou objeto. Por exemplo:

var d = { "a": 1, "b": 2, "c": 3 }
var { a, b, c } = d // Note que os nomes das variáveis à esquerda precisam corresponder às chaves do dicionário à direita.
                    // Caso contrário, teremos erro.
escreva(a) // Imprime 1
escreva(b) // Imprime 2
escreva(c) // Imprime 3
var d1 = { "a1": 1, "b1": 2, "c1": 3 }
const { a1, b1, c1 } = d1 // Mesmo exemplo, só que com constantes.

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 é um número real (ponto flutuante), o resultado será em ponto flutuante.

Também há a adição combinada com a atribuição:

var a = 2;
a += 2; // `a` terá o valor 4

Subtração

escreva(10 - 3); // 7
  • Se ambos os operandos são inteiros, o resultado será inteiro;
  • Se um dos operandos é um número real (ponto flutuante), o resultado será em ponto flutuante.

Também há a subtração combinada com a atribuição:

var b = 10;
b -= 3; // `b` terá o valor 7

Multiplicação

escreva(10 * 3); // 30
  • Se ambos os operandos são inteiros, o resultado será inteiro;
  • Se um dos operandos é um número real (ponto flutuante), o resultado será em ponto flutuante.

Também há a multiplicação combinada com a atribuição:

var c = 10;
c *= 3; // `c` terá o valor 30

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.

Também há a divisão combinada com a atribuição:

var d = 100;
d /= 5; // `d` terá o valor 20

Resto da divisão (módulo)

escreva(25 % 4); // 1

Também há a operação de resto da divisão combinada com a atribuição:

var e = 25;
e %= 4; // `e` terá o valor 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. Caso contrário, retorna falso.
  • ou – Retorna verdadeiro se um dos valores for verdadeiro. Caso contrário, retorna falso.
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 operandos de tipos diferentes e requerem que ambos os operandos sejam 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, caso o valor da direita seja um vetor. Caso contrário, retorna falso.
    • 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, caso o valor da direita seja um dicionário. Caso contrário, retorna falso.
'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 reais (de ponto flutuante) sejam usados, Delégua converte ambos os operandos para números inteiros, arredondando a parte decimal sempre para baixo. O retorno de cada uma dessas operações é 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
Clone this wiki locally