Fundamentos de la Filosofía de Go

10 ejemplos para empezar con la Filosofía de Go: 7 básicos y 3 intermedios.

Prerrequisitos

Go 1.26.x instalado (go version).
No se requieren módulos de terceros para estos fragmentos; todos usan la biblioteca estándar.

Ejemplos Básicos

1. `main` Mínimo - Claridad Primero

Go favorece un punto de entrada corto que conecta dependencias y ejecuta.

package main
 
import "fmt"
 
func main() {
    fmt.Println("despliega programas pequeños y legibles")
}

package main marca un ejecutable; el código de biblioteca usa otros nombres de paquete.
Un único main obvio mantiene el flujo de inicio fácil de auditar durante incidentes.
La lógica de negocio pertenece a paquetes que puedes probar sin iniciar un proceso.

Relacionado: Por qué existe Go - los objetivos de diseño detrás de este diseño

2. Manejo Explícito de Errores

Los errores son valores devueltos junto con los resultados, no excepciones lanzadas.

package main
 
import (
    "fmt"
    "os"
)
 
func readConfig(path string) ([]byte, error) {
    return os.ReadFile(path)
}
 
func main() {
    data, err := readConfig("config.yaml")
    if err != nil {
        fmt.Fprintf(os.Stderr, "error al leer config: %v\n", err)
        os.Exit(1)
    }
    fmt.Printf("cargados %d bytes\n", len(data))
}

Los llamadores manejan los fallos en el sitio de llamada; las trazas de pila no son el flujo de control por defecto.
if err != nil es repetitivo por diseño; mantiene las rutas de fallo visibles en la revisión.
Envolver con fmt.Errorf("error al leer config: %w", err) preserva las causas para los logs.

Relacionado: La Simplicidad como Restricción Deliberada en el Diseño de API - por qué las API devuelven errores simples

3. Interfaz Pequeña en el Sitio de Llamada

Go define interfaces donde se consumen, no donde se declaran los tipos.

package notify
 
import "context"
 
type Sender interface {
    Send(ctx context.Context, msg string) error
}
 
func Deliver(ctx context.Context, s Sender, msg string) error {
    return s.Send(ctx, msg)
}

Las interfaces se mantienen pequeñas, a menudo con uno o dos métodos, por lo que los fakes son triviales en las pruebas.
Los tipos concretos no necesitan "implementar" nada explícitamente; la satisfacción es implícita.
Este patrón favorece la composición y desalienta los árboles de herencia profundos.

4. Goroutine para Trabajo Concurrente

La concurrencia es una característica de primera clase del lenguaje, no solo una preocupación de la biblioteca.

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    ch := make(chan string, 1)
    go func() {
        time.Sleep(50 * time.Millisecond)
        ch <- "listo"
    }()
    fmt.Println(<-ch)
}

go inicia una función de forma concurrente; el runtime la programa en hilos del sistema operativo.
Los canales pasan datos entre goroutines y expresan la transferencia de propiedad.
Siempre ten en cuenta cómo sale una goroutine; las fugas se manifiestan como crecimiento de memoria y FDs.

Relacionado: Por qué existe Go - modelo de concurrencia inspirado en CSP

5. `defer` para Limpieza Confiable

Defer registra la limpieza que se ejecuta cuando la función circundante retorna.

package main
 
import (
    "fmt"
    "os"
)
 
func writeTemp() error {
    f, err := os.CreateTemp("", "demo-*.txt")
    if err != nil {
        return err
    }
    defer func() {
        f.Close()
        os.Remove(f.Name())
    }()
    _, err = f.WriteString("hola")
    return err
}
 
func main() {
    if err := writeTemp(); err != nil {
        panic(err)
    }
    fmt.Println("ok")
}

defer empareja la adquisición con la liberación, incluso cuando existen múltiples rutas de retorno.
Los defer se ejecutan LIFO al salir de la función, útil para bloqueos y archivos anidados.
Prefiere defer sobre la duplicación manual de limpieza en funciones largas.

6. Biblioteca Estándar sobre Proliferación de Frameworks

Go incluye herramientas para HTTP, JSON, TLS y testing en la cadena de herramientas que ya tienes.

package main
 
import (
    "encoding/json"
    "net/http"
)
 
type Health struct {
    Status string `json:"status"`
}
 
func main() {
    http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        _ = json.NewEncoder(w).Encode(Health{Status: "ok"})
    })
    http.ListenAndServe(":8080", nil)
}

net/http es capaz de producción para muchos servicios antes de recurrir a Gin, Echo o chi.
Menos dependencias significan superficies de auditoría más pequeñas y go test más rápidos en CI.
Los frameworks siguen siendo útiles cuando necesitas enrutamiento, enlace o ecosistemas de middleware con opinión.

Relacionado: Dominios Objetivo de Go - valores predeterminados nativos de la nube

7. Pruebas Basadas en Tablas Codifican las Expectativas del Equipo

Las pruebas documentan el comportamiento como filas de datos, coincidiendo con la preferencia de Go por la explicitud.

package mathx
 
import "testing"
 
func Add(a, b int) int { return a + b }
 
func TestAdd(t *testing.T) {
    cases := []struct {
        a, b, want int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }
    for _, tc := range cases {
        if got := Add(tc.a, tc.b); got != tc.want {
            t.Fatalf("Add(%d,%d)=%d, quiero %d", tc.a, tc.b, got, tc.want)
        }
    }
}

Las pruebas de tabla escalan a casos extremos sin bloques de aserción copiados y pegados.
go test es el punto de entrada universal de CI, no se requiere un ejecutor de pruebas adicional.
Los casos fallidos se nombran a sí mismos a través de los datos, lo que ayuda a la revisión del código.

Ejemplos Intermedios

8. `context.Context` en los Límites de la API

La cancelación y los plazos se propagan a través de los servicios al estilo Go.

package fetch
 
import (
    "context"
    "io"
    "net/http"
    "time"
)
 
func Get(ctx context.Context, url string) ([]byte, error) {
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
    if err != nil {
        return nil, err
    }
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    return io.ReadAll(resp.Body)
}
 
func GetWithTimeout(url string, d time.Duration) ([]byte, error) {
    ctx, cancel := context.WithTimeout(context.Background(), d)
    defer cancel()
    return Get(ctx, url)
}

El contexto es el primer parámetro estándar para las API de E/S.
Los padres cancelan a los hijos cuando los clientes se desconectan o expiran los plazos.
Pasar context.Background() solo en el main o el test harness más externo mantiene los árboles coherentes.

Relacionado: Dominios Objetivo de Go - límites de servicios distribuidos

9. Aceptar Interfaces, Devolver Estructuras

Las funciones públicas dependen de interfaces estrechas; los constructores exponen tipos concretos.

package storage
 
import "context"
 
type Store interface {
    Put(ctx context.Context, key string, value []byte) error
}
 
type FileStore struct {
    dir string
}
 
func NewFileStore(dir string) *FileStore {
    return &FileStore{dir: dir}
}
 
func (f *FileStore) Put(ctx context.Context, key string, value []byte) error {
    // implementación omitida
    return nil
}
 
func Save(ctx context.Context, s Store, key string, value []byte) error {
    return s.Put(ctx, key, value)
}

Los llamadores de Save simulan Store sin importar los detalles internos de FileStore.
Los constructores (NewFileStore) documentan la inicialización válida en un solo lugar.
Esta es la alternativa idiomática a los frameworks de DI con muchas fábricas.

Relacionado: La Simplicidad como Restricción Deliberada en el Diseño de API - dar forma a API de paquetes estables

10. Bosquejo de Decisión - Cuándo No Elegir Go por Defecto

La filosofía incluye saber dónde gana otro lenguaje.

// Go sobresale: CLI binaria estática con flags y subcomandos.
// Considera Rust: rendimiento cercano al firmware sin GC.
// Considera Python: ciencia de datos exploratoria con iteración de notebooks.
// Considera JVM: integraciones empresariales maduras que tu equipo ya opera.
 
package main
 
import "fmt"
 
func main() {
    fmt.Println("elige Go cuando la velocidad del equipo y la operabilidad dominen el ADR")
}

Empareja el lenguaje con el riesgo dominante: umbral de latencia, grupo de talentos, paquetes del ecosistema o herramientas de cumplimiento.
Go es una opción predeterminada sólida para servicios en red, no un martillo universal.
Documenta la decisión en un ADR para que los equipos futuros hereden el razonamiento.

Relacionado: Cuándo Go Es la Herramienta Equivocada - contraejemplos concretos | Go vs Rust - compensaciones de sistemas

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

Prerrequisitos

Go 1.26.x instalado (go version).
No se requieren módulos de terceros para estos fragmentos; todos usan la biblioteca estándar.

Ejemplos Básicos

1. `main` Mínimo - Claridad Primero

Go favorece un punto de entrada corto que conecta dependencias y ejecuta.

package main
 
import "fmt"
 
func main() {
    fmt.Println("despliega programas pequeños y legibles")
}

package main marca un ejecutable; el código de biblioteca usa otros nombres de paquete.
Un único main obvio mantiene el flujo de inicio fácil de auditar durante incidentes.
La lógica de negocio pertenece a paquetes que puedes probar sin iniciar un proceso.

Relacionado: Por qué existe Go - los objetivos de diseño detrás de este diseño

2. Manejo Explícito de Errores

Los errores son valores devueltos junto con los resultados, no excepciones lanzadas.

package main
 
import (
    "fmt"
    "os"
)
 
func readConfig(path string) ([]byte, error) {
    return os.ReadFile(path)
}
 
func main() {
    data, err := readConfig("config.yaml")
    if err != nil {
        fmt.Fprintf(os.Stderr, "error al leer config: %v\n", err)
        os.Exit(1)
    }
    fmt.Printf("cargados %d bytes\n", len(data))
}

Los llamadores manejan los fallos en el sitio de llamada; las trazas de pila no son el flujo de control por defecto.
if err != nil es repetitivo por diseño; mantiene las rutas de fallo visibles en la revisión.
Envolver con fmt.Errorf("error al leer config: %w", err) preserva las causas para los logs.

Relacionado: La Simplicidad como Restricción Deliberada en el Diseño de API - por qué las API devuelven errores simples

3. Interfaz Pequeña en el Sitio de Llamada

Go define interfaces donde se consumen, no donde se declaran los tipos.

package notify
 
import "context"
 
type Sender interface {
    Send(ctx context.Context, msg string) error
}
 
func Deliver(ctx context.Context, s Sender, msg string) error {
    return s.Send(ctx, msg)
}

Las interfaces se mantienen pequeñas, a menudo con uno o dos métodos, por lo que los fakes son triviales en las pruebas.
Los tipos concretos no necesitan "implementar" nada explícitamente; la satisfacción es implícita.
Este patrón favorece la composición y desalienta los árboles de herencia profundos.

4. Goroutine para Trabajo Concurrente

La concurrencia es una característica de primera clase del lenguaje, no solo una preocupación de la biblioteca.

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    ch := make(chan string, 1)
    go func() {
        time.Sleep(50 * time.Millisecond)
        ch <- "listo"
    }()
    fmt.Println(<-ch)
}

go inicia una función de forma concurrente; el runtime la programa en hilos del sistema operativo.
Los canales pasan datos entre goroutines y expresan la transferencia de propiedad.
Siempre ten en cuenta cómo sale una goroutine; las fugas se manifiestan como crecimiento de memoria y FDs.

Relacionado: Por qué existe Go - modelo de concurrencia inspirado en CSP

5. `defer` para Limpieza Confiable

Defer registra la limpieza que se ejecuta cuando la función circundante retorna.

package main
 
import (
    "fmt"
    "os"
)
 
func writeTemp() error {
    f, err := os.CreateTemp("", "demo-*.txt")
    if err != nil {
        return err
    }
    defer func() {
        f.Close()
        os.Remove(f.Name())
    }()
    _, err = f.WriteString("hola")
    return err
}
 
func main() {
    if err := writeTemp(); err != nil {
        panic(err)
    }
    fmt.Println("ok")
}

defer empareja la adquisición con la liberación, incluso cuando existen múltiples rutas de retorno.
Los defer se ejecutan LIFO al salir de la función, útil para bloqueos y archivos anidados.
Prefiere defer sobre la duplicación manual de limpieza en funciones largas.

6. Biblioteca Estándar sobre Proliferación de Frameworks

Go incluye herramientas para HTTP, JSON, TLS y testing en la cadena de herramientas que ya tienes.

package main
 
import (
    "encoding/json"
    "net/http"
)
 
type Health struct {
    Status string `json:"status"`
}
 
func main() {
    http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        _ = json.NewEncoder(w).Encode(Health{Status: "ok"})
    })
    http.ListenAndServe(":8080", nil)
}

net/http es capaz de producción para muchos servicios antes de recurrir a Gin, Echo o chi.
Menos dependencias significan superficies de auditoría más pequeñas y go test más rápidos en CI.
Los frameworks siguen siendo útiles cuando necesitas enrutamiento, enlace o ecosistemas de middleware con opinión.

Relacionado: Dominios Objetivo de Go - valores predeterminados nativos de la nube

7. Pruebas Basadas en Tablas Codifican las Expectativas del Equipo

Las pruebas documentan el comportamiento como filas de datos, coincidiendo con la preferencia de Go por la explicitud.

package mathx
 
import "testing"
 
func Add(a, b int) int { return a + b }
 
func TestAdd(t *testing.T) {
    cases := []struct {
        a, b, want int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }
    for _, tc := range cases {
        if got := Add(tc.a, tc.b); got != tc.want {
            t.Fatalf("Add(%d,%d)=%d, quiero %d", tc.a, tc.b, got, tc.want)
        }
    }
}

Las pruebas de tabla escalan a casos extremos sin bloques de aserción copiados y pegados.
go test es el punto de entrada universal de CI, no se requiere un ejecutor de pruebas adicional.
Los casos fallidos se nombran a sí mismos a través de los datos, lo que ayuda a la revisión del código.

Ejemplos Intermedios

8. `context.Context` en los Límites de la API

La cancelación y los plazos se propagan a través de los servicios al estilo Go.

package fetch
 
import (
    "context"
    "io"
    "net/http"
    "time"
)
 
func Get(ctx context.Context, url string) ([]byte, error) {
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
    if err != nil {
        return nil, err
    }
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    return io.ReadAll(resp.Body)
}
 
func GetWithTimeout(url string, d time.Duration) ([]byte, error) {
    ctx, cancel := context.WithTimeout(context.Background(), d)
    defer cancel()
    return Get(ctx, url)
}

El contexto es el primer parámetro estándar para las API de E/S.
Los padres cancelan a los hijos cuando los clientes se desconectan o expiran los plazos.
Pasar context.Background() solo en el main o el test harness más externo mantiene los árboles coherentes.

Relacionado: Dominios Objetivo de Go - límites de servicios distribuidos

9. Aceptar Interfaces, Devolver Estructuras

Las funciones públicas dependen de interfaces estrechas; los constructores exponen tipos concretos.

package storage
 
import "context"
 
type Store interface {
    Put(ctx context.Context, key string, value []byte) error
}
 
type FileStore struct {
    dir string
}
 
func NewFileStore(dir string) *FileStore {
    return &FileStore{dir: dir}
}
 
func (f *FileStore) Put(ctx context.Context, key string, value []byte) error {
    // implementación omitida
    return nil
}
 
func Save(ctx context.Context, s Store, key string, value []byte) error {
    return s.Put(ctx, key, value)
}

Los llamadores de Save simulan Store sin importar los detalles internos de FileStore.
Los constructores (NewFileStore) documentan la inicialización válida en un solo lugar.
Esta es la alternativa idiomática a los frameworks de DI con muchas fábricas.

Relacionado: La Simplicidad como Restricción Deliberada en el Diseño de API - dar forma a API de paquetes estables

10. Bosquejo de Decisión - Cuándo No Elegir Go por Defecto

La filosofía incluye saber dónde gana otro lenguaje.

// Go sobresale: CLI binaria estática con flags y subcomandos.
// Considera Rust: rendimiento cercano al firmware sin GC.
// Considera Python: ciencia de datos exploratoria con iteración de notebooks.
// Considera JVM: integraciones empresariales maduras que tu equipo ya opera.
 
package main
 
import "fmt"
 
func main() {
    fmt.Println("elige Go cuando la velocidad del equipo y la operabilidad dominen el ADR")
}

Empareja el lenguaje con el riesgo dominante: umbral de latencia, grupo de talentos, paquetes del ecosistema o herramientas de cumplimiento.
Go es una opción predeterminada sólida para servicios en red, no un martillo universal.
Documenta la decisión en un ADR para que los equipos futuros hereden el razonamiento.

Relacionado: Cuándo Go Es la Herramienta Equivocada - contraejemplos concretos | Go vs Rust - compensaciones de sistemas

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

Fundamentos de la Filosofía de Go

Buscar en la documentación

Fundamentos de la Filosofía de Go