0Pricing
Blockchain Smart Contracts with Solidity · Lección

Tipos de datos y variables en Solidity

Aprenda sobre los tipos por valor, los tipos por referencia y cómo declarar e inicializar variables en Solidity.

Tipos de datos y variables en Solidity es una lección gratuita de Blockchain Smart Contracts with Solidity en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Blockchain Smart Contracts with Solidity, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Blockchain Smart Contracts with Solidity incluye 4 lecciones en total.

Data Types: The Basics

¡Bienvenido a Solidity! Al igual que en cualquier lenguaje de programación, comprender los tipos de datos es fundamental. Los tipos de datos le indican a Solidity qué tipo de información contendrá una variable. Esto ayuda a la Máquina Virtual de Ethereum (EVM) a gestionar la memoria de manera eficiente y a prevenir errores comunes.

Value Types Explained

Los tipos de valor son los tipos de datos más sencillos. Cuando asignas una variable de tipo valor o la pasas a una función, se realiza una copia de sus datos.

Piénsalo como darle a alguien una foto: ellos obtienen su propia copia, y los cambios en su copia no afectan a la tuya. Se almacenan directamente en la ubicación de la variable.

Booleans and Integers

Empecemos con los tipos de valor comunes:

  • bool: Contiene true o false.
  • uint: Enteros sin signo (números no negativos). uint256 o simplemente uint es el valor predeterminado.
  • int: Enteros con signo (números positivos o negativos). int256 o int es el valor predeterminado.

Intenta ejecutar este contrato simple para verlos en acción:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract MyNumbers {
  bool public isActive = true;
  uint public quantity = 100;
  int public temperature = -5;

  function getStatus() public view returns (bool) {
    return isActive;
  }

  function getQuantity() public view returns (uint) {
    return quantity;
  }

  function getTemperature() public view returns (int) {
    return temperature;
  }
}

The Address Type

El tipo address es crucial en Solidity. Es un valor de 20 bytes que representa una cuenta de Ethereum o un contrato en la cadena de bloques.
  • address: Puede contener cualquier dirección de Ethereum.
  • address payable: También puede contener una dirección de Ethereum, pero específicamente una que puede recibir Ether.
Aquí se muestra cómo podrías almacenar la dirección del propietario de un contrato:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleWallet {
  address public owner;

  constructor() {
    owner = msg.sender; // The address that deployed this contract
  }

  function getOwner() public view returns (address) {
    return owner;
  }
}

Fixed-Size Byte Arrays

Solidity también tiene arrays de bytes de tamaño fijo: bytes1 hasta bytes32. Estos son útiles para almacenar secuencias cortas de bytes brutos de longitud fija, como hashes criptográficos o identificadores cortos. Son más eficientes que los arrays dinámicos para tamaños conocidos.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract DataStore {
  bytes32 public documentHash;

  constructor() {
    // Example: A hash of some document content
    documentHash = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef;
  }

  function getDocumentHash() public view returns (bytes32) {
    return documentHash;
  }
}

Reference Types Explained

A diferencia de los tipos de valor, los tipos de referencia no almacenan los datos directamente. En su lugar, almacenan una referencia (una dirección de memoria) a donde se encuentran los datos. Esto significa que si asignas una variable de tipo de referencia, ambas variables apuntan a los mismos datos. Los cambios realizados a través de una variable serán visibles a través de la otra.

Strings for Text

El tipo string se utiliza para datos de texto. Es un array dinámico de bytes que almacena caracteres codificados en UTF-8. Debido a que su tamaño puede cambiar, string se considera un tipo de referencia. A menudo verá memory o calldata utilizados con cadenas en parámetros de función o tipos de retorno.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Greeter {
  string public currentMessage = "Hello, CoddyKit!";

  function setMessage(string memory _newMessage) public {
    currentMessage = _newMessage;
  }

  function getMessage() public view returns (string memory) {
    return currentMessage;
  }
}

Dynamic Bytes and Arrays

Solidity ofrece estructuras de datos dinámicas:

  • bytes: Una matriz de bytes de tamaño dinámico. Similar a string pero para datos de bytes sin procesar.
  • Matrices (T[] o T[k]): Pueden contener una secuencia de elementos del mismo tipo T. Pueden ser de tamaño fijo (T[k], donde k es la longitud) o dinámicas (T[]).
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract DataCollection {
  bytes public rawData = hex"1a2b3c"; // Dynamic bytes
  uint[] public dynamicNumbers; // Dynamic array of uints
  bool[2] public fixedBooleans = [true, false]; // Fixed-size array

  constructor() {
    dynamicNumbers.push(10);
    dynamicNumbers.push(20);
  }

  function getRawData() public view returns (bytes memory) {
    return rawData;
  }

  function getDynamicNumbersCount() public view returns (uint) {
    return dynamicNumbers.length;
  }
}

Custom Data with Structs

A veces, necesitas agrupar datos relacionados. ¡Ahí es donde los structs resultan útiles!

Un struct te permite definir tu propio tipo de datos personalizado combinando varias variables de diferentes tipos. Piénsalo como crear un plano para un registro.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract UserProfile {
  struct User {
    uint id;
    address userAddress;
    string name;
    bool isActive;
  }

  User public adminUser;

  constructor() {
    adminUser = User(1, msg.sender, "Alice", true);
  }

  function getAdminName() public view returns (string memory) {
    return adminUser.name;
  }
}

Declaring & Initializing

Declarar una variable es sencillo: DataType visibilidad nombreVariable;

Si no inicializas una variable explícitamente, Solidity le asigna un valor predeterminado:

  • bool: false
  • uint/int: 0
  • address: 0x00...00 (dirección cero)
  • string/bytes/arrays: Valor vacío

Es una buena práctica inicializar las variables explícitamente cuando se declaran.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract VariableLife {
  // Declared without explicit initialization (gets default values)
  uint public defaultBalance;
  bool public defaultStatus;

  // Declared and initialized
  uint public initialBalance = 1000;
  string public greeting = "Hello";

  function getDefaults() public view returns (uint, bool) {
    return (defaultBalance, defaultStatus);
  }
}

Data Type Challenge

¡Pon a prueba tus conocimientos sobre los tipos de datos de Solidity!

Lesson Recap

¡Buen trabajo! En esta lección, has aprendido sobre los tipos de datos fundamentales en Solidity:

  • Los tipos de valor (por ejemplo, bool, uint, address, bytesX de tamaño fijo) almacenan datos directamente y se copian al asignarlos.
  • Los tipos de referencia (por ejemplo, string, bytes dinámicos, arrays, structs) almacenan una referencia a los datos, lo que permite que varias variables apunten a la misma información.
  • También aprendiste cómo declarar e inicializar variables, comprendiendo sus valores predeterminados.

¡A continuación, nos sumergiremos en cómo controlar el flujo de tus contratos inteligentes!

Preguntas frecuentes

¿La lección «Tipos de datos y variables en Solidity» es gratis?

Sí — el texto completo de «Tipos de datos y variables en Solidity» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Blockchain Smart Contracts with Solidity, actualiza a CoddyKit PRO. El curso de Blockchain Smart Contracts with Solidity incluye 4 lecciones en total.

¿Qué aprenderé en «Tipos de datos y variables en Solidity»?

Aprenda sobre los tipos por valor, los tipos por referencia y cómo declarar e inicializar variables en Solidity. Practicas Blockchain Smart Contracts with Solidity con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Blockchain Smart Contracts with Solidity?

No se requiere experiencia previa. Blockchain Smart Contracts with Solidity en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Tipos de datos y variables en Solidity»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Blockchain Smart Contracts with Solidity?

Sí. Cada lección de Blockchain Smart Contracts with Solidity incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Tipos de datos y variables en Solidity
  2. Estructuras de control y bucles
  3. Funciones y modificadores de visibilidad
  4. Structs y enums
← Volver a Blockchain Smart Contracts with Solidity