16.11.2024

Aula 042: Operadores Relacionais em Solidity

Nesta aula, exploraremos o conceito de operadores relacionais em Solidity. Operadores relacionais são essenciais na programação, pois ajudam a comparar valores e tomar decisões com base nessas comparações. Em Solidity, esses operadores podem ser usados para comparar inteiros, endereços e valores booleanos.

O Que São Operadores Relacionais?

Operadores relacionais permitem que você compare dois valores e retorne um resultado booleano (verdadeiro ou falso). Abaixo estão os operadores relacionais comumente usados em Solidity:

• == (Igualdade)
• != (Desigualdade)
• > (Maior que)
• < (Menor que)
• >= (Maior ou igual a)
• <= (Menor ou igual a)

Exemplos de Operadores Relacionais

Vamos passar por alguns exemplos de código para demonstrar como usar esses operadores em Solidity.

Exemplo 1: Igualdade e Desigualdade

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

contract OperadoresRelacionais {
    function verificarIgualdade(uint256 a, uint256 b) public pure returns (bool) {
        return a == b; // retorna verdadeiro se a for igual a b
    }

    function verificarDesigualdade(uint256 a, uint256 b) public pure returns (bool) {
        return a != b; // retorna verdadeiro se a não for igual a b
    }
}

Neste exemplo, a função verificarIgualdade retorna verdadeiro se os dois números forem iguais, enquanto verificarDesigualdade retorna verdadeiro se não forem iguais.

Exemplo 2: Maior Que e Menor Que

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

contract OperadoresRelacionais {
    function ehMaior(uint256 a, uint256 b) public pure returns (bool) {
        return a > b; // retorna verdadeiro se a for maior que b
    }

    function ehMenor(uint256 a, uint256 b) public pure returns (bool) {
        return a < b; // retorna verdadeiro se a for menor que b
    }
}

Aqui, ehMaior verifica se a é maior que b, enquanto ehMenor verifica se a é menor que b.

Exemplo 3: Maior ou Igual a e Menor ou Igual a

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

contract OperadoresRelacionais {
    function ehMaiorOuIgual(uint256 a, uint256 b) public pure returns (bool) {
        return a >= b; // retorna verdadeiro se a for maior ou igual a b
    }

    function ehMenorOuIgual(uint256 a, uint256 b) public pure returns (bool) {
        return a <= b; // retorna verdadeiro se a for menor ou igual a b
    }
}

Neste trecho de código, ehMaiorOuIgual retorna verdadeiro se a for maior ou igual a b, enquanto ehMenorOuIgual verifica a condição oposta.

Caso de Uso: Combinando Operadores Relacionais

Você pode combinar esses operadores em declarações condicionais para criar lógica mais complexa. Aqui está um exemplo:

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

contract OperadoresRelacionais {
    function avaliarCondicoes(uint256 a, uint256 b, uint256 c) public pure returns (string memory) {
        if (a > b && b > c) {
            return "a é o maior valor";
        } else if (b > a && b > c) {
            return "b é o maior valor";
        } else {
            return "c é o maior valor ou os valores são iguais";
        }
    }
}

Nesta função, usamos operadores relacionais para comparar três valores (a, b e c) e determinar qual deles é o maior.

Conclusão

Em resumo, os operadores relacionais em Solidity permitem que você faça comparações entre valores e controle o fluxo do seu programa com base nessas comparações. Entender como usar esses operadores de forma eficaz é crucial para desenvolver contratos inteligentes robustos. À medida que você trabalha em contratos mais complexos, descobrirá que combinar operadores relacionais com outras lógicas pode criar processos de tomada de decisão poderosos em seu código.

Video

Navigation