Sebastian Gomez

Jan 05, 2023

Updated: Jun 24, 2026

Estructuras en Go

En Go, una estructura (o struct) es una colección de variables (campos) agrupadas bajo un nombre. Las estructuras son fundamentales para organizar y manejar datos relacionados de forma eficiente. A diferencia de otros lenguajes que utilizan clases, Go se basa en estructuras para modelar datos y comportamientos.

Un ejemplo de una estructura en Go es el siguiente:

// Define un nuevo tipo llamado 'Persona'.
type Persona struct {
    // Declara un campo 'nombre' de tipo string dentro del struct 'Persona'.
    nombre string
    // Declara un campo 'edad' de tipo int (número entero) dentro del struct 'Persona'.
    edad int
}

En el ejemplo anterior, tenemos una estructura llamada Persona. Esta estructura tiene dos campos, nombre y edad, que son de tipo string e int, respectivamente.

Ahora, para usar esta estructura en nuestro código, necesitamos crear una instancia de ella. Esto se puede hacer de la siguiente manera:

// Ambas formas funcionan exactamente igual
miPersona := Persona{nombre: "Juan", edad: 25}

var miPersona Persona = Persona{nombre: "Juan", edad: 25}

En el ejemplo anterior, hemos creado una instancia de la estructura Persona con el nombre de miPersona. Esta instancia contiene los valores "Juan" y 25 para los campos nombre y edad, respectivamente.

Para acceder a los campos de una estructura, se puede usar el operador punto (.). Por ejemplo, si quisiéramos imprimir los datos de miPersona, podemos usar el siguiente código:

fmt.Println("Nombre:", miPersona.nombre)
fmt.Println("Edad:", miPersona.edad)

Además de los campos, las estructuras también pueden tener métodos asociados, aunque no dentro de su definición. Esta es una particularidad de Go, ya que el método se le agrega a la estructura después de su declaración. Por ejemplo, podemos agregar el siguiente método a la estructura Persona:

func (p Persona) saludar() string {
    return "Hola, mi nombre es " + p.nombre
}

Ahora, para usar este método, podemos llamarlo de la siguiente manera:

mensaje := miPersona.saludar()

Nota: La diferencia entre una función común y un método radica en el paréntesis donde se escribe a qué estructura pertenece, y no lo debes confundir con los parámetros que recibe el método. Por ejemplo, func (p Persona) saludar() es diferente de func saludar(p Persona), ya que el primer paréntesis después de la palabra func indica a qué estructura pertenece el método; de lo contrario, será una función normal.

En el ejemplo anterior hemos llamado al método saludar de miPersona y guardado el resultado en la variable mensaje. El resultado sería el siguiente:

"Hola, mi nombre es Juan"

Estructuras versus clases

Go no tiene clases. En su lugar, Go tiene estructuras que se pueden usar para modelar datos y comportamientos. Las estructuras se definen con la palabra clave struct. Aunque Go no tiene clases, algunos conceptos de la programación orientada a objetos, como la herencia, se pueden simular usando estructuras.

Otra diferencia es que las estructuras no tienen herencia, mientras que las clases sí la tienen. Esto significa que una estructura no puede heredar propiedades o métodos de otra estructura, mientras que una clase sí puede heredar propiedades y métodos de otra clase.

Las estructuras se pasan por valor. Esto significa que cualquier cambio hecho a una copia de una estructura no se reflejará en la estructura original.

Algunos ejemplos de estructuras en Go

Coche:

type Coche struct {
    // Declara un campo 'marca' de tipo string dentro del struct 'Coche'.
    marca string
    // Declara un campo 'modelo' de tipo string dentro del struct 'Coche'.
    modelo string
    // Declara un campo 'anio' de tipo int (número entero) dentro del struct 'Coche'.
    anio int
}

Estudiante:

type Estudiante struct {
    nombre string
    edad   int
    curso  string
    notas  [3]float64
}

Estructuras compuestas

En Go, podemos componer estructuras embebiendo una dentro de otra. Conviene aclarar un punto: a diferencia de otros lenguajes, esto no es un anidamiento real, sino lo que Go llama promoción de campos. Cuando embebemos un tipo dentro de un struct, sus campos y métodos quedan promovidos y accesibles desde la estructura externa. Por ejemplo, podemos crear una estructura llamada Tractor que embeba una estructura llamada Carro:

type Carro struct {
    brand string
    year  int
}

type Tractor struct {
    Carro
    capacity int
}

En el ejemplo anterior, la estructura Tractor contiene un campo llamado capacity y una estructura embebida Carro. Esta estructura embebida aporta los campos brand y year.

Para acceder a los campos del tipo embebido podemos usar el operador punto (.). Cuando embebemos un tipo sin darle un nombre de campo, el campo promovido toma el nombre del propio tipo. Así, para acceder al campo brand a través de una instancia de Tractor, usamos el nombre del tipo embebido, Carro:

miTractor := Tractor{Carro{brand: "Ford", year: 2022}, 2}
fmt.Println("------------------------")
fmt.Println("Tractor:", miTractor.Carro.brand)

Campos anónimos en structs

En Go es posible no declarar el nombre del campo de nuestro struct y colocar únicamente el tipo de dato. Hecho así, el campo adopta el nombre del tipo de dato y podemos acceder a él usando ese nombre. Veamos un ejemplo que compila:

type Videogame struct {
    string
    int
}

func main() {
    myVideogame := Videogame{string: "Titulo", int: 2017}
    fmt.Println(myVideogame)
    // imprime {Titulo 2017}
}

En este caso los campos se llaman, literalmente, string e int, porque ese es el nombre que toma el campo anónimo a partir de su tipo. Por eso el literal con claves {string:..., int:...} funciona, las claves coinciden con los nombres promovidos de los campos.

Modificadores de acceso en Go

A diferencia de otros lenguajes de programación, como Java y Python, que utilizan modificadores de acceso como public, private o protected para especificar el ámbito, Go determina si un elemento es exported o unexported según la forma en que se declara. Exportar un elemento, en este caso, lo hace visible fuera del paquete actual. Si no se exportó, solo es visible y utilizable dentro del paquete en el que se definió.

Esta visibilidad externa se controla escribiendo en mayúscula la primera letra del elemento declarado. Todas las declaraciones, como tipos, variables, constantes, funciones y demás, que comienzan con una letra en mayúscula son visibles fuera del paquete actual.

Conclusiones

En este post hemos explorado el concepto de estructuras en el lenguaje de programación Go. Hemos aprendido que las estructuras son colecciones de datos relacionados que permiten almacenar y organizar información de manera eficiente. Además, hemos visto cómo se pueden definir, instanciar y utilizar estructuras en Go, así como la posibilidad de agregar métodos asociados a ellas. También hemos destacado algunas diferencias importantes entre las estructuras de Go y las clases de otros lenguajes, como la ausencia de herencia y el paso por valor. Por último, vimos cómo componer estructuras mediante embebido (promoción de campos) y cómo usar campos anónimos, así como el uso de mayúsculas para controlar la visibilidad de los elementos en Go. En resumen, las estructuras son una parte fundamental de la programación en Go, ya que permiten organizar y manipular datos de manera eficaz y flexible.

Ejercicios para practicar

A continuación te dejo algunos ejercicios para que practiques las estructuras en Go y envíes la solución como un Pull Request a este repositorio, Go Para Principiantes.

1. Crea una estructura EquipoDeportivo que contenga información sobre jugadores, entrenadores y partidos jugados.
2. Crea una estructura Supermercado que contenga información sobre productos, empleados y ventas.
3. Crea una estructura Universidad que contenga información sobre estudiantes, profesores y cursos ofrecidos.
4. Crea una estructura llamada Libro que contenga campos como Titulo, Autor y AnioDePublicacion. Luego, instancia un objeto libro1 y muestra sus datos.
5. Define un método en la estructura Coche que calcule la velocidad promedio en función de la distancia recorrida y el tiempo. Luego, crea una instancia de un coche y utiliza este método para calcular la velocidad promedio.
6. Crea una estructura Escuela que contenga un campo nombre y un slice de estructuras Estudiante, donde cada estudiante tiene un nombre, edad y curso. Crea una instancia de Escuela con varios estudiantes y muestra sus datos.
7. Define una estructura llamada Producto que tenga un campo anónimo de tipo Precio con un campo valor de tipo float64. Luego, crea un producto y muestra su precio.
8. Simula la herencia en Go creando una estructura Animal con campos como nombre y edad, y luego crea estructuras Perro y Gato que embeban la estructura Animal. Muestra los datos de un perro y un gato.
9. Crea una estructura CuentaBancaria con campos como saldo y nombreTitular. Define métodos para depositar y retirar dinero de la cuenta. Realiza algunas transacciones y muestra el saldo final.
10. Define una estructura EquipoDeFutbol que contenga un slice de nombres de jugadores. Agrega y elimina jugadores del equipo y muestra la lista actualizada.
11. Define una estructura Edificio que contenga información sobre apartamentos, donde cada apartamento tiene un número y un área en metros cuadrados. Crea un método en Edificio para calcular el área total de todos los apartamentos.

Eso es todo, espero que este post te sea de utilidad y lo puedas aplicar a algún proyecto que tengas en mente.

Déjame un comentario si te sirvió, si quieres añadir alguna opinión o si tienes alguna duda. Y recuerda que si te gustó, también puedes compartirlo usando los links a las redes sociales aquí abajo. ¡Buena suerte!