Guia rápido para operadores de Solidity

Nesta postagem, examinaremos de perto os operadores do Solidity e vários tipos de operadores suportados pelo Solidity , fornecendo exemplos e trechos de código para ajudá-lo a entender como usá-los em seus próprios contratos inteligentes.

Seja você um iniciante ou um desenvolvedor experiente, este guia o ajudará a obter uma compreensão mais profunda dos operadores do Solidity.

Índice-

Operadores de solidez

Para criar contratos inteligentes eficazes , é importante ter um conhecimento sólido dos operadores do Solidity.

O Solidity oferece suporte a uma ampla variedade de operadores, incluindo operadores aritméticos, bit a bit, lógicos, de comparação e de atribuição, entre outros.

Ao dominar esses operadores, você pode escrever um código mais limpo, mais conciso e mais eficiente.

O que é um Operador?

Vejamos uma expressão simples: 7+ 6 = 13. Nesse caso, 7 e 6 são conhecidos como operandos, enquanto + é o operador.

Aqui está uma lista dos tipos de operadores suportados pelo Solidity.

  • Operadores aritméticos
  • Operadores de Comparação
  • Operadores Lógicos (ou Relacionais)
  • Operadores de atribuição
  • Operadores condicionais (ou ternários)

Vamos examinar cada operador um por um.

Aritmética do operador de solidez

Os operadores aritméticos suportados pelo Solidity incluem o seguinte:

No caso da variável mrx segurando 7 e variável ampla segurando 5, então:

Sr. Não. Operadores e visão geral
1 + (Adição)

A soma de dois operandos (mrx e ample) será:

Ex: mrx + amplo vai dar 12
2 – (subtração)

Encontra a diferença de amplo de mrx

Ex: mrx – amplo dará 2
3 * (Multiplicação)

Exibe o produto de mrx e amplo

Ex: mrx * amplo vai dar 35
4 / (Divisão)

Divida o mrx pelo amplo

Ex: mrx/amplo vai dar 1
5 % (Módulo)

Exibe o restante de uma divisão inteira

Ex: mrx % amplo dará 2
6 ++ (Incremento)

Faça um incremento de um ao valor inteiro

Ex: mrx++ vai dar 8
7 — (Decremento)

Diminui um valor inteiro em um

Ex: amplo– vai dar 4

 

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint public mrx=7;
uint public ample=5;
function Add_Integers() public view returns(uint){
uint sum=mrx+ample;
return sum;
}
function Subtract_Integers() public view returns(uint){
uint difference=mrx-ample;
return difference;
}
function Multiply_Integers() public view returns(uint){
uint product=mrx*ample;
return product;
}
function Divide_Integers() public view returns(uint){
uint devide=mrx/ample;
return devide;
}
function Modulus_Of_Integers() public view returns(uint){
uint modulus=mrx%ample;
return modulus;
}
function Increament_mrx() public returns(uint){
mrx++;
return mrx;
}
function Decrement_mrx() public returns(uint){
mrx--;
return mrx;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Comparação do Operador Solidity

Os operadores de comparação são usados ​​para comparar duas variáveis.

Considerando o cenário que pegamos no código acima, vamos explorar o funcionamento do operador de comparação:

Correspondentemente quando a variável mrx=7 e ample=5 então:

Sr. Não. Visão geral
1 = = (Igual)

Nesse método, o valor de dois operandos é verificado entre si para ver se são iguais; se forem, a condição se tornará verdadeira caso contrário.

Ex: (mrx == amplo) não é verdade.
2 != (Diferente)

Uma condição é testada para ver se o valor de dois operandos são iguais ou não. Se os operandos não tiverem o mesmo valor, a condição é verdadeira.

Ex: (mrx != amplo) é verdadeiro.
3 > (maior que)

Esta função verifica se o valor do operando esquerdo é maior que o valor do operando direito, se for, a condição torna-se verdadeira, caso contrário, será falsa.

Ex: (mrx > amplo) resulta como verdadeiro.
4 < (Menos que)

Ele verifica se o valor do operando esquerdo é maior que o valor do operando direito e, se for, a condição torna-se verdadeira. Caso contrário, retorna falso.

Ex: (mrx < amplo) é falso.
5 >= (Maior ou igual a)

Verifica se o operando da esquerda tem valor maior ou igual ao operando da direita; se o fizer, então torna-se verdadeiro. Caso contrário, a condição permanece falsa

Ex: (mrx >= amplo) é verdadeiro.
6 <= (Menor ou igual a)

Esta função verifica se o valor do operando da esquerda é menor ou igual ao valor do operando da direita, se a resposta for sim, a condição torna-se verdadeira, caso contrário, torna-se falsa.

Ex: (mrx <= amplo) é falso.

 

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint public mrx=7;
uint public ample=5;
function Equal_Condition() public view returns(bool){
return mrx==ample;
}
function Not_Equal_Condition() public view returns(bool){
return mrx!=ample;
}
function GreaterThan_Condition() public view returns(bool){
return mrx>ample;
}
function LessThan_Condition() public view returns(bool){
return mrx<ample;
}
function GreaterThanEqualsTo_Condition() public view returns(bool){
return mrx>=ample;
}
function LessThanEqualsTo_Condition() public view returns(bool){
return mrx<=ample;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Saída de exemplo de Solidity Operators

Solidity Operador Lógico

O significado de um operador lógico ou frase de operador é um símbolo ou palavra usada para conectar duas expressões.

Isso significa que o valor da expressão composta gerada depende apenas do valor da expressão original, bem como do significado do operador ou frase.

Há vários operadores lógicos comumente usados, incluindo AND , OR e NOT .

Aqui mrx=7 e ample=5 como usamos nos códigos acima:

 

Sr. Não. Visão geral
1 && (E Lógico)

Se ambas as condições forem verdadeiras, a saída será verdadeira:

Ex: (mrx>2 && amplo>3) é verdadeiro.
2 || (OU Lógico)

Se qualquer uma das condições for verdadeira, ele retornará verdadeiro:

Ex: (mrx>4 || ample<3 ) é verdadeiro.
3 ! (NÃO Lógico)

Ele inverte o resultado dos operadores lógicos, se o resultado for verdadeiro então mostra fale e vice-versa.,

Exemplo: ! (mrx>4 && amplo==5) é falso.

Assumindo o Cenário que usamos nos códigos acima, aqui podemos entender o funcionamento dos Operadores Lógicos:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint public mrx=7;
uint public ample=5;
function AND_Operator() public view returns(bool){
return (mrx>2 && ample>2);
}
function OR_Operator() public view returns(bool){
return (mrx>4 || ample<2);
}
function Not_Operator() public view returns(bool){
return !(mrx>4 && ample==5);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Operador de solidez bit a bit

O operador AND bit a bit ( & ) é usado para comparar cada bit do primeiro operando com o bit correspondente do segundo operando.

No caso de dois bits serem 1, o bit resultante é definido como 1. Caso contrário, o bit correspondente ao resultado é definido como 0. Para realizar um AND bit a bit, ambos os operandos devem ser do tipo integral.

Vamos pegar uma variável, nomeá-la como mrx e atribuir-lhe um valor 4, e declarar outra variável ampla e atribuir-lhe um valor 2:

Sr. Não. Visão geral
1 & (E bit a bit)

Uma operação booleana AND é executada em cada bit de seus argumentos inteiros.

Ex: (mrx & amplo) é 0.
2 | (BitWise OU)

A operação booleana OR é aplicada a cada bit dos argumentos inteiros.

Ex: (mrx | amplo) é 6.
3 ^ (XOR bit a bit)

Esta função executa uma operação booleana OU exclusiva em cada bit de seus argumentos inteiros. Em uma situação OU exclusiva, o operando um ou dois será verdadeiro, mas nenhum será verdadeiro ao mesmo tempo.

Ex: (mrx ^ amplo) é 6.
4 ~ (não bit a bit)

Este é um operador unário que inverte todos os bits do operando quando é aplicado.

Ex: (~mrx) é 0.
5 << (Shift à esquerda)

Os bits do primeiro operando são movidos para a esquerda pelo número de casas especificado no segundo operando. Sempre que um novo bit é criado, ele é preenchido com zeros. Quando você desloca um valor à esquerda em uma posição, equivale a multiplicá-lo por 2. Se deslocar duas posições, equivale a multiplicá-lo por 4.

Ex: (mrx << 2) é 16.
6 >> (Shift à direita)

Usando o Binary Right Shift Operator, o valor do operando esquerdo é deslocado para a direita pelo número de bits do operando direito.

Ex: (mrx >> 2) é 16.
7 >>> (Deslocamento à direita com Zero)

Existe um operador muito semelhante, o operador >>, mas os bits deslocados à esquerda são sempre zero.

Ex: (mrx >>> 1) é 5.

 

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint public mrx=4;
uint public ample=2;
function Bitwise_AND_Operator() public view returns(uint){
return (mrx & ample);
}
function Bitwise_OR_Operator() public view returns(uint){
return (mrx | ample);
}
function Bitwise_XOR_Operator() public view returns(uint){
return (mrx ^ ample);
}
function Bitwise_Not_Operator() public view returns(uint){
return (~mrx);
}
function Left_Shift_Operator() public view returns(uint){
return (mrx << 2);
}
function Right_Shift_Operator() public view returns(uint){
return (mrx << 2);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

 

Sr. Não. Visão geral
1 = (Atribuição Simples)

Um valor é atribuído ao operando esquerdo do operando direito

Ex: mrx= ample , neste caso o valor de ample é atribuído à variável mrx
2 += (Adicionar e Atribuir)

O operando direito é adicionado ao operando esquerdo e, em seguida, o resultado é atribuído ao operando esquerdo.

Ex: mrx += 3 é equivalente a mrx = mrx + 3
3 –= (Subtração e Atribuição)

Esta função subtrai o operando direito do operando esquerdo e atribui o resultado ao operando esquerdo.

Ex: amplo -= 5 é equivalente a amplo = amplo – 5
4 *= (Multiplicação e Atribuição)

O resultado da multiplicação do operando direito pelo esquerdo é atribuído ao operando esquerdo.

Ex: mrx*= amplo é equivalente a mrx = mrx * amplo
5 /= (Divisão e Atribuição)

Os operandos esquerdo e direito são divididos juntos e o resultado é atribuído ao operando esquerdo.

Ex: mrx/= ample é equivalente a mrx = mrx / ample
6 %= (Módulos e Atribuição)

O módulo é calculado com dois operandos e atribuído ao operando esquerdo.

Ex: amplo %= 4 é equivalente a amplo = amplo % 4

 

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint public mrx=14;
uint public ample=8;
function Simple_Assignment_Operator() public returns(uint){
mrx=10; // Here we modified the value of mrx
return mrx;
}
function Add_and_Assign_Operator() public returns(uint){
return (mrx+=3); // Value of mrx is added to three digits adn the corresponding value is assigned to the left operand
}
function Subtract_and_Assign_Operator() public returns(uint){
return (ample-=5);
}
function Multiply_and_Assign_Operator() public returns(uint){
return (mrx*=ample);
}
function Divide_and_Assign_Operator() public returns(uint){
return (mrx /= ample);
}
function Modulus_Operator() public view returns(uint){
return (ample % 4);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>
Os operadores bit a bit terão a mesma lógica que <<=, >>=, >>=, &=, |= e ^=

Operador condicional de solidez (?

Operadores condicionais avaliam expressões para determinar se são verdadeiras ou falsas . Em seguida, com base no resultado da avaliação , eles executam qualquer uma das duas instruções fornecidas.

Sr. Não. Visão geral
1 ? : (Condicional)

O valor será X se a condição for verdadeira, caso contrário, será Y se a condição for falsa

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract SolidityTest{
uint public mrx=14;
uint public ample=8;
function Conditional_Operators() public view returns(uint){
uint result=(mrx>ample ? mrx-ample : ample-mrx);
return result;
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>
Nós valorizamos o seu feedback.
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
Assine a nossa newsletter
Digite seu e-mail para receber um resumo semanal de nossos melhores posts. Saber mais!
ícone
Ao assinar, você concorda com nossa política de privacidade e nossos termos de serviço.