Las estructuras en Golang son una de las más utilizadas y una forma de crear tipos definidos por el usuario.
En esto, cubriré todos los conceptos básicos sobre las estructuras y cómo usarlas en sus programas go con un par de ejemplos.
¡Empecemos!
Tabla de contenido
Introducción
A estructura es una colección de múltiples campos de datos con sus tipos de datos definidos agrupados. Son útiles para agrupar datos para formar registros personalizados. Una estructura consta de tipos integrados y definidos por el usuario (la estructura en sí es un tipo definido por el usuario).
Las estructuras en Golang son mutables, es decir, se pueden modificar a lo largo del programa.
Las estructuras ayudan a mejorar la calidad general del código al permitirnos crear y pasar estructuras de datos complejas a través de múltiples módulos. Imagine pasar 10 parámetros a una función, pronto se escapará del código. Esta es exactamente la razón por la que las estructuras son útiles, ahora en lugar de 10 parámetros, simplemente pasa una sola estructura a esa función.
Una estructura se declara usando dos palabras clave: escribe y estructura. Está entre corchetes (al igual que las clases en Java), que contiene un conjunto de campos que tienen un tipo definido y un identificador (nombre). Discutimos los detalles de implementación en la siguiente sección.
Si proviene de un entorno de Programación orientada a objetos (OOP), puede pensar en struct como una clase pero sin herencia.
Declaración de estructuras
Ahora que comprende qué es una estructura y por qué se usa, es hora de aprender a declarar estructuras. El esqueleto básico de una estructura se parece a:
type name_of_struct struct {
field1 data_type_field1
field2 data_type_field2
}
Aquí, type y struct son palabras clave, mientras que struct contiene varios campos con su tipo de datos definido.
Veamos un ejemplo –
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
var user User
fmt.Println(user)
}
Aquí, definimos una estructura de usuario que consta de campos string, int y float32. ¡En el main() declaramos nuestra estructura como usuario y la imprimimos! ¡El resultado que obtenemos es un valor cero/vacío de estructura ya que aún no lo hemos inicializado! los valor cero es básicamente cero valores de cada campo.
{ 0 0}
Inicializando estructuras
En la sección anterior, aprendimos cómo declarar estructuras. Ahora, nos gustaría inicializarlos o asignarles valores. Verifique el código a continuación sobre cómo lo hacemos:
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
// With field names
user1 := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
}
// Without field names
user2 := User{"Nidhi", 21, 1000.0}
fmt.Println(user1)
fmt.Println(user2)
}
El código mismo explica cómo inicializamos dos estructuras con y sin nombres de campo. Aquí, la salida será:
{Mohit 24 100}
{Nidhi 21 1000}
En el caso anterior, si uno de los campos no se inicializa, entonces ese campo tiene por defecto su valor cero.
user1 := User{
name: "Mohit",
age: 24,
}
// Output - { Mohit 24 0.0 }
Hay una forma más de crear estructuras usando una nueva palabra clave. Veremos cómo usarlo en la siguiente sección.
Acceso a campos de una estructura
Ahora que sabemos cómo crear e inicializar estructuras, veamos cómo acceder a los campos de una estructura. Para ello, Golang nos proporciona el operador punto. Continuando con el ejemplo anterior, accedamos a los campos de nombre y edad e imprimámoslos.
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
// With field names
user := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
}
fmt.Println(user.name)
fmt.Println(user.age)
fmt.Println(user.bankBalance)
}
Aquí, usamos struct_name.field_name para acceder a los campos en una estructura. La salida del código anterior será:
Mohit 24 100
Como se mencionó anteriormente, podemos crear estructuras con una nueva palabra clave. Veamos cómo –
user := new(User)
user.name = "Mohit"
user.age = 24
user.bankBalance = 100.0
fmt.Println(user)
// Output - &{Mohit 24 100}
La nueva palabra clave devuelve el puntero a la estructura inicializada. En Golang, no es necesario eliminar la referencia explícita del puntero, pero fmt.Println(*user) daría como resultado el mismo resultado.
Estructuras anidadas
Las estructuras en golang también pueden contener otros tipos definidos por el usuario. Entonces, una estructura puede contener otras estructuras anidadas.
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
roleDetails RoleDetails
}
type RoleDetails struct {
position string
team string
}
func main() {
roleDetailForMohit := RoleDetails{
position: "Software Engineer",
team: "Transport",
}
user := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
roleDetails: roleDetailForMohit,
}
fmt.Println(user)
}
En el código anterior, tenemos la estructura RoleDetails como parte de la estructura User. La salida será –
{Mohit 24 100 {Software Engineer Transport}}
Si desea acceder a roleDetails, puede hacerlo usando el mismo operador de punto:
usuario.roleDetails.posición
Igualdad de estructura
Dos estructuras son iguales si cada uno de los campos que tienen son iguales (tanto integrados como definidos por el usuario), pero no todos los tipos de datos son comparables. (el mapa no es comparable directamente). Veamos un ejemplo para demostrar la igualdad.
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
user1 := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
}
user2 := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
}
user3 := User{
name: "Nidhi",
age: 21,
bankBalance: 1000.0,
}
if user1 == user2 {
fmt.Println("user1 and user2 are equal")
} else {
fmt.Println("user1 and user2 are not equal")
}
if user1 == user3 {
fmt.Println("user1 and user3 are equal")
} else {
fmt.Println("user1 and user3 are not equal")
}
}
Las estructuras vacías y de valor cero son iguales. El orden de los campos no importa, básicamente, cada campo debe coincidir por igualdad. La salida para el código anterior será:
user1 and user2 are equal user1 and user3 are not equal
Conclusión
¡Impresionante!
Ahora está listo para usar estructuras en golang. Cubrimos todos los conceptos básicos, como la declaración, la inicialización y el acceso a los campos de estructura. También vimos cómo comparar dos estructuras e incluso implementamos una estructura anidada. Aquí hay algunos recursos para aprender más sobre las estructuras:
Hay mucho más que aprender acerca de las estructuras, pero es un buen comienzo por ahora. ¡Espero que hayas aprendido algo nuevo!
Seguir explorando. ¡Seguir aprendiendo!