Métodos en structs
Receivers por valor frente a receivers por puntero
Métodos en structs es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.
¿Qué es un método?
Un método es una función con un argumento receptor. El receptor aparece entre la palabra clave func y el nombre del método, vinculando la función a un tipo.
Receptor por valor
Un receptor por valor recibe una copia del struct. Úselo cuando el método no necesite modificar el estado:
package main
import "fmt"
type Circle struct{ Radius float64 }
func (c Circle) Area() float64 {
return 3.14159 * c.Radius * c.Radius
}
func main() {
c := Circle{Radius: 5}
fmt.Printf("%.2f\n", c.Area()) // 78.54
}Receptor por puntero
Un receptor por puntero permite que el método modifique el struct. Es más eficiente para structs grandes:
package main
import "fmt"
type Counter struct{ N int }
func (c *Counter) Increment() { c.N++ }
func (c *Counter) Reset() { c.N = 0 }
func main() {
c := Counter{}
c.Increment(); c.Increment()
fmt.Println(c.N) // 2
c.Reset()
fmt.Println(c.N) // 0
}Cuándo usar receptores por puntero
Use receptores por puntero cuando:
- El método necesite modificar el receptor
- El struct sea grande (evita copiarlo)
- Busque coherencia: si algún método tiene un receptor por puntero, todos deberían tenerlo
Use receptores por valor cuando el struct sea pequeño y el método solo lea datos.
Expresiones y valores de método
Los métodos se pueden usar como valores de primera clase:
package main
import "fmt"
type Adder struct{ Base int }
func (a Adder) Add(n int) int { return a.Base + n }
func main() {
a := Adder{Base: 10}
fn := a.Add // method value — bound to a
fmt.Println(fn(5)) // 15
}Métodos en tipos que no son structs
Puede definir métodos en cualquier tipo con nombre del mismo paquete, no solo en structs:
package main
import "fmt"
type Celsius float64
func (c Celsius) ToFahrenheit() float64 {
return float64(c)*9/5 + 32
}
func main() {
t := Celsius(100)
fmt.Println(t.ToFahrenheit()) // 212
}Desreferenciación automática de punteros
Go obtiene automáticamente la dirección o desreferencia el puntero al llamar a los métodos. No necesita escribir (&c).Method() manualmente:
package main
import "fmt"
type Box struct{ Val int }
func (b *Box) Double() { b.Val *= 2 }
func main() {
b := Box{Val: 5}
b.Double() // Go auto-takes address
fmt.Println(b.Val) // 10
}Encadenamiento de métodos
Devuelva el puntero al receptor para habilitar el encadenamiento de métodos (patrón builder):
package main
import "fmt"
type Builder struct{ result string }
func (b *Builder) Add(s string) *Builder {
b.result += s
return b
}
func (b *Builder) Build() string { return b.result }
func main() {
s := (&Builder{}).Add("Hello").Add(", ").Add("World").Build()
fmt.Println(s)
}Método String (fmt.Stringer)
Implemente el método String() string para controlar cómo se muestra un tipo:
package main
import "fmt"
type Point struct{ X, Y int }
func (p Point) String() string {
return fmt.Sprintf("(%d, %d)", p.X, p.Y)
}
func main() {
p := Point{3, 4}
fmt.Println(p) // (3, 4)
}Receptores de puntero nil
Se puede llamar a un método con receptor por puntero sobre un puntero nil, lo que resulta útil para comportamientos predeterminados:
package main
import "fmt"
type Node struct{ Val int }
func (n *Node) Value() int {
if n == nil { return 0 }
return n.Val
}
func main() {
var n *Node
fmt.Println(n.Value()) // 0
}Principio de coherencia
En la biblioteca estándar de Go y en el Go idiomático, todos los métodos de un tipo usan la misma clase de receptor: todos por puntero o todos por valor. Mezclarlos provoca errores sutiles con las interfaces.
Comprobación rápida
¿Qué tipo de receptor permite que un método modifique los campos del struct?
Recapitulación: métodos
Conclusiones principales:
- Los métodos tienen un receptor entre
funcy el nombre - Receptores por valor: solo lectura y structs pequeños
- Receptores por puntero: modificación, structs grandes y coherencia
- Go desreferencia automáticamente; no es necesario escribir
(&v).Method() - Implemente
String() stringpara personalizar la representación
Ejercicio práctico
Defina un struct BankAccount con un campo Balance float64. Añada los métodos Deposit y Withdraw con receptores por puntero, y un método String() con receptor por valor.
Preguntas frecuentes
¿La lección «Métodos en structs» es gratis?
Sí — el texto completo de «Métodos en structs» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Métodos en structs»?
Receivers por valor frente a receivers por puntero Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Go Academy?
No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Métodos en structs»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Go Academy?
Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Definición y uso de structs
- Métodos en structs
- Patrones de constructores
- Structs anónimos y composición