Conceptos básicos de funciones y métodos

10 ejemplos para empezar con Funciones e Interfaces: 7 básicos y 3 intermedios.

Prerrequisitos

• Go 1.26.x instalado (go version).
• No se requieren módulos de terceros: los fragmentos solo usan la biblioteca estándar.

Ejemplos básicos

1. Función nombrada con retornos múltiples

Las funciones de Go devuelven valores explícitos, a menudo un resultado más un error.

package main
 
import (
    "fmt"
    "strconv"
)
 
func parsePort(s string) (int, error) {
    return strconv.Atoi(s)
}
 
func main() {
    port, err := parsePort("8080")
    if err != nil {
        fmt.Println("parse:", err)
        return
    }
    fmt.Println("listening on", port)
}

• Los valores de retorno múltiples reemplazan los parámetros de salida y los canales de efectos secundarios de excepciones.
• Los llamadores deben manejar el error en el punto de llamada: el flujo de control permanece visible.
• Los valores cero se aplican cuando se ignora un retorno con _.

Relacionado: Retornos Múltiples, Retornos Nombrados y Retornos Desnudos - cuándo nombrar resultados

2. Método con Receptor de Valor

Los métodos adjuntan comportamiento a los tipos; los receptores de valor operan sobre una copia.

package main
 
import "fmt"
 
type Counter struct {
    n int
}
 
func (c Counter) Value() int {
    return c.n
}
 
func main() {
    c := Counter{n: 3}
    fmt.Println(c.Value())
}

• El receptor (c Counter) copia la estructura para el cuerpo del método.
• Los accesores de solo lectura a menudo usan receptores de valor para evitar mutaciones accidentales.
• Los métodos son solo funciones con un parámetro receptor.

Relacionado: Métodos: Receptores de Valor vs. Puntero - elección del tipo de receptor

3. Método con Receptor de Puntero

Los receptores de puntero mutan el valor original y manejan estructuras más grandes de manera eficiente.

package main
 
import "fmt"
 
type Counter struct {
    n int
}
 
func (c *Counter) Inc() {
    c.n++
}
 
func main() {
    c := &Counter{}
    c.Inc()
    c.Inc()
    fmt.Println(c.n)
}

• (c *Counter) permite que Inc modifique el estado del llamador.
• Go toma automáticamente la dirección al llamar c.Inc() en una variable de valor.
• La consistencia importa: mezclar tipos de receptores en un mismo tipo confunde la satisfacción de interfaces.

4. Interfaz del Lado del Consumidor

Las interfaces se satisfacen implícitamente cuando los métodos coinciden.

package main
 
import "fmt"
 
type Stringer interface {
    String() string
}
 
type User struct {
    Name string
}
 
func (u User) String() string {
    return "user:" + u.Name
}
 
func printLabel(s Stringer) {
    fmt.Println(s.String())
}
 
func main() {
    printLabel(User{Name: "ada"})
}

• User nunca menciona Stringer: el compilador lo verifica en la asignación.
• Define interfaces donde se consumen para mantener las dependencias estrechas.
• Las interfaces pequeñas hacen que los dobles de prueba sean triviales.

Relacionado: Definición e Implementación de Interfaces - patrones de diseño de API

5. Tipo de Función y Valor

Las funciones son valores de primera clase con sus propios tipos nombrados.

package main
 
import "fmt"
 
type Op func(int, int) int
 
func apply(a, b int, op Op) int {
    return op(a, b)
}
 
func main() {
    add := func(x, y int) int { return x + y }
    fmt.Println(apply(2, 3, add))
}

• type Op func(...) documenta la intención mejor que repetir func(int,int) int.
• Los valores de función pueden capturar variables (clausuras) - ver ejemplos intermedios.
• Las funciones de orden superior reemplazan parte de la ceremonia de la interfaz para ganchos únicos.

Relacionado: Funciones Variádicas y Tipos de Función - patrones variádicos y HOF

6. Parámetro Variádico

El último parámetro puede absorber una lista de argumentos variable.

package main
 
import "fmt"
 
func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}
 
func main() {
    fmt.Println(sum(1, 2, 3, 4))
}

• nums ...int es un slice dentro de la función ([]int).
• Los llamadores pueden pasar cero o muchos argumentos; también puedes expandir un slice con sum(vals...).
• Variadic debe ser el último parámetro en la firma.

7. Parámetros de Resultado Nombrados

Los nombres de resultado actúan como variables en el cuerpo de la función y aparecen en la documentación.

package main
 
import "fmt"
 
func divide(a, b float64) (quot float64, ok bool) {
    if b == 0 {
        return 0, false
    }
    quot = a / b
    ok = true
    return
}
 
func main() {
    q, ok := divide(10, 2)
    fmt.Println(q, ok)
}

• Los resultados nombrados se inicializan a valores cero al entrar en la función.
• Un return desnudo devuelve los valores nombrados actuales; úsalo con moderación para mayor claridad.
• Útil en funciones cortas con muchos defer; perjudicial cuando oscurecen la lógica.

Relacionado: Retornos Múltiples, Retornos Nombrados y Retornos Desnudos - compensaciones de los retornos desnudos

Ejemplos intermedios

8. Clausura Capturando Variable de Bucle (Patrón Seguro)

Las clausuras capturan variables por referencia; los iteradores de bucle necesitan una copia local por iteración.

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    var wg sync.WaitGroup
    for i := 0; i < 3; i++ {
        i := i
        wg.Add(1)
        go func() {
            defer wg.Done()
            fmt.Println(i)
        }()
    }
    wg.Wait()
}

• Sin i := i, las gorutinas pueden observar el valor final del bucle.
• defer wg.Done() se empareja con Add para un cierre limpio del trabajo concurrente.
• Prefiere pasar variables de bucle como parámetros de función cuando la clausura se reutiliza.

Relacionado: Literales de Función y Clausuras - patrones de fábrica y middleware

9. Aceptar Interfaz, Devolver Estructura

Conecta las dependencias a través de interfaces pequeñas; los constructores devuelven tipos concretos.

package main
 
import (
    "context"
    "fmt"
)
 
type Notifier interface {
    Notify(ctx context.Context, msg string) error
}
 
type Logger struct{}
 
func (Logger) Notify(ctx context.Context, msg string) error {
    fmt.Println("notify:", msg)
    return nil
}
 
type Service struct {
    n Notifier
}
 
func NewService(n Notifier) *Service {
    return &Service{n: n}
}
 
func (s *Service) Run(ctx context.Context) error {
    return s.n.Notify(ctx, "ready")
}
 
func main() {
    svc := NewService(Logger{})
    _ = svc.Run(context.Background())
}

• NewService acepta Notifier para pruebas; devuelve *Service como API concreta.
• Pasa context.Context como primer parámetro en los límites de E/S.
• Mantiene los paquetes componibles sin herencia ni frameworks de DI.

Relacionado: Funciones e Interfaces: El Modelo de Composición de Go - modelo mental para la composición

10. Nil de Tipo en una Variable de Interfaz

Un puntero nil almacenado en una interfaz no es igual a una interfaz nil sin tipo.

package main
 
import "fmt"
 
type Worker interface {
    Work() error
}
 
type job struct{}
 
func (j *job) Work() error { return nil }
 
func main() {
    var w Worker = (*job)(nil)
    fmt.Println(w == nil)
}

• w contiene el tipo *job con valor nil; la interfaz en sí misma no es nil.
• if w == nil falla a pesar de que no existe una instancia concreta.
• Devuelve interfaces solo cuando es necesario; documenta explícitamente que "nil significa ausente".

Relacionado: Interfaz Nil vs. Puntero Nil - diseños de API que evitan la trampa

Versiones de Stack: Esta página fue escrita para Go 1.26.x (predeterminado GC de Green Tea, modernizadores de go fix - verificar parche en la compilación), chi (última versión - verificar en la compilación), gin (última versión - verificar en la compilación), echo (última versión - verificar en la compilación), google.golang.org/grpc (última versión - verificar en la compilación), sigs.k8s.io/controller-runtime (última versión - verificar en la compilación), kubebuilder (última versión - verificar en la compilación), tinygo (última versión - verificar objetivos de placa en la compilación), wazero (última versión - verificar en la compilación) y golangci-lint (última versión - verificar conjunto de linters en la compilación).