miércoles 11 diciembre 2024

Tipos de Variables en Solidity

En Solidity, las variables se utilizan para almacenar datos dentro de un contrato inteligente. Existen varios tipos de variables, cada una diseñada para manejar diferentes tipos de datos y con distintas características. Estas se pueden clasificar en función de su tipo y almacenamiento.

Clasificación de variables en Solidity

1. Variables por tipo de dato

a. Tipos de datos primitivos

1. Enteros (uint y int):

uint: Enteros sin signo (positivos).
int: Enteros con signo (positivos y negativos).
Tamaños disponibles: uint8, uint16, ..., uint256 (por defecto, uint es equivalente a uint256).

uint public enteroPositivo = 100;
   int public enteroConSigno = -50;

2. Booleanos (bool):

Representan valores de verdad (true o false).

bool public esVerdadero = true;

3. Direcciones (address):

Representan direcciones de cuentas en la blockchain.

address public propietario = 0x1234567890123456789012345678901234567890;

4. Cadenas de texto (string):

Almacenan texto.

string public saludo = "Hola, Blockchain!";

5. Bytes (bytes):

Datos binarios de longitud fija o variable.
bytes: longitud dinámica.
bytes1, bytes2, ..., bytes32: longitud fija.

bytes public datosDinamicos = "Hola";
   bytes32 public datosFijos = "Blockchain";

b. Tipos de datos complejos

1. Arrays:

Colecciones de datos del mismo tipo.
Pueden ser estáticos (tamaño fijo) o dinámicos.

uint[] public numerosDinamicos;
   uint[5] public numerosFijos = [1, 2, 3, 4, 5];

2. Structs:

Estructuras personalizadas que agrupan diferentes tipos de datos.

struct Usuario {
       uint id;
       string nombre;
   }
   Usuario public usuario = Usuario(1, "Alice");

3. Mappings:

Estructuras de datos que relacionan pares clave-valor.

mapping(address => uint) public balances;

2. Variables por alcance

1. Variables de estado:

Persisten en la blockchain.
Almacenadas en storage.
Declaradas fuera de las funciones.

uint public contador;

2. Variables locales:

Declaradas dentro de funciones.
Solo existen durante la ejecución de la función.
Almacenadas en memory.

function sumar(uint a, uint b) public pure returns (uint) {
       uint resultado = a + b;
       return resultado;
   }

3. Variables globales:

Propiedades predefinidas del entorno de ejecución, como msg.sender o block.timestamp.

address public remitente = msg.sender;
   uint public tiempo = block.timestamp;

3. Variables por ubicación de almacenamiento

1. storage:

Ubicación de las variables de estado (persisten en la blockchain).
Costoso en términos de gas.

uint[] public numeros;

2. memory:

Almacenamiento temporal para variables dentro de funciones.
Más barato que storage.

function obtenerDoble(uint[] memory numeros) public pure returns (uint[] memory) {
       for (uint i = 0; i < numeros.length; i++) {
           numeros[i] *= 2;
       }
       return numeros;
   }

3. calldata:

Para parámetros de solo lectura en funciones externas.
Más eficiente que memory.

function concatenar(string calldata a, string calldata b) external pure returns (string memory) {
       return string(abi.encodePacked(a, b));
   }

4. stack:

Usado para variables temporales y pequeñas.
Automáticamente gestionado por la EVM.

4. Variables constantes e inmutables

1. Constantes (constant):

Valores conocidos en tiempo de compilación.
Más eficientes en términos de gas.

uint public constant TASA = 100;

2. Inmutables (immutable):

Asignadas en el constructor y no pueden ser modificadas después.

address public immutable propietario;

   constructor(address _propietario) {
       propietario = _propietario;
   }

Ejemplo avanzado

pragma solidity ^0.8.0;

contract TiposVariables {
    // Variables de estado
    uint public contador;
    address public propietario;
    uint[] public numeros;

    // Constructor para inicializar variables
    constructor(uint _contadorInicial) {
        contador = _contadorInicial;
        propietario = msg.sender;
    }

    // Función para manejar variables locales
    function sumar(uint a, uint b) public pure returns (uint) {
        uint resultado = a + b; // Variable local
        return resultado;
    }

    // Función que utiliza `calldata` y `memory`
    function procesarTexto(string calldata entrada) public pure returns (string memory) {
        return string(abi.encodePacked("Hola, ", entrada));
    }
}

Buenas prácticas

1. Usa el tipo adecuado:

Selecciona tipos de datos y ubicaciones óptimos para ahorrar gas.

2. Documenta las variables:

Describe claramente el propósito de cada variable.

3. Usa constantes e inmutables siempre que sea posible:

Reducen costos de gas y aumentan la seguridad.

Referencias oficiales

Para más detalles sobre los tipos de variables en Solidity, consulta la documentación oficial de Solidity.

Etiquetas:

solidity

Creado por:

Jorge García

Fullstack developer