Estructuras en Golang

Los structs en Golang son uno de los más utilizados y una forma de crear tipos definidos por el usuario

En esto, voy a estar cubriendo todos los fundamentos acerca de los structs y cómo utilizarlos en sus programas go con un par de ejemplos

¡Empecemos!

Introducción

Un struct es una colección de múltiples campos de datos con sus tipos de datos definidos agrupados. Son útiles para agrupar datos y formar registros personalizados. Un struct consta tanto de tipos incorporados como de tipos definidos por el usuario (el propio struct es un tipo definido por el usuario)

Los struct en Golang son mutables, es decir, pueden modificarse a lo largo del programa

Los struct 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 quedará sin código. Esta es exactamente la razón por la que los structs son útiles, ahora en lugar de 10 parámetros usted simplemente pasa un único struct a esa función

Un struct se declara utilizando dos palabras clave – type y struct. Se envuelve con llaves (al igual que las clases en java) – que contiene un conjunto de campos que tienen un tipo definido y un identificador (nombre). Discutiremos los detalles de implementación en la siguiente sección.

Si usted viene de una programación orientada a objetos (POO) de fondo, se puede pensar en struct como una clase, pero sin herencia

Declarar structs

Ahora que ya sabe qué es un struct y por qué se utiliza, es hora de aprender a declarar structs. El esqueleto básico de un struct tiene el siguiente aspecto

type nombre_de_la_estructura struct {
 campo1 tipo_datos_campo1
 campo2 tipo_datos_campo2
 }

Aquí, type y struct son palabras clave, mientras que struct contiene múltiples 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 User que consta de campos string, int y float32. En main () declaramos nuestra struct como user y la imprimimos ¡La salida que obtenemos es el valor cero/vacío de la struct ya que aún no la hemos inicializado! El valor cero es básicamente valores cero de cada campo

{ 0 0}

Inicializando structs

En la sección anterior, aprendimos cómo declarar structs. Ahora, queremos inicializarlos o asignarles valores. Compruebe en el código siguiente cómo lo hacemos –

package main

import (
"fmt"
)

type User struct {
name string
age int
bankBalance float32
}

func main() {
// Con los nombres de los campos
user1 := User{
name: "Mohit",
age:         24,
bankBalance: 100.0,
}
	
// Sin nombres de campo
user2 := User{"Nidhi", 21, 1000.0}
	
fmt.Println(user1)
fmt.Println(user2)

}
El propio código explica cómo inicializamos dos structs 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 toma por defecto su valor cero

usuario1 := Usuario{
nombre: "Mohit",
edad:         24,
}

 // Salida - { Mohit 24 0.0 }

Hay una forma más de crear structs utilizando la palabra clave new. Veremos cómo utilizarla en la siguiente sección

Acceso a los campos de un struct

Ahora que sabemos cómo crear e inicializar structs, veamos cómo acceder a los campos de un struct. Para ello, Golang nos proporciona el operador punto. Siguiendo con el ejemplo anterior, accedamos a los campos nombre y edad e imprimámoslos

package main

import (
"fmt"
)

type User struct {
name string
age int
bankBalance float32
}

func main() {
// Con los nombres de los campos
user := User{
name: "Mohit",
age:         24,
bankBalance: 100.0,
}

fmt.Println(user.name)
fmt.Println(user.age)
fmt.Println(user.bankBalance)

}
Aquí utilizamos struct_name.field_name para acceder a los campos de una struct. La salida del código anterior será

Mohit
 24
 100

Como se mencionó anteriormente, podemos crear structs con la palabra clave new. Veamos cómo –

user := new(Usuario)
 user.name = "Mohit"
 user.age = 24
 user.bankBalance = 100.0

 fmt.Println(user)

 // Salida - &{Mohit 24 100}

La palabra clave new devuelve el puntero a la estructura inicializada. En Golang no es necesario desreferenciar explícitamente el puntero, pero fmt .Println(*user ) daría la misma salida

Estructuras anidadas

Los struct en golang pueden contener también otros tipos definidos por el usuario. Así, un struct puede contener otros structs anidados

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: "Ingeniero de Software",
team:     "Transporte",
}
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 {Ingeniero de Software Transporte}}

Si desea acceder a roleDetails, puede hacerlo utilizando el mismo operador de punto –

user.roleDetails.position

Igualdad de estructuras

Dos structs son iguales si cada uno de los campos que tienen son iguales (tanto los incorporados como los definidos por el usuario) pero no todos los tipos de datos son comparables. (map 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 := Usuario{
nombre: "Mohit",
edad:         24,
bankBalance: 100.0,
}
user3 := Usuario{
name: "Nidhi",
age:         21,
bankBalance: 1000.0,
}

if usuario1 == usuario2 {
fmt.Println("usuario1 y usuario2 son iguales")
} else {
fmt.

Println(“usuario1 y usuario2

no son iguales")
}

if usuario1 == usuario3 {
fmt.Println("usuario1 y usuario3 son iguales")
} else {
fmt.Println("usuario1 y usuario3 no son iguales")
}

}
Los structs vacíos y de valor cero son iguales. El orden de los campos no importa, básicamente, cada campo debe coincidir para la igualdad. La salida para el código anterior será

user1 y user2 son iguales
user1 y user3 no son iguales

Conclusión

¡Impresionante!

Ahora está listo para usar structs en golang. Hemos cubierto todos los aspectos básicos como la declaración, la inicialización y el acceso a los campos struct. También vimos cómo comparar dos structs e incluso implementamos un struct anidado. Aquí hay algunos recursos para aprender más sobre structs –

Hay mucho más que aprender sobre los structs, pero es un buen comienzo por ahora. ¡Espero que haya aprendido algo nuevo!

Siga explorando. ¡Siga aprendiendo!

Mohit Khare

Autor