Volver a la página principal
martes 10 diciembre 2024
6

Cómo usar constructores (constructor) en Solidity para inicializar variables al desplegar el contrato

Un constructor es una función declarada con la palabra clave constructor y no tiene un nombre específico. Su ejecución ocurre automáticamente durante el despliegue del contrato y no puede ser llamada nuevamente después de ese momento.

Características principales:

  • Solo puede haber un constructor por contrato.
  • No se puede sobrescribir ni heredar.
  • Puede aceptar parámetros para personalizar la inicialización del contrato.
  • No devuelve valores.

Declaración básica 

constructor(tipo parametro1, tipo parametro2, ...) {
    // Lógica de inicialización
}

Ejemplo básico de constructor 

pragma solidity ^0.8.0;

contract EjemploConstructor {
    string public mensaje;

    // Constructor que inicializa el mensaje
    constructor(string memory _mensajeInicial) {
        mensaje = _mensajeInicial;
    }
}

En este ejemplo:

  • Al desplegar el contrato, se debe proporcionar un mensaje inicial.
  • Este mensaje se almacena en la variable de estado mensaje.

Uso de constructores con parámetros

Los constructores son ideales para configurar contratos con datos personalizados al desplegarlos.

Ejemplo con parámetros 

contract Billetera {
    address public propietario;

    // Constructor que inicializa al propietario
    constructor(address _propietario) {
        propietario = _propietario;
    }

    // Función para consultar si una dirección es el propietario
    function esPropietario() public view returns (bool) {
        return msg.sender == propietario;
    }
}

En este contrato:

  • El constructor establece la dirección del propietario al desplegar el contrato.
  • La función esPropietario verifica si el llamador es el propietario.

Constructores en contratos heredados

Cuando un contrato hereda de otro que tiene un constructor, el contrato derivado debe invocar explícitamente el constructor del contrato base.

Ejemplo de herencia con constructores 

contract Base {
    uint public valor;

    constructor(uint _valor) {
        valor = _valor;
    }
}

contract Derivado is Base {
    string public mensaje;

    // Constructor del contrato derivado
    constructor(uint _valor, string memory _mensaje) Base(_valor) {
        mensaje = _mensaje;
    }
}

En este ejemplo:

  • El contrato Derivado hereda de Base.
  • El constructor de Derivado llama al constructor de Base utilizando Base(_valor).

Inicialización de valores constantes o inmutables

Los constructores son útiles para inicializar variables inmutables, que solo pueden asignarse una vez y no se pueden cambiar después de la implementación.

Ejemplo con immutable 

contract EjemploInmutable {
    address public immutable propietario;

    // Inicialización de una variable inmutable
    constructor() {
        propietario = msg.sender;
    }

    // Función que solo el propietario puede llamar
    function accionDelPropietario() public view returns (string memory) {
        require(msg.sender == propietario, "No eres el propietario");
        return "Acción permitida";
    }
}

Consideraciones al usar constructores

1. Parámetros obligatorios: Si el constructor tiene parámetros, deben proporcionarse al desplegar el contrato.

2. Gas del constructor: La lógica dentro del constructor consume gas y afecta el costo de despliegue.

3. Uso de immutable: Las variables inicializadas en el constructor como immutable son más eficientes en términos de gas.

Ventajas de los constructores

1. Inicialización personalizada: Permite configurar el contrato al momento de su despliegue.

2. Seguridad: Establece valores iniciales esenciales para el funcionamiento seguro del contrato.

3. Reutilización: Facilita el uso de contratos parametrizados en diferentes contextos.

Ejemplo avanzado: Contrato parametrizado

Un contrato que utiliza el constructor para inicializar múltiples valores. 

contract ContratoComplejo {
    address public propietario;
    uint public tasaInteres;
    string public nombreContrato;

    // Constructor que inicializa múltiples valores
    constructor(address _propietario, uint _tasaInteres, string memory _nombreContrato) {
        propietario = _propietario;
        tasaInteres = _tasaInteres;
        nombreContrato = _nombreContrato;
    }

    // Función que solo el propietario puede usar
    function cambiarTasa(uint _nuevaTasa) public {
        require(msg.sender == propietario, "No autorizado");
        tasaInteres = _nuevaTasa;
    }
}

En este ejemplo:

  • Se establecen valores iniciales para el propietario, la tasa de interés y el nombre del contrato.
  • La lógica del contrato utiliza estos valores configurados al momento del despliegue.

Referencias oficiales

Para más información sobre constructores, consulta la documentación oficial de Solidity.

Etiquetas:
solidity
Compartir:
Creado por:
Author photo

Jorge García

Fullstack developer