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
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.
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.
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.
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.
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;
}
}Last updated