- Las estructuras de Golang nos permiten agrupar datos.
- Son similares a estructuras de otros lenguajes de programación.
- Las estructuras son tipos de datos definidos por el usuario y le permiten crear sus propios tipos personalizados.
- Las estructuras pueden contener cualquier tipo de datos, incluidas otras estructuras.
Definición de estructura:
```ir
escriba nombre_estructura estructura {
nombre_miembro tipo1
nombre_miembro tipo2
...
nombre_miembro tipoN
}
```
- Esto define una estructura llamada `nombre_estructura` con miembros `nombre_miembro`. Cada miembro tiene un tipo, que puede ser cualquier tipo de Go válido.
Creación de estructuras:
```ir
var nombre_estructura =tipo_estructura {
nombre_miembro1:valor1,
nombre_miembro2:valor2,
...
nombre_miembroN:valorN
}
```
- Esto crea una variable de tipo `estructura_nombre` e inicializa sus miembros con los valores dados.
Acceso a miembros:
- Para acceder a un miembro de la estructura, utilice el operador de punto:`nombre_estructura.nombre_miembro`.
Ejemplo:
```ir
// Definir una estructura llamada persona con nombre y edad de los miembros.
escriba persona estructura {
Cadena de nombre
edad int
}
función principal() {
// Crea una persona llamada "John Doe".
persona1 :=persona{"John Doe", 30}
// Imprime el nombre y la edad de John.
fmt.Println("Nombre:", persona1.Nombre)
fmt.Println("Edad:", persona1.Edad)
}
```
Estructuras nombradas:
- Si una estructura contiene campos de tipos de datos básicos, entonces se puede declarar sin una palabra clave de estructura.
```ir
escriba la estructura MyStruct {
un entero
b flotador32
cuerda c
}
escribe tu estructura {
f int 'json:"primero"'
l cadena 'json:"último"'
}
```
- Tanto para `MyStruct` como para `your struct` anteriores, la palabra clave struct es opcional
Estructuras anónimas
- Se pueden utilizar estructuras anónimas para crear tipos de datos ad-hoc sin definir explícitamente un tipo de estructura.
- Cuando una estructura anónima se utiliza como campo de otra estructura o como elemento de un segmento/mapa, el tipo de campo es la estructura anónima y la etiqueta del campo es el nombre del tipo.
```ir
escriba estructura de persona {
cadena de nombre
edad int
}
```
- Alternativamente, se pueden usar estructuras anónimas para crear instancias de una estructura sin definir un tipo de estructura.
```ir
var persona =estructura {
cadena de nombre
edad int
}{nombre:"Bob", edad:20}
```
- En este caso, la variable persona de tipo `struct{ nombre cadena; age int }` se crea e inicializa.
Estructuras de incrustación
- Incrustar una estructura en otra estructura permite una forma de herencia en Go.
```ir
escriba estructura de persona {
cadena de nombre
edad int
}
escriba estructura de empleado {
salario int
Persona
}
```
- Aquí `Empleado` incorpora `Persona`, por lo que una variable `Empleado` incluirá los campos de `Persona` (nombre y edad), así como sus propios campos.
```ir
emp :=Empleado{salario:100000, Persona:Persona{nombre:"John", edad:30}}
fmt.Println(emp.salario) // 100000
fmt.Println(emp.nombre) // Juan
```
- Los campos de la estructura incrustada se promueven a la estructura externa (contenedora) como si estuvieran declarados en la estructura contenedora. Aquí, ahora se puede acceder a los campos `nombre` y `edad` de `Persona` en la variable `Empleado` (`emp`).
Etiquetas en Estructuras
- Se pueden adjuntar etiquetas a los campos de la estructura para proporcionar información adicional. Estas etiquetas son utilizadas por reflexión y codificadores/decodificadores.
```ir
tipo Persona estructura {
cadena de nombre `json:"nombre"` // etiqueta json
edad int `xml:"edad"` // etiqueta xml
}
```
- Las etiquetas se escriben entre comillas graves ("`") si contienen espacios u otros caracteres especiales.
Conclusión
- Las estructuras proporcionan una forma de agrupar datos relacionados y crear tipos de datos personalizados en Go.
- Se pueden utilizar estructuras nombradas y anónimas dependiendo de la situación, y la incrustación permite una forma de herencia.
- Se pueden adjuntar etiquetas a los campos de la estructura para obtener metadatos adicionales y compatibilidad con bibliotecas estándar.