Declaración y uso de estructuras de datos en Go

Contenido del curso

Introducción y Configuración

Fundamentos de Go

Estructuras de Datos y Funciones

Manejo de Errores y Concurrencia

Buenas Prácticas en Go

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:009:06

Declaración y uso de estructuras de datos en Go

Curso de Go

Clase 18 de 28

Clase 18 / 28

Recursos

El lenguaje Go emplea estructuras de datos llamadas structs como equivalentes a las clases en otros lenguajes de programación. Estas estructuras permiten definir tipos personalizados con propiedades específicas y métodos asociados, haciendo posible trabajar de manera organizada y eficiente.

¿Qué son las estructuras de datos ó structs en Go?

En Go, una estructura de datos, conocidas comúnmente como struct, es un tipo de dato personalizado que facilita crear objetos que tienen propiedades específicas. Los structs son similares a las clases en programación orientada a objetos y permiten gestionar la información agrupadamente.

Para declarar un nuevo struct se utiliza la palabra reservada type, seguida del nombre de la estructura y la indicación struct. Por ejemplo:

type persona struct {
    nombre string
    edad   int
}

Estos atributos definen las propiedades del nuevo objeto "persona", permitiendo organizar de manera fácil los datos relacionados.

¿Cómo crear una función que retorne una estructura?

Cuando se trabaja con structs, es común escribir funciones que permitan crear instancias de estas estructuras de forma dinámica. Observa cómo una función puede regresar un objeto con la estructura recién definida:

func nuevaPersona(nombre string, edad int) *persona {
    nuevoIndividuo := persona{
        nombre: nombre,
        edad:   edad,
    }
    nuevoIndividuo.edad = 42 // Se manipula directamente la propiedad
    return &nuevoIndividuo
}

Esta función demuestra también cómo trabajar con punteros, retornando directamente la dirección de memoria del objeto creado, lo que mejora el rendimiento al evitar copias innecesarias.

¿De qué formas puedes declarar e inicializar structs?

En Go existen diferentes métodos para ingresar datos a un struct. Por ejemplo:

Declaración implícita:

fmt.Println(persona{"Marcela", 42})

Declaración explícita:

fmt.Println(persona{nombre: "Santiago", edad: 44})

En ambos casos, el resultado es el mismo, pero en Go también puedes omitir propiedades al declarar un objeto, asignándose un valor por defecto:

fmt.Println(persona{nombre: "Felipe"}) // edad será 0

¿Cómo actualizar propiedades específicas de un struct?

Los structs permiten modificar sus propiedades individualmente, tanto en la creación como posteriormente:

personita := persona{nombre: "Miranda", edad: 7}
personita.edad = 10 // Actualiza edad directamente

Esto facilita controlar los datos dentro del programa, actualizándolos según se necesite durante la ejecución del código.

¿Qué experiencia tienes trabajando con structs en Go? ¡Comparte tus opiniones y dudas en los comentarios!

package types

import "fmt"

// Un struct es una colección de campos. Cada campo tiene un nombre y un tipo.
// Es decir puedo grupar distintas propiedades bajo un mismo tipo,
// como si fuera una “plantilla” u “objeto” en otros lenguajes.
// Además, puedes asociar funciones (llamadas métodos) a estos
// tipos, para que operen sobre sus datos internos.

// Un método es una función con un receptor (receiver).
// El receptor indica sobre qué tipo de dato va a operar esa función.

// definir un struct
type ArtistaMarcial struct {
	Nombre    string
	Peso      float64
	Altura    float64
	Victorias int
	Derrotas  int
}

// Método para presentar al peleador
// Receptor por valor (a ArtistaMarcial). Esto significa que se trabaja con una copia del objeto original.
func (a ArtistaMarcial) Presentarse() {
	fmt.Printf("Soy %s, peso %.1f kg y mi récord es %d - %d\n", a.Nombre, a.Peso, a.Victorias, a.Derrotas)
}

// Método para registrar una victoria
// Receptor por puntero (a *ArtistaMarcial). Esto significa que el método recibe una referencia al objeto original, y puede modificar su estado interno
func (a *ArtistaMarcial) Victoria() {
	a.Victorias++
	fmt.Printf("¡%s ha ganado una pelea! Nuevo récord: %d - %d\n", a.Nombre, a.Victorias, a.Derrotas)
}

// Método para registrar una derrota
func (a *ArtistaMarcial) Derrota() {
	a.Derrotas++
	fmt.Printf("¡%s ha perdido una pelea! Nuevo récord: %d - %d\n", a.Nombre, a.Victorias, a.Derrotas)
}

// Se usa un puntero en el segundo método (*ArtistaMarcial) porque se necesita modificar el objeto original.
// En el primero no se usa porque solo se lee, y una copia es suficiente.

func Structs() {
	// crear un luchador
	luchador := ArtistaMarcial{
		Nombre:    "Ilia Topuria",
		Peso:      70,
		Altura:    1.70,
		Victorias: 17,
		Derrotas:  0,
	}

	luchador.Presentarse()
	luchador.Victoria()
}

package fundamentals

import "fmt"

type Kage string

const (
	Hokage     Kage = "Hokage"
	Kazekage   Kage = "Kazekage"
	Mizukage   Kage = "Mizukage"
	Raikage    Kage = "Raikage"
	Tsuchikage Kage = "Tsuchikage"
)

// tipos de datos personalizados
func CustomTypes() {
	Tsunade := Hokage
	fmt.Println("Tsunade es la: ", Tsunade)
}

package main

import (
	"fmt"
	"errors"
)

type person struct {
	name string
	age  int
}

type Level uint8

const (
	Junior Level = iota + 1
	SemiSenior
	Senior
)

type worker struct {
	id uint32
	active bool
	person
	yearsInCompany uint8
	level Level
}

func main() {
	p := createPerson("John Doe", 30)
	w := createWorker(1, true, p)

	printWorkerInfo(w)

	separator()

	err := registerAniversary(&w)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	
	fmt.Println("After 1st anniversary:")
	printWorkerInfo(w)

	separator()
	
	deactivateWorker(&w)
	fmt.Println("After deactivation:")
	printWorkerInfo(w)

	separator()
	
	err = registerAniversary(&w)
	if err != nil {
		fmt.Println("Error:", err)
	}

	separator()
	
	activateWorker(&w)
	fmt.Println("After activation:")
	printWorkerInfo(w)
	
	separator()
	
	err = registerAniversary(&w)
	if err != nil {
		fmt.Println("Error:", err)
	}
	fmt.Println("After 2nd anniversary:")
	printWorkerInfo(w)

	separator()

	registerAniversary(&w)
}

func createPerson(name string, age int) person {
	if age < 18 || age > 70 || age == 0 {
		_ = errors.New("Invalid age")
		return person{}
	}

	if name == "" {
		_ = errors.New("Name cannot be empty")
		return person{}
	}

	return person{name: name, age: age}
}

func createWorker(id uint32, active bool, p person) worker {
	return worker{id: id, active: active, person: p}
}

func printWorkerInfo(w worker) {
	fmt.Printf("Worker ID: %d\n", w.id)
	fmt.Printf("Active: %t\n", w.active)
	fmt.Printf("Name: %s\n", w.name)
	fmt.Printf("Age: %d\n", w.age)
	fmt.Printf("Years in Company: %d\n", w.yearsInCompany)
	fmt.Printf("Level: %d\n", w.level)
}

func registerAniversary(w *worker) error {

	if !w.active {
		err := errors.New("Cannot register anniversary for inactive worker")
		return err
	}

	w.yearsInCompany++
	w.person.age++

	if w.yearsInCompany >= 2 && w.yearsInCompany < 5 {
		w.level = SemiSenior
	} else if w.yearsInCompany >= 5 {
		w.level = Senior
	}
	return nil
}

func deactivateWorker(w *worker) error {

	if !w.active {
		err := errors.New("Worker is already inactive")
		return err
	}

	w.active = false
	return nil
}

func activateWorker(w *worker) error {
	
	if w.active {
		err := errors.New("Worker is already active")
		return err
	}

	w.active = true
	return nil
}

func separator() {
	fmt.Println("----------------------------")
}

Resumen

¿Qué son las estructuras de datos ó structs en Go?

Para declarar un nuevo struct se utiliza la palabra reservada type, seguida del nombre de la estructura y la indicación struct. Por ejemplo:

type persona struct {
    nombre string
    edad   int
}

Estos atributos definen las propiedades del nuevo objeto "persona", permitiendo organizar de manera fácil los datos relacionados.

¿Cómo crear una función que retorne una estructura?

func nuevaPersona(nombre string, edad int) *persona {
    nuevoIndividuo := persona{
        nombre: nombre,
        edad:   edad,
    }
    nuevoIndividuo.edad = 42 // Se manipula directamente la propiedad
    return &nuevoIndividuo
}

Esta función demuestra también cómo trabajar con punteros, retornando directamente la dirección de memoria del objeto creado, lo que mejora el rendimiento al evitar copias innecesarias.

¿De qué formas puedes declarar e inicializar structs?

En Go existen diferentes métodos para ingresar datos a un struct. Por ejemplo:

Declaración implícita:

fmt.Println(persona{"Marcela", 42})

Declaración explícita:

fmt.Println(persona{nombre: "Santiago", edad: 44})

En ambos casos, el resultado es el mismo, pero en Go también puedes omitir propiedades al declarar un objeto, asignándose un valor por defecto:

fmt.Println(persona{nombre: "Felipe"}) // edad será 0

¿Cómo actualizar propiedades específicas de un struct?

Los structs permiten modificar sus propiedades individualmente, tanto en la creación como posteriormente:

personita := persona{nombre: "Miranda", edad: 7}
personita.edad = 10 // Actualiza edad directamente

Esto facilita controlar los datos dentro del programa, actualizándolos según se necesite durante la ejecución del código.

¿Qué experiencia tienes trabajando con structs en Go? ¡Comparte tus opiniones y dudas en los comentarios!

package main

import (
	"fmt"
	"errors"
)

type person struct {
	name string
	age  int
}

type Level uint8

const (
	Junior Level = iota + 1
	SemiSenior
	Senior
)

type worker struct {
	id uint32
	active bool
	person
	yearsInCompany uint8
	level Level
}

func main() {
	p := createPerson("John Doe", 30)
	w := createWorker(1, true, p)

	printWorkerInfo(w)

	separator()

	err := registerAniversary(&w)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	
	fmt.Println("After 1st anniversary:")
	printWorkerInfo(w)

	separator()
	
	deactivateWorker(&w)
	fmt.Println("After deactivation:")
	printWorkerInfo(w)

	separator()
	
	err = registerAniversary(&w)
	if err != nil {
		fmt.Println("Error:", err)
	}

	separator()
	
	activateWorker(&w)
	fmt.Println("After activation:")
	printWorkerInfo(w)
	
	separator()
	
	err = registerAniversary(&w)
	if err != nil {
		fmt.Println("Error:", err)
	}
	fmt.Println("After 2nd anniversary:")
	printWorkerInfo(w)

	separator()

	registerAniversary(&w)
}

func createPerson(name string, age int) person {
	if age < 18 || age > 70 || age == 0 {
		_ = errors.New("Invalid age")
		return person{}
	}

	if name == "" {
		_ = errors.New("Name cannot be empty")
		return person{}
	}

	return person{name: name, age: age}
}

func createWorker(id uint32, active bool, p person) worker {
	return worker{id: id, active: active, person: p}
}

func printWorkerInfo(w worker) {
	fmt.Printf("Worker ID: %d\n", w.id)
	fmt.Printf("Active: %t\n", w.active)
	fmt.Printf("Name: %s\n", w.name)
	fmt.Printf("Age: %d\n", w.age)
	fmt.Printf("Years in Company: %d\n", w.yearsInCompany)
	fmt.Printf("Level: %d\n", w.level)
}

func registerAniversary(w *worker) error {

	if !w.active {
		err := errors.New("Cannot register anniversary for inactive worker")
		return err
	}

	w.yearsInCompany++
	w.person.age++

	if w.yearsInCompany >= 2 && w.yearsInCompany < 5 {
		w.level = SemiSenior
	} else if w.yearsInCompany >= 5 {
		w.level = Senior
	}
	return nil
}

func deactivateWorker(w *worker) error {

	if !w.active {
		err := errors.New("Worker is already inactive")
		return err
	}

	w.active = false
	return nil
}

func activateWorker(w *worker) error {
	
	if w.active {
		err := errors.New("Worker is already active")
		return err
	}

	w.active = true
	return nil
}

func separator() {
	fmt.Println("----------------------------")
}

Comentarios (5)5 comentarios

Ronaldo Jiménez

Hace un año

Sergio Romero

Bastante bueno el aporte, es lo que yo esperaba ver en la clase

Jehú Frayle

Por cierto, otra cosa que se puede hacer con las structs es declarar método (sí, como una clase de POO).

Es un poco extraña la sintaxis para esto, pero se entiende:

func (p Persona) Saludar() {
    fmt.Println("Hola, mi nombre es", p.Nombre)
}

Y si necesitas que el método manipule el arreglo tan solo especificas que el struct se pasará como puntero.

func (p *Persona) CumplirAnios() {
    p.Edad++
}

Juan Felipe Barahona Gonzalez

Hace 10 meses

Miguel Angel Reyes Moreno

Entonces vimos 2 formas de crear structs en esta clase, supongo que con los punteros tendremos mejor rendimiento en memoria:

package main

import (

"fmt"

)

// It's like Classes in other languages, but with some differences.

type Person struct {

Name string

Age int

}

func newPerson(name string, age int) *Person {

return &Person{

Name: name,

Age: age,

func main() {

person := newPerson("John Doe", 30)

fmt.Println(person)

person2 := Person{

Name: "Jane Doe",

Age: 25,

fmt.Println(person2)

Introducción y Configuración

Características y ventajas del lenguaje de programación Go

Instala Go en WSL con un comando

Paquetes en Go sin npm ni pip

Fundamentos de Go

Formas de declarar variables en Go

Conversión de tipos en Go

if else y operador módulo en Go

Cuatro formas de usar for en Go

Estructuras de Datos y Funciones

Sentencia switch en Go con ejemplos reales

Arreglos en Go: fijos e inferidos

Creación y uso de slices dinámicos en Go

Mapas en Go: creación, acceso y manipulación de datos clave-valor

Cómo crear y usar funciones personalizadas en Go

Retorno de múltiples valores en Go

Funciones variadic en Go con tres puntos

Funciones recursivas en Go con Fibonacci

Punteros en Go para optimizar rendimiento del sistema

Runas en Go: bytes vs caracteres reales

Declaración y uso de estructuras de datos en Go

Implementación de enumeradores en Go para controlar estados

Manejo de Errores y Concurrencia

Errores personalizados en Go

Goroutines y channels en Go

Select para ordenar goroutines en Go

Timeouts en goroutines con time.After

Workers en Go con goroutines y channels

Buenas Prácticas en Go

JSON con Marshal y Unmarshal en Go

Conversión de texto plano a hash con SHA256 en Go

Variables de ambiente en Go con paquetes externos

Cierre de curso de Go: consejos para consolidar el aprendizaje

Declaración y uso de estructuras de datos en Go