# Guía de Solidity para Principiantes


By [Yolfry](https://paragraph.com/@yolfry) · 2024-10-15

---

**Guía de Solidity para Principiantes**
---------------------------------------

### **Introducción**

En esta guía, exploraremos Solidity, el lenguaje de programación utilizado para desarrollar contratos inteligentes en la blockchain de Ethereum y otras cadenas compatibles con la EVM (Ethereum Virtual Machine).  
  
Solidity permite a los desarrolladores crear contratos seguros y escalables, optimizando los recursos de la blockchain para aplicaciones descentralizadas.  
  
En este artículo, aprenderás los conceptos básicos necesarios para comenzar a desarrollar contratos inteligentes, centrándonos en las variables, estructuras y funciones que son fundamentales para el desarrollo en Solidity.

![](https://storage.googleapis.com/papyrus_images/d866c79ba7c0da2c5253ba32c96688bdd1e5487eed7ce7da7f5a9fa71bb89110.png)

* * *

**1\. Conceptos Básicos de Solidity**
-------------------------------------

### **1.1 Versión del Compilador (**`pragma solidity`)

Uno de los primeros aspectos que debes especificar al escribir un contrato en Solidity es la versión del compilador. Esto se hace con la directiva `pragma`, que asegura que el contrato se compile correctamente con una versión específica de Solidity, evitando posibles incompatibilidades.

**Ejemplo:**

    // Especificamos que el contrato funciona con versiones de Solidity desde la 0.8.0 hasta la 0.9.0
    pragma solidity ^0.8.0;
    

### **1.2 Definición de Contratos**

En Solidity, un contrato es similar a una clase en lenguajes de programación orientados a objetos. Es la unidad básica donde se define el estado (variables) y el comportamiento (funciones) del programa.

**Ejemplo:**

    contract MiPrimerContrato {
        uint public numero;
    }
    

En este ejemplo, se define un contrato simple que contiene una variable `numero` de tipo `uint` (entero sin signo).

### **1.3 Variables y Tipos de Datos en Solidity**

Solidity ofrece varios tipos de datos primitivos y complejos que puedes utilizar en tus contratos. Aquí revisaremos algunos de los más comunes:

#### **1.3.1 Tipos Enteros (**`uint`, `int`)

*   `uint` representa enteros sin signo.
    
*   `int` representa enteros con signo.
    

**Ejemplo:**

    uint public numeroPositivo;
    int public numeroConSigno;
    

#### **1.3.2 Direcciones (**`address`)

El tipo `address` se usa para almacenar direcciones de cuentas en la blockchain.

**Ejemplo:**

    address public propietario;
    

#### **1.3.3 Booleanos (**`bool`)

El tipo `bool` se usa para almacenar valores lógicos (`true` o `false`).

**Ejemplo:**

    bool public esActivo;
    

* * *

**2\. Tipos Avanzados en Solidity**
-----------------------------------

### **2.1 Arrays**

Los arrays son colecciones de elementos del mismo tipo. Solidity soporta arrays de tamaño fijo y dinámico.

**Ejemplo:**

    uint[] public numeros; // Array dinámico
    

### **2.2 Mappings**

Un `mapping` es una estructura de datos que asocia claves con valores. Es similar a los diccionarios o mapas en otros lenguajes de programación.

**Ejemplo:**

    mapping(address => uint) public saldo;
    

Este ejemplo asocia direcciones (`address`) con números enteros (`uint`), representando un sistema de saldos.

### **2.3 Structs**

Los `structs` permiten definir tipos de datos personalizados, agrupando diferentes tipos bajo un solo nombre.

**Ejemplo:**

    struct Usuario {
        string nombre;
        uint edad;
    }
    
    Usuario public usuario;
    

* * *

**3\. Funciones en Solidity**
-----------------------------

### **3.1 Definición de Funciones**

Las funciones en Solidity permiten manipular los datos de un contrato. Se pueden definir como `public`, `private`, `internal` o `external`, lo que determina quién puede llamarlas.

#### **3.1.1 Funciones Públicas (**`public`)

Las funciones `public` pueden ser llamadas desde cualquier lugar, incluyendo fuera del contrato.

**Ejemplo:**

    function establecerNumero(uint _numero) public {
        numero = _numero;
    }
    

#### **3.1.2 Funciones Privadas (**`private`)

Las funciones `private` solo pueden ser llamadas dentro del mismo contrato.

**Ejemplo:**

    function _calcular(uint _x, uint _y) private pure returns (uint) {
        return _x + _y;
    }
    

### **3.2 Funciones** `pure` vs `view`

*   **Funciones** `pure`: No acceden al estado del contrato, lo que significa que no pueden leer ni escribir en las variables de estado.
    
*   **Funciones** `view`: Pueden leer el estado del contrato, pero no modificarlo.
    

**Ejemplo de** `pure`:

    function sumar(uint _a, uint _b) public pure returns (uint) {
        return _a + _b;
    }
    

**Ejemplo de** `view`:

    function obtenerNumero() public view returns (uint) {
        return numero;
    }
    

### **3.3 Cuándo usar** `pure`, `view`, y otras funciones

*   Usa `pure` cuando la función no necesita leer ni modificar el estado del contrato. Ideal para cálculos o funciones utilitarias.
    
*   Usa `view` cuando la función solo necesita leer el estado del contrato, sin hacer modificaciones. Es útil para consultas.
    
*   Las funciones regulares (sin `pure` ni `view`) deben usarse cuando la función va a modificar el estado del contrato (escribir en las variables de estado).
    

**Ejemplo de cuándo usar una sobre la otra:**

*   Si estás implementando una función para calcular intereses o realizar operaciones matemáticas, utiliza `pure`.
    
*   Si necesitas consultar el saldo de una cuenta o el propietario de un contrato, usa `view`.
    
*   Para cambiar el saldo de una cuenta o actualizar el estado, usa funciones regulares sin restricciones.
    

* * *

**4\. Modificadores y Control de Acceso**
-----------------------------------------

### **4.1 Modificadores**

Los modificadores permiten añadir condiciones antes de la ejecución de una función. Se usan comúnmente para verificar permisos, estados o cualquier otra condición previa.

**Ejemplo:**

    modifier soloPropietario() {
        require(msg.sender == propietario, "No eres el propietario");
        _;
    }
    

### **4.2** `msg.sender` y `msg.value`

*   `msg.sender`: Es la dirección de la cuenta que está ejecutando la transacción.
    
*   `msg.value`: Es la cantidad de ether enviada con la transacción.
    

**Ejemplo:**

    function pagar() public payable {
        require(msg.value > 0, "Debes enviar ether");
    }
    

* * *

**5\. Herencia y Contratos**
----------------------------

### **5.1 Herencia entre Contratos**

Solidity permite la herencia entre contratos, lo que facilita la reutilización de código. Un contrato puede heredar de otro, y sobreescribir o extender sus funcionalidades.

**Ejemplo:**

    contract Base {
        function saludar() public pure returns (string memory) {
            return "Hola!";
        }
    }
    
    contract Derivado is Base {
        function despedir() public pure returns (string memory) {
            return "Adiós!";
        }
    }
    

### **5.2 Uso de Bibliotecas Externas e Interfaces**

Las bibliotecas permiten agrupar funciones que pueden ser usadas por otros contratos sin necesidad de herencia. Las interfaces son útiles para interactuar con contratos externos.

**Ejemplo de una Interfaz:**

    interface ERC20 {
        function transfer(address _to, uint _value) external returns (bool);
    }
    

* * *

**6\. Manejo de Eventos**
-------------------------

### **6.1 Definir y Emitir Eventos**

Los eventos permiten registrar acciones que ocurren en la blockchain, y los usuarios o aplicaciones externas pueden suscribirse a ellos.

**Ejemplo:**

    event Transferencia(address indexed _de, address indexed _a, uint _valor);
    
    function transferir(address _a, uint _valor) public {
        emit Transferencia(msg.sender, _a, _valor);
    }
    

### **6.2 Uso de Eventos para Interacción con el Frontend**

Los eventos son clave para la interacción de contratos con aplicaciones descentralizadas (DApps), ya que permiten al frontend escuchar cambios en el estado del contrato.

* * *

**Conclusión**
--------------

Esta guía te ofrece una introducción detallada a los conceptos básicos de Solidity, desde las variables y tipos de datos hasta la estructura de funciones y la herencia de contratos. Profundizar en estos temas te permitirá desarrollar contratos más seguros, eficientes y escalables en blockchain.

En las próximas secciones abordaremos temas más avanzados, como los **Opcodes**, el funcionamiento del **EVM** y las optimizaciones de contratos inteligentes. ¡Sigue atento para continuar tu camino hacia la maestría en Solidity!

![](https://storage.googleapis.com/papyrus_images/0339e5aea3d023f54f6db0843c84a90ae87a3728ac7f9b6b7b60acae21c82fcf.webp)

---

*Originally published on [Yolfry](https://paragraph.com/@yolfry/gu-a-de-solidity-para-principiantes)*