Un objeto de tipo Struct es una colección de campos o propiedades con tipos de dato definidos. Dentro de la estructura, cada campo se declara con un tipo conocido, puede ser definido por el usuario o bien ser un tipo integrado.

En Go las estructuras son las única manera de crear tipos definidos por el usuario. Son útiles puesto que permiten mejorar la modularidad y poder manipular estructuras de datos complejas en toda nuestra aplicación. Golang no es lenguaje 100% orientado a objetos sin embargo mediante las estructuras es posible trabajar con POO , podríamos decir que sería un equivalente a las clases de otros lenguajes.

Las estructuras resultan particularmente útiles; representan una plantilla que nos permite registrar datos o mapear con otros formatos como JSON,XML,etc.

Veamos la declaración básica de una estructura.

//Siempre al inicio la palabra type , seguido del nombre que queremos asignar a la estructura y la palabra struct.
type identificador struct{
  //declaramos el nombre de los campos , seguido del tipo de dato
  campo1 tipoDeDato
  campo2 tipoDeDato
}

Declaración de una Estructura

Declaremos una estructura de tipo alumno, que cuenta con 2 campos de diferentes tipos de datos. En este ejemplo vamos a usar la estructura sin crear una nueva instancia de la misma.

package main

import "fmt"

type alumno struct {
	nombre string
	edad   int
}

func main() {
	fmt.Println(alumno{"diego", 22})
}

Es importante mencionar que los campos en la estructura alumno no son exportables a otros paquetes puesto que inician su declaración con minúsculas, de esta manera la accesibilidad esta limitada a el paquete actual.

Instanciar Estructuras

Utilizando la palabra var se crea la inicialización de la variable alum del tipo alumno. Usando . es posible asignar valores a los campos de la estructura.

package main

import "fmt"

type alumno struct {
	nombre string
	edad   int
}

func main() {
	//creamos la instancia de alumno
	var alum alumno
        //seteamos valores
	alum.nombre = "diego"
	alum.edad = 20
	fmt.Println(alum)
	fmt.Println("Nombre:\t", alum.nombre)
	fmt.Println("Edad:\t", alum.edad)
}

Crear Instancias con Literales

Crear una instancia de alumno es realmente sencillo usando literales, puesto que al mismo tiempo podemos asignar los valores.

package main

import "fmt"

type alumno struct {
	nombre string
	edad   int
}

func main() {
	//creamos la instancia de alumno y asignamos valores
	alum := alumno{"roman", 33}

	//creamos otra instancia de alumno pero omitimos el valor de edad
	alum2 := alumno{nombre: "pablo"}

	fmt.Println(alum)
	fmt.Println(alum2)

}

Crear una instancia usando la palabra new

Existe otra opción para crear instancias de una estructura, mediante la palabra new. En este caso alum apunta a la dirección de la estructura instanciada.

package main

import "fmt"

type alumno struct {
	nombre string
	edad   int
}

func main() {
	//alum es un apuntador a una instancia de alumno
	alum := new(alumno)
	alum.nombre = "roman"
	alum.edad = 33
	fmt.Println(alum)

}

Crear una instancia Usando Apuntador

Para crear una instancia de alumno usando un apuntador basta con utilizar el operador &.

package main

import "fmt"

type alumno struct {
	nombre string
	edad   int
}

func main() {
	//creamos un apuntador a una instancia, asignando todos los valores
	//de la estructura
	var alumno1 = &alumno{"roman", 33}
	fmt.Println(alumno1)

	//creamos un apuntador a la instancia, pero asignamos los valores después
	var alumno2 = &alumno{}
	alumno2.nombre = "pablo"
	alumno2.edad = 34
	fmt.Println(alumno2)

}

En este post hemos visto la declaración e inicialización de estructuras, en el siguiente post aprenderemos a manejar operaciones con las estructuras.

Jesus Flores

Ingeniero de Software y Agile Coach

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *