Punteros y Structs en Go: Aplicaciones Prácticas y Funciones

Clase 23 de 36 • Curso Básico de Programación en Go

Contenido del curso

Hola mundo en Go

Variables, funciones y documentación

Estructuras de control de flujo y condicionales

Estructuras de datos básicas

Métodos e interfaces

Concurrencia y Channels

Manejo de paquetes y Go Modules

Despedida del curso

33
Recursos Avanzados y Comunidad para Desarrolladores en Go
03:28 min

Bonus

Tomar examen

Resumen

¿Cómo trabajar con punteros y structs en Go?

Explorar el mundo de los punteros y los structs en Go es esencial para desarrollar un entendimiento sólido de la administración de memoria y la programación efectiva en este lenguaje. Estos conceptos son fundamentales para crear programas eficientes y bien estructurados. En este contenido, profundizaremos en el uso de punteros y structs, proporcionándote ejemplos prácticos y funciones que te serán útiles en tu camino como desarrollador Go.

¿Qué son los punteros y cómo funcionan?

Los punteros son referencias a ubicaciones en la memoria de donde se almacenan los datos. En Go, manejar punteros es relativamente sencillo comparado con otros lenguajes, ya que se utiliza el símbolo & para obtener la dirección de memoria de una variable, y el asterisco * para acceder al valor que se encuentra en esa dirección.

a := 50
b := &a
fmt.Println(a) // Imprimirá 50
fmt.Println(b) // Imprimirá dirección de memoria de 'a'

Cuando modificas el valor de la variable a través del puntero, el cambio reflejará en todas las referencias a esa dirección de memoria:

*b = 100
fmt.Println(a) // Imprimirá 100

¿Cómo crear y utilizar structs?

En Go, los structs son tipos de datos personalizados que permiten agrupar datos relacionados. Son esenciales para organizar datos complejos de manera lógica y efectiva. Aquí un ejemplo de cómo declararlos y usarlos:

type PC struct {
    RAM   int
    Disco int
    Marca string
}

miPC := PC{RAM: 16, Disco: 200, Marca: "MSI"}
fmt.Println(miPC)

¿Cómo añadir funciones a los structs?

Los métodos agregados a un struct permiten encapsular comportamientos relacionados con el tipo. Para añadir una función que, por ejemplo, realice un ping que muestre la marca, puedes hacer lo siguiente:

func (pc PC) Ping() string {
    return fmt.Sprintf("Pong! Marca: %s", pc.Marca)
}

fmt.Println(miPC.Ping()) // Imprimirá "Pong! Marca: MSI"

¿Cómo utilizan los punteros para modificar structs?

Para realizar cambios en los datos de un struct utilizando punteros, se accede directamente a la dirección de memoria del struct:

func (pc *PC) DuplicaRAM() {
    pc.RAM *= 2
}

miPC.DuplicaRAM()
fmt.Println(miPC.RAM) // Imprimirá 32

Con esta técnica, puedes modificar los datos de un struct de forma eficiente y mantener un código limpio y optimizado.

¿Cuáles son los beneficios de usar punteros en Go?

El uso de punteros permite:

Pasar grandes structs de manera eficiente sin copiar toda la estructura de datos.
Modificar datos dentro de funciones evitando duplicar memoria.
Crear funciones más personalizadas para librerías y paquetes.

El uso adecuado de punteros y structs es crucial para lograr eficiencia y flexibilidad en tus proyectos de programación en Go. Esto te ayudará a crear programas robustos y maneja de manera efectiva la memoria y los recursos. Continúa practicando y aplicando estos conceptos para desarrollar tus habilidades. ¡El viaje a través de Go tiene mucho más que ofrecer!

Comentarios

Luis Arturo Cruz Cruz

student•

Eso de los punteros es una herencia directa del lenguaje C, y si mal no recuerdo es ya una norma en los leguajes compilados.

Raúl Humberto Peñate Ramírez

student•

Nunca entendí del todo los memes sobre punteros, con saber cómo funcionan el heap y el stack puede ya se entienden. En lenguajes que manejan la memoria automáticamente, como Java, el concepto de punteros se reemplaza por el manejo de referencias a objetos y esto molesta porque a vecez hacen falta jaja.

Royer Guerrero Pinilla

student•

Quiero compartir con ustedes este video CS50 2020 - Lecture 4 - Memory

Allí explican por qué lucen algo como 0xc0000b8010 spoiler está en hexadecimal el número y el 0x es un prefijo en la computación cuando se escribe un número hexadecimal.

Rogger Vásquez Oviedo

student•

Gracias! el curso de CS50 es muyyy bueno.

J. Sebastián Botello. H.

student•

Gracias, material interesante

Miguel Angel Luque Acevedo

student•

Reto: Decidí dejar las variables del struct privadas y acceder a ellas mediante un get y set. Ya que hice uso de variables privadas cree un tipo de constructor.

package reto

import "fmt"

type Pc struct {
	ram   int
	disk  int
	brand string
}

func New(rm, dsk int, brn string) Pc {
	myPc := Pc{ram: rm, disk: dsk, brand: brn}
	return myPc
}

func (myPc Pc) FormatPrint() {
	fmt.Printf("Esta pc marca %s cuenta con una ram de %dGB y un disco de %dGB.\n", myPc.brand, myPc.ram, myPc.disk)
}

func (myPc *Pc) DuplicateRAM() {
	myPc.ram = myPc.ram * 2
}

func (myPc Pc) GetRam() int {
	return myPc.ram
}

func (myPc *Pc) SetRam(rm int) {
	myPc.ram = rm
}

package main

import (
	rt "curso-golang/src/16.Punteros/reto"
	"fmt"
)

func main() {
	myPc := rt.New(12, 200, "HP")
	myPc.SetRam(16)
	myPc.FormatPrint()
	fmt.Println("Se duplica la ram")
	myPc.DuplicateRAM()
	myPc.FormatPrint()
}

Daniel Fernández Sánchez

student•

Genial

Peter Jonathan Montalvo Garcia

student•

Perfecto!

Andres Giovanny Rodriguez Escobar

student•

Creo que en esta clase falto mas detalle de lo que sucede con las funciones y la sintaxis de golang para associarlas con los structs. Por favor revisar lo que son las Receiver Functions, los value receivers y los pointer receivers. En resumen es lo que el intento demostrar el final del video pero sin esta terminologia la explicacion esta desconectada de las definiciones de la sintaxis de go.

María Sol Battaglia

student•

Este en un muy buen articulo donde explican punteros en Go https://www.digitalocean.com/community/conceptual_articles/understanding-pointers-in-go-es

Juan Carlos García Esquivel

student•

Muy buen aporte, muchas gracias.

Miguel Buritica

student•

Considero esta lectura fundamental para entender como funciona y para que nos puede servir diferenciarlos

Wilson Fernando Antury Torres

student•

El símbolo " & " accede a la memoria de la variable.
El símbolo " * " accede al valor que está guardado en memoria, usando la dirección de memoria de la variable.

Guillermo Pedro Cuneo

student•

Te agrego un detalle:

El "&" accede a la dirección del espacio de memoria de la variable.
"*" accede al valor que contiene ese espacio de memoria, dado el nombre de una variable o una dirección especifica.

Wilson Fernando Antury Torres

student•

Lo que pude entender:

Podemos asociar una función o método a un struct.
Si no indicamos el apuntador, es posible acceder a los valores de las variables, pero no es posible modificarlos desde el método.
Si pasamos el apuntador al método, entonces tendremos acceso a la memoria donde podremos modificar los valores.

Anthony Aguilar

student•

Me pareció bueno tu aporte, y me surgió un duda con este punto:

Si no indicamos el apuntador, es posible acceder a los valores de las variables, pero no es posible modificarlos desde el método.

por lo que hice una prueba y esto es lo que vi:

type pc struct {
	ram   int
	hdd   int
	brand string
}

func (myPc pc) ping() {
	myPc.brand = "Apple"
	fmt.Println(myPc.brand, "pong")
}

func main() {
	myPC := pc{ram: 4, hdd: 500, brand: "Dell"}

	myPC.ping()

	fmt.Println(myPC)

}

esto me imprime

Apple pong
{4 500 Dell}

lo que me demuestra que: Cuando NO se indica el apuntador en el método, es posible modificar los datos, pero SOLO dentro de esa función, en este caso la función ping() ya que imprimió Apple. pero no queda guardado en memoria ya que después imprimió Dell.

Anthony Aguilar

student•

Por lo que el segundo punto seria:

Si no indicamos el apuntador al método, es posible acceder a los valores de las variables, pero no es posible modificarlos en memoria.

Ignacio Castillejo Gómez

student•

me hizo gracia que dijera al final de la clase que se podía hacer una cosa y de repente la clase finalizará sin explicarla. Una lastima que desde hace ya varios años hacía aquí la calidad de la formación en platzi ha decaído muchísimo.

Anibal Jose

student•

siento que falta claridad en las explicaciones,

José Gustavo Meoño Velázquez

student•

Van varias clases donde pasa exactamente lo mismo.

Cristian Cepeda

student•

Un ejemplo para complementar el uso de Pointer receivers https://tour.golang.org/methods/4

Kebyn Enrique Ajin Elías

student•

Para solucionar el reto, creé una carpeta llamada "pcpackage" y dentro, un archivo llamado "pcpackage.go". Allí, escribí el siguiente código:

package pcpackage

import "fmt"

// PC struct with public access
type PC struct {
	Ram   int
	Disk  int
	Brand string
}

func (myComputer *PC) DuplicateRAM() {
	myComputer.Ram = myComputer.Ram * 2
	fmt.Println(myComputer)
}

Luego, en el main.go para acceder al struct creado en pcpackage, escribí el siguiente código:

package main

import (
	computer "curso_golang_platzi/src/pcpackage"
	"fmt"
)

func main() {
	var newComputer computer.PC
	newComputer.Ram = 32
	newComputer.Disk = 256
	newComputer.Brand = "Razer"

	fmt.Println(newComputer)
	newComputer.DuplicateRAM()

	// Output:
	// {32 256 Razer}
	// &{64 256 Razer}
}
}```

Espero que sea de utilidad :)

Xavier Flores

student•

estas explicaciones son muy vagas para quien recien esta aprendiendo a programar....

estas explicaciones son muy claras para alguien que ya sepa programar en otro lenguaje....

estas explicaciones son lo mejor cuando te quieres saltar de un lenguaje a otro y aprender las bases para comenzar a desarrollar en horas...

Fernando Pioli Martínez

student•

a mi criterio no esta bueno que cuando el profe te dice "Para profundizar tal tema..." te mande a una enciclopedia. Yo como profe, trataría de ser mas específico.

Anibal Jose

student•

el profesor dice "agregamos el metodo ping, cuando no ha explicado que es un metodo, tampoco si es que la funcion se llama ping o es que existe una keyword que se llame ping, no lo se, la verdad falta mucha claridad en estas explicaciones"

Enzo Venturi

student•

También podemos duplicar la ram de esta forma:

myPc.ram *= 2

Mario Andrés Castro Martínez

student•

Mi reto:

Aldo Said Salas Rodríguez

student•

En Go para escribir métodos a las "clases" o structs se les llama receiver functions y estas se distinguen de las funciones normales porque antes del nombre de la función reciben una variable de tipo struct que le pasemos.

Ejemplo en Go:

type pc struct {
	ram   int
	disk  int
	brand string
}

func (myPc pc) ping() {
	fmt.Println(myPc.brand, "Pong")
}

func main() {
	myPC := pc{ram: 16, disk: 200, brand: "msi"}
	myPC.ping()
}

Su equivalente en Python:

class PC:
    def __init__(self, ram, disk, brand):
        self.ram = ram
        self.disk = disk
        self.brand = brand
    
    def ping(self):
        print(self.brand, "Pong")

myPC = PC(16, 200, "msi")
myPC.ping()

O su equivalente en TypeScript:

class PC {
  ram: number;
  disk: number;
  brand: string;

  constructor(ram: number, disk: number, brand: string) {
    this.ram = ram;
    this.disk = disk;
    this.brand = brand;
  }

  ping(): void {
    console.log(this.brand, "Pong");
  }
}

let myPC: PC = new PC(16, 200, "msi");
myPC.ping();

Nicoll Idaly Angulo Mejia

student•

Ver los nombres de un strong con %+v

package main

import "fmt"

type Pc struct {
	RAM int
	Disco int
}

func (pc *Pc) dupicateRam()  {
	pc.RAM = pc.RAM * 2
}

func main() {
	var Mypc = Pc{
		RAM:   2,
		Disco: 120,
	}
	fmt.Printf("%+v\n", Mypc)
	Mypc.dupicateRam()
	fmt.Printf("%+v\n", Mypc)
	Mypc.dupicateRam()
	fmt.Printf("%+v\n", Mypc)
}

Eliaz Bobadilla

student•

Codigo de la clase:

package main

import "fmt"

type pc struct {
	ram   int
	disk  int
	brand string
}

func (myPC pc) ping() {
	fmt.Println(myPC.brand, "Pong")
}

func (myPC *pc) duplicateRam() {
	myPC.ram = myPC.ram * 2
}

func (myPC *pc) duplicateDisk() {
	myPC.disk = myPC.disk * 2
}

func main() {
	var a int = 50
	b := &a

	fmt.Println(*b, b)

	*b = 100
	fmt.Println(a)

	myPC := pc{ram: 16, disk: 200, brand: "linux"}
	fmt.Println(myPC)

	myPC.ping()

	fmt.Println(myPC)
	myPC.duplicateRam()
	myPC.duplicateDisk()

	fmt.Println(myPC)

}

Esto esta mas documentado aquí.

Nicolás Peralta Páez

student•

Uuuff, Crack!

Wilmer León Chávez

student•

📄 Un buen artículo con ejemplo sobre los punteros, cómo crearlos y usar los operadores de dirección (&) y desreferenciación (*) https://ed.team/blog/que-son-los-punteros-en-go

Joserra Parada Fontaiña

student•

Ahora si que estoy confuso, porque creo recordar que en C, se le tenía que pasar un puntero y, aquí veo que se le pasa el mismo valor pero se tipa de puntero, y ahí si que me pierdo.

Anibal Jose

student•

falta claridad en lo que explica, que significa agregar algo antes del nombre de la funcion? me da bronca que solo diga "escribe aca el struct y listo" en vez de explicar bien

package reto

import "fmt"

type Pc struct {
	ram   int
	disk  int
	brand string
}

func New(rm, dsk int, brn string) Pc {
	myPc := Pc{ram: rm, disk: dsk, brand: brn}
	return myPc
}

func (myPc Pc) FormatPrint() {
	fmt.Printf("Esta pc marca %s cuenta con una ram de %dGB y un disco de %dGB.\n", myPc.brand, myPc.ram, myPc.disk)
}

func (myPc *Pc) DuplicateRAM() {
	myPc.ram = myPc.ram * 2
}

func (myPc Pc) GetRam() int {
	return myPc.ram
}

func (myPc *Pc) SetRam(rm int) {
	myPc.ram = rm
}

package main

import (
	rt "curso-golang/src/16.Punteros/reto"
	"fmt"
)

func main() {
	myPc := rt.New(12, 200, "HP")
	myPc.SetRam(16)
	myPc.FormatPrint()
	fmt.Println("Se duplica la ram")
	myPc.DuplicateRAM()
	myPc.FormatPrint()
}

type pc struct {
	ram   int
	hdd   int
	brand string
}

func (myPc pc) ping() {
	myPc.brand = "Apple"
	fmt.Println(myPc.brand, "pong")
}

func main() {
	myPC := pc{ram: 4, hdd: 500, brand: "Dell"}

	myPC.ping()

	fmt.Println(myPC)

}

package pcpackage

import "fmt"

// PC struct with public access
type PC struct {
	Ram   int
	Disk  int
	Brand string
}

func (myComputer *PC) DuplicateRAM() {
	myComputer.Ram = myComputer.Ram * 2
	fmt.Println(myComputer)
}

package main

import (
	computer "curso_golang_platzi/src/pcpackage"
	"fmt"
)

func main() {
	var newComputer computer.PC
	newComputer.Ram = 32
	newComputer.Disk = 256
	newComputer.Brand = "Razer"

	fmt.Println(newComputer)
	newComputer.DuplicateRAM()

	// Output:
	// {32 256 Razer}
	// &{64 256 Razer}
}
}```

Espero que sea de utilidad :)

class PC:
    def __init__(self, ram, disk, brand):
        self.ram = ram
        self.disk = disk
        self.brand = brand
    
    def ping(self):
        print(self.brand, "Pong")

myPC = PC(16, 200, "msi")
myPC.ping()

class PC {
  ram: number;
  disk: number;
  brand: string;

  constructor(ram: number, disk: number, brand: string) {
    this.ram = ram;
    this.disk = disk;
    this.brand = brand;
  }

  ping(): void {
    console.log(this.brand, "Pong");
  }
}

let myPC: PC = new PC(16, 200, "msi");
myPC.ping();

package main

import "fmt"

type Pc struct {
	RAM int
	Disco int
}

func (pc *Pc) dupicateRam()  {
	pc.RAM = pc.RAM * 2
}

func main() {
	var Mypc = Pc{
		RAM:   2,
		Disco: 120,
	}
	fmt.Printf("%+v\n", Mypc)
	Mypc.dupicateRam()
	fmt.Printf("%+v\n", Mypc)
	Mypc.dupicateRam()
	fmt.Printf("%+v\n", Mypc)
}

package main

import "fmt"

type pc struct {
	ram   int
	disk  int
	brand string
}

func (myPC pc) ping() {
	fmt.Println(myPC.brand, "Pong")
}

func (myPC *pc) duplicateRam() {
	myPC.ram = myPC.ram * 2
}

func (myPC *pc) duplicateDisk() {
	myPC.disk = myPC.disk * 2
}

func main() {
	var a int = 50
	b := &a

	fmt.Println(*b, b)

	*b = 100
	fmt.Println(a)

	myPC := pc{ram: 16, disk: 200, brand: "linux"}
	fmt.Println(myPC)

	myPC.ping()

	fmt.Println(myPC)
	myPC.duplicateRam()
	myPC.duplicateDisk()

	fmt.Println(myPC)

}

Punteros y Structs en Go: Aplicaciones Prácticas y Funciones

Hola mundo en Go

Programación Básica con Go: Variables, Funciones y GoModules

Introducción al lenguaje de programación Go y sus beneficios

Instalación de Go en Linux paso a paso

Instalación de Go en macOS con Brew y métodos alternativos

Instalación y Configuración de Go en Windows

Programación en Go: Primer Hola Mundo paso a paso

Variables, funciones y documentación

Variables, Constantes y Cero Valores en Go

Operadores Aritméticos en Go: Suma, Resta, Multiplicación y División

Tipos de Datos Primitivos en Go: Enteros, Flotantes y Booleanos

Funciones clave del paquete fmt en Go

Funciones y Retornos en Go: Uso y Mejores Prácticas

Lectura de Documentación en Go y Librerías de Terceros

Estructuras de control de flujo y condicionales

Ciclos For en Go: Uso y Ejemplos Prácticos

Operadores de Comparación y Lógicos en Go

Sentencias Condicionales If en Go: Uso y Ejemplos Prácticos

Condicionales en Go: Uso de Switch vs If

Uso de Keywords Differ, Break y Continue en Go

Estructuras de datos básicas

Manejo de Arrays y Slices en Go: Declaración y Modificación

Recorrido de Slices y Detección de Palíndromos en Go

Uso de Maps en Go: Diccionarios Llave-Valor

Structs en Go: Creación y Uso de Atributos y Métodos

Modificadores de Acceso en Go: Público y Privado

Métodos e interfaces