Operadores

Os operadores do Solidity permitem realizar operações matemáticas, lógicas, de comparação, de atribuição, entre outras. Compreender esses operadores é fundamental para o desenvolvimento eficaz de contratos inteligentes. Aritméticos

Aritméticos

Operación	Operador	Descripción
Soma	+	Soma dois operandos
Subtração	-	Subtrai o segundo operando do primeiro.
Multiplicação	*	Multiplica os operandos.
Divisão	/	Divide o numerador pelo denominador
Módulo	%	Retorna o resto de uma divisão
Incremento	++	Incrementa o valor em um.
Decremento	—	Reduz o valor em um.

Exemplo

// SPDX-License-Identifier: MIT 
pragma solidity ^0.8.13; 
contract OperatorDemo {
    // Inicializar variáveis
    uint16 public primeiro = 10;
    uint16 public segundo = 30;
    // Inicializar uma variável com o operador de soma
    uint public soma = primeiro + segundo;
    // Inicializar uma variável com o operador de subtração
    uint public subtracao = segundo - primeiro; 
    // Inicializar uma variável com uma multiplicação
    uint public multiplicacao = primeiro * segundo;
    // Inicializar uma variável com o quociente de uma divisão
    uint public divisao = primeiro / segundo; 
    // Inicializar uma variável com o módulo
    uint public modulo = primeiro % segundo; 
    // Inicializar uma variável com um valor decrementado em uma unidade
    uint public decremento = --segundo;
    // Inicializar uma variável com um valor incrementado em uma unidade
    uint public incremento = ++primeiro; 
}

Relações

Operadores utilizadores para comparação de valores.

Relación	Operador	Descripción
Igual	==	Compara se dois valores são iguais. Se são, retorna verdadeiro(true)
Diferente	!=	Compara se os valores são diferentes. Se são, retorna verdadeiro(true).
Maior que	>	Verifica se o valor da esquerda é maior que o valor da direita. Se sim, retorna verdadeiro(true).
Menor que	<	Verifica se o valor da esquerda é menor que o valor da direita. Se sim, retorna verdadeiro(true).
Maior ou igual que	>=	Verifica se o valor da esquerda é maior ou igual que o valor da direita. Se sim, retorna verdadeiro(true).
Menor ou igual que	<=	Verifica se o valor da esquerda é menor ou igual ao valor da direita. Se sim, retorna verdadeiro(true).

Ejemplo

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract OperatorDemo {
    // Inicializar variáveis
    uint16 public primeiro = 10;
    uint16 public segundo = 30;

    // Inicializar uma variável (bool) com o resultado de uma comparação de igualdade
    bool public igual = primeiro == segundo;

    // Inicializar uma variável (bool) com o resultado de uma comparação de diferença
    bool public diferente = primeiro != segundo;

    // Inicializar uma variável (bool) com o resultado de uma comparação de maior
    bool public maior = segundo > primeiro;

    // Inicializar uma variável (bool) com o resultado de uma comparação de menor
    bool public menor = primeiro < segundo;

    // Inicializar uma variável (bool) com o resultado de uma comparação de maior ou igual
    bool public maiorOuIgual = segundo >= primeiro;

    // Inicializar uma variável (bool) com o resultado de uma comparação de menor ou igual
    bool public menorOuIgual = primeiro <= segundo;
}

Lógicos

Combinam condições para determinar um valor lógico resultante.

Función lógica	Operador	Descripción
AND	&&	Retorna verdadeiro(true) se ambas as condições são verdadeiras. Retorna falso(false) se uma das condições forem falsas.
OR
NOT	!	Retorna verdadeiro se a condição não for satisfeita.

Exemplo

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract OperatorDemo { 
    // Inicializar variáveis
    bool public primeiro = true; 
    bool public segundo = false; 

    // Inicializar uma variável com o resultado de um AND
    bool public e = primeiro && segundo; 

    // Inicializar uma variável com o resultado de um OR
    bool public ou = primeiro || segundo;

    // Inicializar uma variável com o resultado de um NOT
    bool public nao = !segundo; 
}

De atribuição

Permitem atribuir um valor a uma variável. No lado direito do operador está o valor, e no lado esquerdo, uma variável.

Tipo	Operador	Descripción
Atribuição simples	=	Atribui o valor da direita à variável da esquerda do operador.
Atribuição de soma	+=	Soma o valor da direita ao valor da variável da esquerda e atribui o resultado à variável.
Atribuição de subtração	-=	Subtrai o valor da direita do valor da variável da esquerda. Atribui o resultado à variável.
Atribuição de Multiplicação	*=	Multiplica os valores. Atribui o resultado á variável da esquerda.
Atribuição de divisão	/=	Divide o valor da variável da esquerda pelo valor da direita. Atribui o resultado à variável da esquerda.
Atribuição de módulo	%=	Divide o valor da variável da esquerda pelo valor a direita. Atribui o resto da divisão à variável da esquerda.

Exemplo

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract OperatorDemo {
    // Inicializar variável de estado
    uint public primeiro = 10;

    // Atribuição simples
    function atribuicaoSimples() public {
        primeiro = 20;
    }

    // Atribuição com soma
    function atribuicaoSoma() public {
        primeiro += 10;
    }

    // Atribuição com subtração
    function atribuicaoSubtracao() public {
        primeiro -= 10;
    }

    // Atribuição com multiplicação
    function atribuicaoMultiplicacao() public {
        primeiro *= 5;
    }

    // Atribuição com divisão
    function atribuicaoDivisao() public {
        primeiro /= 3;
    }

    // Atribuição com módulo
    function atribuicaoModulo() public {
        primeiro %= 3;
    }
}

Sugestão: Leve este exemplo para o Remix e veja o que acontece com o valor de primeiro quando você executar cada uma das funções.

Bitwise

São operadores utilizados para realizar operações a nível de bit.

Tipo	Operador	Descripción
Bitwise AND	&	Aplica um operador lógico AND aos operandos inteiros. a nível de bit.
Bitwise OR
Bitwise XOR	^	Aplica um operador lógico XOR aos operandos inteiros a nível de cada bit.
Bitwise NOT	~	Aplica um operador lógico NOT ao operando a nível de cada bit.
Deslocamento à esquerda	<<	Os bits do primeiro operando são deslocados para a esquerda por um número de posições indicado pelo segundo operando.
Deslocamento à direita	>>	Os bits do primeiro operando são deslocados para a direita por um número de posições indicado pelo segundo operando.

Para entender essas funções, vejamos alguns exemplos de como realizar operações a nível de bit ou binário.

Para expressar um número em binário, usamos apenas 0 e 1. Cada posição do número binário representa uma potência de 2. Assim, um 1 na primeira posição da direita é 2^0 = 1, na segunda 2^1 = 2, na terceira 2^2 = 4, na quarta 2^3 = 8, e assim por diante.

Suponhamos que temos dois valores x e y:

x = 12, y = 5, que devemos expressar em binário para realizar operações bitwise.

x = 12 = 8 + 4 + 0 + 0 = 1100 (binário)

y = 5 = 0 + 4 + 0 + 1 = 0101 (binário)

Se realizarmos a operação AND a nível de bit, teremos o seguinte:

x & y = 0100 = 0 + 4 + 0 + 0 = 4

Se realizarmos a operação OR a nível de bit:

x | y = 1101 = 8 + 4 + 0 + 1 = 13

Se realizarmos a operação XOR a nível de bit, que é 1 quando um dos operandos é 1:

x ^ y = 1001 = 8 + 0 + 0 + 1 = 9

Se realizarmos a operação NOT a x a nível de bit, o que implica trocar os zeros por uns e vice-versa:

NOT x = 0011 = 0 + 0 + 2 + 1 = 3

Se deslocarmos x para a esquerda duas posições:

x = 12 = 1100 (binário)

x << 2 = 110000 = 48

Se deslocarmos x para a direita duas posições:

x = 12 = 1100 (binário)

x >> 2 = 0011 = 3

Exemplo: Deploye este contrato e verifique se os valores para x = 12 e y = 5 coincidem com os resultados anteriores. Teste também com outros valores.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract BitwiseOps {
    
    // Função AND a nível de bit
    function and(uint x, uint y) external pure returns (uint) {
        return x & y;
    }

    // Função OR a nível de bit
    function or(uint x, uint y) external pure returns (uint) {
        return x | y;
    }

    // Função XOR a nível de bit
    function xor(uint x, uint y) external pure returns (uint) {
        return x ^ y;
    }

    // Função NOT a nível de bit
    function not(uint8 x) external pure returns (uint8) {
        return ~x;
    }

    // Função de deslocamento para a esquerda
    function shiftLeft(uint x, uint bits) external pure returns (uint) {
        return x << bits;
    }

    // Função de deslocamento para a direita
    function shiftRight(uint x, uint bits) external pure returns (uint) {
        return x >> bits;
    }
}

Condicional

É um operador ternário que avalia inicialmente uma expressão e executa uma ação se for verdadeira, ou outra se for falsa. O formato do operador ternário é o seguinte:

<condição> ? <se for verdadeira> : <se for falsa>

Exemplo

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Conditional {

    function ternario(uint _x) public pure returns (uint) {
        // Se _x for menor que 10, a função retorna 1, caso contrário, retorna 2
        return _x < 10 ? 1 : 2;
    }
}