Punto del Curso de Solidity: 4. Control de Flujo

En Solidity, el control de flujo nos permite determinar cómo se ejecutan las instrucciones en nuestro contrato inteligente. Esto incluye estructuras de control como condicionales, bucles y las sentencias de transferencia y parada. A continuación, vamos a desentrañar cada una de estas estructuras con ejemplos clave.

Condicionales

Las declaraciones condicionales nos permiten ejecutar código de manera selectiva basado en ciertas condiciones. En Solidity, utilizamos las estructuras if, else if y else para las condiciones.

Ejemplo

    // Contrato demostrando el uso de condiciones
    pragma solidity ^0.8.0

    contract Condicionales {
        function evaluarNumero(uint _numero) public pure returns (string memory) {
            if (_numero > 10) {
                return Mayor que 10
            } else if (_numero == 10) {
                return Igual a 10
            } else {
                return Menor que 10
            }
        }
    }
    

En este contrato, la función evaluarNumero devuelve diferentes mensajes basados en el valor del argumento _numero.

Bucles

Solidity también permite utilizar bucles for, while y do while. Sin embargo, es importante ser cauteloso al usar bucles en contratos inteligentes debido al límite de gas.

Ejemplo con Bucle for

    // Contrato demostrando el uso de bucles
    pragma solidity ^0.8.0

    contract Bucles {
        function sumarNumeros(uint _tope) public pure returns (uint) {
            uint suma = 0
            for (uint i = 0 i <= _tope i  ) {
                suma  = i
            }
            return suma
        }
    }
    

En este ejemplo, la función sumarNumeros suma todos los números desde 0 hasta _tope y devuelve el resultado.

Ejemplo con Bucle while

    // Contrato demostrando el uso de bucles
    pragma solidity ^0.8.0

    contract Bucles {
        function contarHasta(uint _tope) public pure returns (uint) {
            uint contador = 0
            uint i = 0
            while (i < _tope) {
                contador  
                i  
            }
            return contador
        }
    }
    

Aquí, la función contarHasta cuenta cuántas veces se ejecuta el bucle hasta alcanzar el valor de _tope.

Transferencia y Parada de Ejecución

Solidity también proporciona palabras clave para transferencias y para detener la ejecución del contrato, como return, break, continue, require, assert y revert.

Ejemplo de require y revert

El uso de require y revert es fundamental para la validación de entradas y el manejo de errores.

    // Contrato demostrando el uso de require y revert
    pragma solidity ^0.8.0

    contract Validaciones {
        function dividir(uint _numerador, uint _denominador) public pure returns (uint) {
            require(_denominador != 0, Denominador no puede ser cero)
            return _numerador / _denominador
        }
        
        function dividirYRevertir(uint _numerador, uint _denominador) public pure returns (uint) {
            if (_denominador == 0) {
                revert(Denominador no puede ser cero)
            }
            return _numerador / _denominador
        }
    }
    

Aquí, las funciones dividir y dividirYRevertir validan que el denominador no sea cero antes de realizar la división.

Ejemplo de assert

    // Contrato demostrando el uso de assert
    pragma solidity ^0.8.0

    contract Afirmaciones {
        function verificarValor(uint _valor) public pure {
            assert(_valor != 0) // Aseguramos que el valor no es cero
        }
    }
    

En este ejemplo, la función verificarValor usa assert para asegurarse de que el valor proporcionado no sea cero.

Conclusión

El control de flujo en Solidity es esencial para construir contratos inteligentes robustos y seguros. La comprensión de estas estructuras y su uso apropiado puede ayudarnos a manejar de manera eficiente las condiciones y el control en nuestros contratos inteligentes.

Anterior...Siguiente

[mwai_chat]