16.11.2024

Aula 040: Operadores em Solidity

Em Solidity, operadores são símbolos especiais usados para realizar várias operações em variáveis e valores. Compreender os operadores é essencial para escrever contratos inteligentes eficazes. Nesta aula, vamos explorar os diferentes tipos de operadores disponíveis no Solidity.

1. Operadores Aritméticos

Os operadores aritméticos são utilizados para realizar operações matemáticas.

Exemplo

pragma solidity ^0.8.0;

contract ExemploAritmetico {
    uint public a = 10;
    uint public b = 5;

    function somar() public view returns (uint) {
        return a + b; // Adição
    }

    function subtrair() public view returns (uint) {
        return a - b; // Subtração
    }

    function multiplicar() public view returns (uint) {
        return a * b; // Multiplicação
    }

    function dividir() public view returns (uint) {
        return a / b; // Divisão
    }

    function modulo() public view returns (uint) {
        return a % b; // Módulo
    }
}

2. Operadores de Comparação

Os operadores de comparação são usados para comparar dois valores e retornar um resultado booleano.

Exemplo

pragma solidity ^0.8.0;

contract ExemploComparacao {
    uint public a = 10;
    uint public b = 5;

    function ehIgual() public view returns (bool) {
        return a == b; // Igual a
    }

    function naoEhIgual() public view returns (bool) {
        return a != b; // Não igual a
    }

    function ehMaior() public view returns (bool) {
        return a > b; // Maior que
    }

    function ehMenor() public view returns (bool) {
        return a < b; // Menor que
    }

    function ehMaiorOuIgual() public view returns (bool) {
        return a >= b; // Maior ou igual a
    }

    function ehMenorOuIgual() public view returns (bool) {
        return a <= b; // Menor ou igual a
    }
}

3. Operadores Lógicos

Os operadores lógicos são usados para realizar operações lógicas entre valores booleanos.

Exemplo

pragma solidity ^0.8.0;

contract ExemploLogico {
    bool public a = true;
    bool public b = false;

    function logicoE() public view returns (bool) {
        return a && b; // Lógico E
    }

    function logicoOU() public view returns (bool) {
        return a || b; // Lógico OU
    }

    function logicoNao() public view returns (bool) {
        return !a; // Lógico NÃO
    }
}

4. Operadores Bitwise

Os operadores bitwise são usados para realizar operações nas representações binárias de inteiros.

Exemplo

pragma solidity ^0.8.0;

contract ExemploBitwise {
    uint8 public a = 5;  // 0101 em binário
    uint8 public b = 3;  // 0011 em binário

    function bitwiseE() public view returns (uint8) {
        return a & b; // Bitwise E
    }

    function bitwiseOU() public view returns (uint8) {
        return a | b; // Bitwise OU
    }

    function bitwiseXor() public view returns (uint8) {
        return a ^ b; // Bitwise XOR
    }

    function bitwiseNao() public view returns (uint8) {
        return ~a; // Bitwise NÃO
    }

    function deslocamentoEsquerdo() public view returns (uint8) {
        return a << 1; // Deslocamento para a Esquerda
    }

    function deslocamentoDireito() public view returns (uint8) {
        return a >> 1; // Deslocamento para a Direita
    }
}

5. Operadores de Atribuição

Os operadores de atribuição são usados para atribuir valores a variáveis, muitas vezes permitindo operações abreviadas.

Exemplo

pragma solidity ^0.8.0;

contract ExemploAtribuicao {
    uint public a = 10;

    function adicaoAtribuicao() public {
        a += 5; // a = a + 5
    }

    function subtracaoAtribuicao() public {
        a -= 2; // a = a - 2
    }

    function multiplicacaoAtribuicao() public {
        a *= 3; // a = a * 3
    }

    function divisaoAtribuicao() public {
        a /= 2; // a = a / 2
    }
}

6. Operador Ternário

O operador ternário é uma forma abreviada de uma declaração if-else.

Exemplo

pragma solidity ^0.8.0;

contract ExemploTernario {
    uint public a = 10;
    uint public b = 5;

    function maximo() public view returns (uint) {
        return (a > b) ? a : b; // Operador Ternário
    }
}

Conclusão

Nesta aula, cobrimos vários tipos de operadores em Solidity, incluindo operadores aritméticos, de comparação, lógicos, bitwise, de atribuição e o operador ternário. Compreender como e quando usar esses operadores é crucial para desenvolver contratos inteligentes de forma eficaz.

Experimente esses exemplos para obter uma compreensão mais profunda de como os operadores funcionam em Solidity.

Video

Navigation