Solidez – Operadores

En cualquier lenguaje de programación, los operadores juegan un papel vital, es decir, crean una base para la programación. Del mismo modo, la funcionalidad de Solidity también está incompleta sin el uso de operadores. Los operadores permiten a los usuarios realizar diferentes operaciones en los operandos. Solidity admite los siguientes tipos de operadores en función de su funcionalidad.

1. Operadores aritméticos
2. Operadores relacionales
3. Operadores logicos
4. Operadores bit a bit
5. Operadores de Asignación
6. Operador Condicional

Operadores aritméticos

Estos operadores se utilizan para realizar operaciones aritméticas o matemáticas. Solidity admite los siguientes operadores aritméticos: 

Ejemplo: En el siguiente ejemplo, el contrato SolidityTest demuestra los diferentes tipos de operadores aritméticos mencionados anteriormente.

// Solidity contract to demonstrate
// Arithmetic Operator
pragma solidity ^0.5.0;
 
// Creating a contract
contract SolidityTest {
 
    // Initializing variables
    uint16 public a = 20;
    uint16 public b = 10;
 
    // Initializing a variable
    // with sum
    uint public sum = a + b;
 
    // Initializing a variable
    // with the difference
    uint public diff = a - b;
 
    // Initializing a variable
    // with product
    uint public mul = a * b;
 
    // Initializing a variable
    // with quotient
    uint public div = a / b;
 
    // Initializing a variable
    // with modulus
    uint public mod = a % b;
 
    // Initializing a variable
    // decrement value
    uint public dec = --b;
 
    // Initializing a variable
    // with increment value
    uint public inc = ++a;
     
}

Producción :  

Operadores relacionales

Estos operadores se utilizan para comparar dos valores. Solidity admite los siguientes operadores relacionales:  

Ejemplo: En el siguiente ejemplo, el contrato SolidityTest demuestra los diferentes tipos de operadores relacionales mencionados anteriormente. 

// Solidity program to demonstrate
// Relational Operator
pragma solidity ^0.5.0;
 
// Creating a contract
contract SolidityTest {
 
    // Declaring variables
    uint16 public a = 20;
    uint16 public b = 10;
 
    // Initializing a variable
    // with bool equal result
    bool public eq = a == b;
 
    // Initializing a variable
    // with bool not equal result
    bool public noteq = a != b;
    
    // Initializing a variable
    // with bool greater than result
    bool public gtr = a > b;
 
    // Initializing a variable
    // with bool less than result
    bool public les = a < b;
 
    // Initializing a variable
    // with bool greater than equal to result
    bool public gtreq = a >= b;
 
    // Initializing a variable
    // bool less than equal to result
    bool public leseq = a <= b;
     
}

Producción :  

Operadores logicos

Estos operadores se utilizan para combinar dos o más condiciones. Solidity admite los siguientes operadores aritméticos:  

Ejemplo: En el siguiente ejemplo, el contrato logicalOperator demuestra los diferentes tipos de operadores lógicos mencionados anteriormente. 

// Solidity program to demonstrate
// Logical Operators
pragma solidity ^0.5.0;
 
// Creating a contract
contract logicalOperator{
 
     // Defining function to demonstrate
     // Logical operator
     function Logic(
       bool a, bool b) public view returns(
       bool, bool, bool){
        
       // Logical AND operator 
       bool and = a&&b;
        
       // Logical OR operator 
       bool or = a||b;
        
       // Logical NOT operator
       bool not = !a;
       return (and, or, not);
 }
}

Producción : 

Operadores bit a bit

Estos operadores funcionan a un nivel de bit utilizado para realizar operaciones a nivel de bit. Solidity admite los siguientes operadores aritméticos:

Ejemplo: En el siguiente ejemplo, el contrato SolidityTest demuestra los diferentes tipos de operadores bit a bit mencionados anteriormente.

// Solidity program to demonstrate
// Bitwise Operator
pragma solidity ^0.5.0;
 
// Creating a contract
contract SolidityTest {
 
    // Declaring variables
    uint16 public a = 20;
    uint16 public b = 10;
 
    // Initializing a variable
    // to '&' value
    uint16 public and = a & b;
 
    // Initializing a variable
    // to '|' value
    uint16 public or = a | b;
 
    // Initializing a variable
    // to '^' value
    uint16 public xor = a ^ b;
 
    // Initializing a variable
    // to '<<' value
    uint16 public leftshift = a << b;
 
    // Initializing a variable
    // to '>>' value
    uint16 public rightshift = a >> b;
   
    // Initializing a variable
    // to '~' value
    uint16 public not = ~a ;
     
}

Producción : 

Operador de asignación

Estos operadores son para la asignación de valor a una variable. El operando del lado izquierdo es variable mientras que el operando del lado derecho es el valor. Solidity admite los siguientes operadores aritméticos: 

Ejemplo: En el siguiente ejemplo, el contrato SolidityTest demuestra los diferentes tipos de operadores de asignación mencionados anteriormente.

// Solidity program to demonstrate
// Assignment Operator
pragma solidity ^0.5.0;
 
// Creating a contract
contract SolidityTest {
 
        // Declaring variables
        uint16 public assignment = 20;
        uint public assignment_add = 50;
        uint public assign_sub = 50;
        uint public assign_mul = 10;
        uint public assign_div = 50;
        uint public assign_mod = 32;
     
        // Defining function to
        // demonstrate Assignment Operator
        function getResult() public{
           assignment_add += 10;
           assign_sub -= 20;
           assign_mul *= 10;
           assign_div /= 10;
           assign_mod %= 20;
           return ;
        }
}

Producción : 

Operadores Condicionales

Es un operador ternario que primero evalúa la expresión y luego verifica la condición para los valores de retorno correspondientes a verdadero o falso. 

Sintaxis: 

if condition true ? then A: else B

Ejemplo: En el siguiente ejemplo, el contrato SolidityTest demuestra el operador condicional. 

// Solidity program to demonstrate
// Conditional Operator
pragma solidity ^0.5.0;
 
// Creating a contract
contract SolidityTest{
 
     // Defining function to demonstrate
     // conditional operator
     function sub(
       uint a, uint b) public view returns(
       uint){
      uint result = (a > b? a-b : b-a);
      return result;
 }
}

Producción :