---
title: "¿Qué es un struct en Solidity?"
description: "Aprende qué hacen los structs en Solidity, cómo funcionan y cuándo usarlos"
---

# ¿Qué es un struct en Solidity?

Existen diferentes tipos de datos básicos en [Solidity](https://www.alchemy.com/overviews/solidity) como [_uint_ \(números enteros sin signo\)](https://www.alchemy.com/overviews/solidity-uint), _bool_ y _string_, pero como desarrollador blockchain puede que necesites un tipo de dato flexible que puedas definir tú mismo. Un **struct** es un formato de estructura de datos en Solidity donde variables de diversos tipos de datos pueden agruparse en una sola variable o tipo personalizado.

Este artículo te introducirá a los structs en Solidity, mostrando qué hacen y cómo funcionan. Finalmente, explicaremos cómo usar structs para crear smart contracts más robustos.

## **¿Qué es un struct en Solidity?**

**Un struct es un formato de estructura de datos creativo en Solidity donde variables de diversos tipos de datos pueden agruparse en una sola variable o tipo personalizado.** Una vez que los tipos de datos se agrupan en un struct, el nombre del struct representa los subconjuntos de variables que contiene.

Imagina los structs como contenedores que contienen diferentes tipos de objetos, de modo que cuando mueves el contenedor, todos los elementos dentro de él también se mueven. Por lo tanto, cuando un desarrollador de Solidity declara o llama al nombre de un struct, el struct responde de acuerdo con los tipos de datos que contiene.

**A continuación un ejemplo de un struct en Solidity:**

El ejemplo de struct anterior contiene variables para address creator, string name, address users, y uint amount.

## **Ejemplos de código de structs en Solidity**

Esta sección te mostrará ejemplos de código para definir y crear structs en Solidity. También demostraremos las dos opciones disponibles para la declaración de structs. Finalmente, te mostraremos cómo importar e inicializar structs.

### **Cómo definir y crear un struct en Solidity**

El código de un struct es similar a cómo funciona la declaración de objetos en Javascript. Aunque el parecido es notable, las sintaxis funcionan de manera diferente. Un struct en Solidity siempre sigue el siguiente formato:

**Así se define y crea un struct en Solidity:**

1. Crea un struct escribiendo la **palabra clave struct**, que le indica a [el compilador de Solidity](https://www.alchemy.com/overviews/solidity-compiler) que el tipo que sigue es un tipo personalizado
1. Nombra el struct, el cual será correferencial a las variables agrupadas dentro del struct
1. Usa llaves, porque cualquier otra forma de paréntesis, como corchetes o paréntesis redondos, no compilará

Si no usas llaves, generarás este mensaje de **ParserError** en Remix.

<ImageBlock
  src="https://media.alchemy.com/1704181525-parsererror-message.png"
  alt="Mensaje de ParserError del compilador de Remix al no usar llaves en structs."
  width={809}
  height={185}
  caption="Mensaje de ParserError del compilador de Remix al no usar llaves en structs."
/>

      4. Declara tus tipos de datos junto con sus variables correspondientes

En el ejemplo anterior, estos eran string theWord, uint theFigure, y bool polarData. Aquí es donde declaras los subconjuntos de tus structs. Después de que el struct se declara en el smart contract, podemos llamar al nombre del struct más adelante en el código.

#### **Consejos para desarrolladores:**

- Usa solo llaves
- Termina cada miembro de un struct con un punto y coma
- Solidity generará un error si declaras un tipo de dato e ingresas una variable que no corresponde a esa clase
- Los smart contracts pueden contener múltiples structs, que se diferencian por su palabra clave

### Cómo declarar un struct en Solidity

Hay dos lugares donde puedes declarar structs: **dentro de un contrato o fuera de un contrato**. Saber dónde declarar tus structs de Solidity depende de lo que quieras hacer. Veamos las dos opciones de declaración de structs.

#### **Declarar un struct fuera de un contrato**

En el ejemplo anterior, el struct _floorOverlay_ se declaró fuera del [smart contract](https://www.alchemy.com/overviews/solidity-smart-contract), y todos los contratos en la base de código pueden llamarlo. Es mejor declarar un struct fuera de un smart contract para crear un struct más aplicable a todos tus contratos, en contraste con contratos individuales que pueden tener structs específicos solo para ellos.

Además, si quieres que los smart contracts accedan a la misma colección de structs, decláralo justo después de _pragma_ en lugar de crear structs en cada smart contract por separado.

#### **Declarar un struct dentro de un contrato**

El struct _carpet_ está dentro del smart contract y, como resultado, la funcionalidad del struct está restringida al contrato actual. Ningún otro contrato puede llamar a su nombre.

### Cómo importar un struct en Solidity

Los structs pueden importarse de un smart contract a otro, lo cual ayuda a los desarrolladores a ahorrar tiempo y crear código reutilizable. Para demostrar cómo importar un struct, a continuación hay dos smart contracts: uno donde se creó el struct, y otro donde se importará.

Hay un error que debes evitar al importar: el nombre del segundo contrato debe ser el nombre del struct que quieres importar. De lo contrario, los compiladores de Solidity no podrán identificarlo, lo que resultará en un bug.

### **Cómo inicializar un struct en Solidity**

Aunque hayas declarado y creado tu struct, no podrás usarlo en [varias funciones de Solidity](https://www.alchemy.com/overviews/solidity-modifier) sin asignarle un valor inicial determinado. Hay 3 formas de inicializar structs: \(i\) el método de pares clave-valor, \(ii\) el método de definir y actualizar, \(iii\) poner entre paréntesis los parámetros.

#### **1. El método de pares clave-valor**

En este método, tomarás cada tipo de clave en el struct y le asignarás valores.

La sintaxis de este método no es estricta; puedes optar por no seguir el orden de los tipos en el struct.

#### **2. El método de definir y actualizar**

La sintaxis de este método de inicialización es tal que primero debes ingresar una variable para almacenar el struct, después de lo cual usarás la variable para acceder y nombrar cada miembro del struct. El siguiente código es una ilustración:

Sin embargo, ten en cuenta que la mayoría de los desarrolladores no usan este método porque es más largo.

#### **3. Poner entre paréntesis los parámetros**

Si quieres usar este método, tendrás que llamar al nombre del struct, almacenar su memoria y asignar valores a los miembros del struct en orden secuencial. Aquí hay un ejemplo:

Aquí, "measles" es la variable que almacena esta inicialización, y también declaramos los parámetros tal como se establecen en el struct. Recuerda siempre poner el nombre de la declaración entre paréntesis dentro de un apóstrofe para que los compiladores de Solidity puedan identificarlo.

## **Casos de uso de structs en Solidity**

Esta sección demuestra un caso de uso de Solidity para rastrear información de usuarios dentro de un contrato. Los structs se mapean dentro de este caso de uso.

### **¿Se pueden mapear structs en Solidity?**

**Los structs pueden mapearse en Solidity como tipos de valor, de modo que puedas rastrear piezas de información sobre cualquier miembro de tu struct.** Observa el siguiente código, por ejemplo:

En este contrato, los detalles de cada miembro de un DAO en particular están categorizados. Creamos dos mappings aquí: uno simple, mientras que el otro es anidado.

En el mapping simple, mapeamos la dirección de cada miembro dentro del struct para facilitar la ubicación de un miembro en particular. Además, un [mapping anidado](https://www.alchemy.com/overviews/solidity-mapping) facilitará el rastreo de las direcciones de los miembros del DAO y si han votado o no.

Debido a que el mapping siempre sigue la sintaxis key type =&gt; value type, los structs siempre deben declararse como un tipo de valor, y no como un tipo de clave. De lo contrario, recibirás un error.

<ImageBlock
  src="https://media.alchemy.com/1704181857-remix-error.png"
  alt="Error de Remix que muestra lo que pasaría si intentaras declarar un struct como key type."
  width={935}
  height={160}
  caption="Error de Remix que muestra lo que pasaría si intentaras declarar un struct como key type."
/>

## **Resumen — ¿cuál es la esencia de los structs en Solidity?**

Los structs en Solidity permiten a los desarrolladores crear tipos personalizados que se adaptan a lo que están construyendo. Los tipos personalizados son similares a contenedores que albergan otros tipos de datos relacionados dentro de ellos. Para aprender más sobre structs, ¡inscríbete en [el bootcamp de Solidity de Alchemy University](https://www.alchemy.com/university/courses/solidity?a=53bceeeaa3)!
