1 Fundamentos de Struct

En el lenguaje Go, un struct es un tipo de dato compuesto utilizado para agrupar diferentes tipos de datos en una sola entidad, ya sean diferentes o idénticos. Los structs ocupan una posición significativa en Go, ya que sirven como un aspecto fundamental de la programación orientada a objetos, aunque con ligeras diferencias de los lenguajes tradicionales de programación orientada a objetos.

La necesidad de structs surge de los siguientes aspectos:

  • Organizar variables con fuerte relevancia juntas para mejorar la mantenibilidad del código.
  • Proporcionar un medio para simular "clases", facilitando las características de encapsulación y agregación.
  • Al interactuar con estructuras de datos como JSON, registros de bases de datos, etc., los structs ofrecen una herramienta de mapeo conveniente.

Organizar datos con structs permite una representación más clara de modelos de objetos del mundo real, como usuarios, pedidos, etc.

2 Definición de un Struct

La sintaxis para definir un struct es la siguiente:

type NombreStruct struct {
    Campo1 TipoCampo1
    Campo2 TipoCampo2
    // ... otras variables miembro
}
  • La palabra clave type introduce la definición del struct.
  • NombreStruct es el nombre del tipo de struct, siguiendo las convenciones de nomenclatura de Go y generalmente se escribe en mayúscula para indicar su exportabilidad.
  • La palabra clave struct indica que este es un tipo struct.
  • Dentro de las llaves {}, se definen las variables miembro (campos) del struct, cada una seguida por su tipo.

El tipo de los miembros del struct puede ser cualquier tipo, incluyendo tipos básicos (como int, string, etc.) y tipos complejos (como arrays, slices, otro struct, etc.).

Por ejemplo, definir un struct que represente a una persona:

type Persona struct {
    Nombre string
    Edad   int
    Correos []string // puede incluir tipos complejos, como slices
}

En el código anterior, el struct Persona tiene tres variables miembro: Nombre de tipo string, Edad de tipo entero y Correos de tipo slice de strings, indicando que una persona puede tener múltiples direcciones de correo electrónico.

3 Creación e Inicialización de un Struct

3.1 Creación de una Instancia de Struct

Hay dos maneras de crear una instancia de struct: declaración directa o usando la palabra clave new.

Declaración directa:

var p Persona

El código anterior crea una instancia p de tipo Persona, donde cada variable miembro del struct toma el valor cero de su tipo correspondiente.

Usando la palabra clave new:

p := new(Persona)

Crear un struct usando la palabra clave new resulta en un puntero al struct. En este punto, la variable p es de tipo *Persona, apuntando a una variable recién asignada de tipo Persona donde las variables miembro han sido inicializadas a valores cero.

3.2 Inicialización de Instancias de Struct

Las instancias de struct se pueden inicializar a la vez cuando se crean, utilizando dos métodos: con nombres de campo o sin nombres de campo.

Inicializar con Nombres de Campo:

p := Persona{
    Nombre: "Alice",
    Edad:   30,
    Correos: []string{"[email protected]", "[email protected]"},
}

Cuando se inicializa con la forma de asignación de campo, el orden de inicialización no necesita ser el mismo que el orden de declaración del struct, y cualquier campo no inicializado conservará sus valores cero.

Inicializar sin Nombres de Campo:

p := Persona{"Bob", 25, []string{"[email protected]"}}

Cuando se inicializa sin nombres de campo, asegúrate de que los valores iniciales de cada variable miembro estén en el mismo orden que cuando se definió el struct, y no se pueden omitir campos.

Además, los structs se pueden inicializar con campos específicos, y cualquier campo no especificado tomará valores cero:

p := Persona{Nombre: "Charlie"}

En este ejemplo, solo se inicializa el campo Nombre, mientras que Edad y Correos tomarán sus valores cero correspondientes.

4 Acceso a los Miembros del Struct

Acceder a las variables miembro de un struct en Go es muy sencillo, logrado mediante el uso del operador punto (.). Si tienes una variable struct, puedes leer o modificar sus valores miembro de esta manera.

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func main() {
    // Create a variable of type Person
    p := Person{"Alice", 30}

    // Access struct members
    fmt.Println("Name:", p.Name)
    fmt.Println("Age:", p.Age)

    // Modify member values
    p.Name = "Bob"
    p.Age = 25

    // Access the modified member values again
    fmt.Println("\nNombre actualizado:", p.Name)
    fmt.Println("Edad actualizada:", p.Age)
}

En este ejemplo, primero definimos una estructura Person con dos variables miembro, Name y Age. Luego creamos una instancia de esta estructura y demostramos cómo leer y modificar estos miembros.

5 Composición y anidamiento de estructuras

Las estructuras no solo pueden existir de forma independiente, sino que también se pueden componer y anidar para crear estructuras de datos más complejas.

5.1 Estructuras anónimas

Una estructura anónima no declara explícitamente un nuevo tipo, sino que utiliza directamente la definición de la estructura. Esto es útil cuando necesitas crear una estructura una vez y usarla de manera simple, evitando la creación de tipos innecesarios.

Ejemplo:

package main

import "fmt"

func main() {
    // Definir e inicializar una estructura anónima
    persona := struct {
        Nombre string
        Edad   int
    }{
        Nombre: "Eva",
        Edad:   40,
    }

    // Acceder a los miembros de la estructura anónima
    fmt.Println("Nombre:", persona.Nombre)
    fmt.Println("Edad:", persona.Edad)
}

En este ejemplo, en lugar de crear un nuevo tipo, definimos directamente una estructura y creamos una instancia de la misma. Este ejemplo muestra cómo inicializar una estructura anónima y acceder a sus miembros.

5.2 Anidamiento de estructuras

El anidamiento de estructuras implica anidar una estructura como miembro de otra estructura. Esto nos permite construir modelos de datos más complejos.

Ejemplo:

package main

import "fmt"

// Definir la estructura Address
type Address struct {
    Ciudad  string
    País string
}

// Anidar la estructura Address en la estructura Person
type Person struct {
    Nombre  string
    Edad     int
    Domicilio Address
}

func main() {
    // Inicializar una instancia de Person
    p := Person{
        Nombre: "Carlos",
        Edad:  28,
        Domicilio: Address{
            Ciudad:    "Nueva York",
            País: "EE. UU.",
        },
    }

    // Acceder a los miembros de la estructura anidada
    fmt.Println("Nombre:", p.Nombre)
    fmt.Println("Edad:", p.Edad)
    // Acceder a los miembros de la estructura Address
    fmt.Println("Ciudad:", p.Domicilio.Ciudad)
    fmt.Println("País:", p.Domicilio.País)
}

En este ejemplo, definimos una estructura Address y la anidamos como un miembro en la estructura Person. Al crear una instancia de Person, también creamos una instancia de Address simultáneamente. Podemos acceder a los miembros de la estructura anidada utilizando la notación de punto.

6 Métodos de estructuras

Las características de la programación orientada a objetos (OOP) se pueden implementar a través de métodos de estructuras.

6.1 Conceptos básicos de los métodos

En el lenguaje Go, aunque no existe el concepto tradicional de clases y objetos, se pueden lograr características similares a la OOP mediante la vinculación de métodos a estructuras. Un método de estructura es un tipo especial de función que se asocia con un tipo específico de estructura (o un puntero a una estructura), lo que permite que ese tipo tenga su propio conjunto de métodos.

// Definir una estructura simple
type Rectángulo struct {
    largo, ancho float64
}

// Definir un método para la estructura Rectángulo para calcular el área del rectángulo
func (r Rectángulo) Área() float64 {
    return r.largo * r.ancho
}

6.2 Receptores de Valor y Receptores de Puntero

Los métodos pueden clasificarse en receptores de valor y receptores de puntero según el tipo de receptor. Los receptores de valor utilizan una copia del struct para llamar al método, mientras que los receptores de puntero utilizan un puntero al struct y pueden modificar el struct original.

// Define un método con un receptor de valor
func (r Rectangle) Perimeter() float64 {
    return 2 * (r.length + r.width)
}

// Define un método con un receptor de puntero, que puede modificar el struct
func (r *Rectangle) SetLength(newLength float64) {
    r.length = newLength // puede modificar el valor original del struct
}

En el ejemplo anterior, Perimeter es un método con receptor de valor, llamarlo no cambiará el valor de Rectangle. Sin embargo, SetLength es un método con receptor de puntero, y llamar a este método afectará a la instancia original de Rectangle.

6.3 Invocación de Métodos

Puedes llamar métodos de un struct utilizando la variable del struct y su puntero.

func main() {
    rect := Rectangle{length: 10, width: 5}

    // Llama al método con un receptor de valor
    fmt.Println("Área:", rect.Area())

    // Llama al método con un receptor de valor
    fmt.Println("Perímetro:", rect.Perimeter())

    // Llama al método con un receptor de puntero
    rect.SetLength(20)

    // Llama al método con un receptor de valor nuevamente, nota que la longitud ha sido modificada
    fmt.Println("Después de la modificación, Área:", rect.Area())
}

Cuando llamas a un método utilizando un puntero, Go maneja automáticamente la conversión entre valores y punteros, independientemente de si tu método está definido con un receptor de valor o un receptor de puntero.

6.4 Selección del Tipo de Receptor

Al definir métodos, debes decidir si utilizar un receptor de valor o un receptor de puntero basado en la situación. Aquí tienes algunas pautas comunes:

  • Si el método necesita modificar el contenido de la estructura, utiliza un receptor de puntero.
  • Si la estructura es grande y el costo de copiar es alto, utiliza un receptor de puntero.
  • Si deseas que el método modifique el valor al que apunta el receptor, utiliza un receptor de puntero.
  • Por razones de eficiencia, incluso si no modificas el contenido de la estructura, es razonable utilizar un receptor de puntero para una estructura grande.
  • Para estructuras pequeñas, o cuando solo se lee datos sin necesidad de modificación, a menudo es más simple y eficiente utilizar un receptor de valor.

A través de los métodos de struct, podemos simular algunas características de la programación orientada a objetos en Go, como la encapsulación y los métodos. Este enfoque en Go simplifica el concepto de objetos al tiempo que proporciona suficiente capacidad para organizar y gestionar funciones relacionadas.

7 Serialización de Struct y JSON

En Go, a menudo es necesario serializar un struct en formato JSON para transmisión de red o como archivo de configuración. De manera similar, también necesitamos poder deserializar JSON en instancias de struct. El paquete encoding/json en Go proporciona esta funcionalidad.

Aquí tienes un ejemplo de cómo convertir entre un struct y JSON:

package main

import (
	"encoding/json"
	"fmt"
	"log"
)

// Define la estructura Person, y utiliza etiquetas json para definir la asignación entre los campos del struct y los nombres de campo JSON
type Person struct {
	Name   string   `json:"name"`
	Age    int      `json:"age"`
	Emails []string `json:"emails,omitempty"`
}

func main() {
	// Crea una nueva instancia de Person
	p := Person{
		Name:   "John Doe",
		Age:    30,
		Emails: []string{"[email protected]", "[email protected]"},
	}

	// Serializa a JSON
	jsonData, err := json.Marshal(p)
	if err != nil {
		log.Fatalf("Error al serializar JSON: %s", err)
	}
	fmt.Printf("Formato JSON: %s\n", jsonData)

	// Deserializa en un struct
	var p2 Person
	if err := json.Unmarshal(jsonData, &p2); err != nil {
		log.Fatalf("Error al deserializar JSON: %s", err)
	}
	fmt.Printf("Estructura recuperada: %#v\n", p2)
}

En el código anterior, definimos una estructura Person, que incluye un campo de tipo slice con la opción "omitempty". Esta opción especifica que si el campo está vacío o falta, no se incluirá en el JSON.

Utilizamos la función json.Marshal para serializar una instancia de struct en JSON, y la función json.Unmarshal para deserializar datos JSON en una instancia de struct.

8 Temas Avanzados en Structs

8.1 Comparación de Structs

En Go, se permite comparar directamente dos instancias de structs, pero esta comparación se basa en los valores de los campos dentro de las structs. Si todos los valores de los campos son iguales, entonces las dos instancias de los structs se consideran iguales. Cabe señalar que no todos los tipos de campos se pueden comparar. Por ejemplo, no se pueden comparar directamente structs que contienen slices.

A continuación se muestra un ejemplo de comparación de structs:

package main

import "fmt"

type Point struct {
	X, Y int
}

func main() {
	p1 := Point{1, 2}
	p2 := Point{1, 2}
	p3 := Point{1, 3}

fmt.Println("p1 == p2:", p1 == p2) // Salida: p1 == p2: true
fmt.Println("p1 == p3:", p1 == p3) // Salida: p1 == p3: false
}

En este ejemplo, p1 y p2 se consideran iguales porque todos sus valores de campo son iguales. Y p3 no es igual a p1 porque el valor de Y es diferente.

8.2 Copia de Structs

En Go, las instancias de structs pueden ser copiadas por asignación. Si esta copia es una copia profunda o una copia superficial depende de los tipos de los campos dentro de la struct.

Si la struct solo contiene tipos básicos (como int, string, etc.), la copia es una copia profunda. Si la struct contiene tipos de referencia (como slices, maps, etc.), la copia será una copia superficial, y la instancia original y la instancia recién copiada compartirán la memoria de los tipos de referencia.

A continuación se muestra un ejemplo de copiar un struct:

package main

import "fmt"

type Data struct {
Numbers []int
}

func main() {
// Inicializar una instancia del struct Data
original := Data{Numbers: []int{1, 2, 3}}

// Copiar el struct
copied := original

// Modificar los elementos del slice copiado
copied.Numbers[0] = 100

// Ver los elementos de las instancias original y copiada
fmt.Println("Original:", original.Numbers) // Salida: Original: [100 2 3]
fmt.Println("Copia:", copied.Numbers) // Salida: Copia: [100 2 3]
}

Como se muestra en el ejemplo, las instancias original y copied comparten el mismo slice, por lo que modificar los datos del slice en copied también afectará los datos del slice en original.

Para evitar este problema, puedes lograr una verdadera copia profunda al copiar explícitamente el contenido del slice a un nuevo slice:

newNumbers := make([]int, len(original.Numbers))
copy(newNumbers, original.Numbers)
copied := Data{Numbers: newNumbers}

De esta manera, cualquier modificación en copied no afectará a original.