Go Academy · Lección

Packages internos y workspaces

internal/, directivas replace y go work

Packages internos y workspaces es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 4 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.

El directorio internal/

Los paquetes dentro de un directorio internal/ solo pueden ser importados por código del árbol de directorios padre. Esto garantiza la encapsulación del paquete:

// Project structure:
// myapp/
//   main.go
//   internal/
//     auth/auth.go      <- can only be imported by myapp/
//     db/db.go          <- can only be imported by myapp/
//   api/
//     handlers.go       <- can import myapp/internal/auth

// External package CANNOT do:
// import "myapp/internal/auth"  <- compile error

Usar paquetes internal/

El código del mismo módulo (situado por encima del directorio internal/) puede importar libremente los paquetes internos:

// myapp/api/handlers.go
package api

import (
    "myapp/internal/auth"
    "myapp/internal/db"
)

func GetUser(id int) (*db.User, error) {
    if !auth.IsValid() {
        return nil, auth.ErrUnauthorized
    }
    return db.FindUser(id)
}

¿Por qué usar internal/?

Ventajas de la convención internal/:

Impide que otros módulos dependan de detalles de implementación
Permite refactorizar libremente sin romper a los usuarios externos
Indica claramente que esto no forma parte de la API pública
Las herramientas estándar de Go hacen cumplir la restricción en tiempo de compilación

Espacios de trabajo de Go — go work

Go 1.18 introdujo los espacios de trabajo para trabajar simultáneamente con varios módulos locales sin utilizar directivas replace:

# Create a workspace in parent directory:
go work init ./myapp ./mylib

# Creates go.work:
# go 1.21
# use (
#     ./myapp
#     ./mylib
# )

# Now myapp can import mylib without replace directives

go work sync

Sincronice las dependencias del espacio de trabajo con go work sync:

# go.work file:
go 1.21

use (
    ./api
    ./worker
    ./shared
)

# Sync all module dependencies:
go work sync

# Build across all workspace modules:
go build ./...

# Test across all workspace modules:
go test ./...

Espacio de trabajo frente a directiva replace

Comparación de dos enfoques para el desarrollo local con varios módulos:

// BEFORE workspaces (cumbersome):
// go.mod in myapp:
// replace github.com/me/mylib => ../mylib
// Must remove before publishing!

// WITH workspaces (cleaner):
// go.work at root:
// use (./myapp ./mylib)
// go.mod files stay clean — go.work is gitignored

Casos de uso de los espacios de trabajo

Cuándo utilizar espacios de trabajo de Go:

Desarrollar simultáneamente una biblioteca y el código que la utiliza
Un monorepo con varios módulos que hacen referencia entre sí
Probar cambios en un módulo compartido antes de publicarlo
Trabajar en un fork de una dependencia junto con su aplicación

go work add y go work use

Administre las entradas del espacio de trabajo con los subcomandos de go work:

# Add a module to the workspace
go work use ./newservice

# Remove a module from workspace
go work use -r ./oldservice

# Edit go.work directly (opens $EDITOR):
go work edit

# go.work should usually be gitignored:
echo "go.work" >> .gitignore
echo "go.work.sum" >> .gitignore

internal/ y espacios de trabajo juntos

Los paquetes internos y los espacios de trabajo se combinan de forma natural en los monorepos:

// Monorepo structure:
// services/
//   go.work
//   auth-service/
//     internal/tokens/   <- private to auth-service
//   order-service/
//     internal/pricing/  <- private to order-service
//   shared/
//     models/            <- shared across services

// go.work:
// use (./auth-service ./order-service ./shared)

Prácticas recomendadas para organizar paquetes

Recomendaciones para la estructura de proyectos de Go:

Estructura de paquetes plana para proyectos pequeños; evite organizar el código prematuramente
Use internal/ para los detalles de implementación que no estén destinados a uso externo
Coloque los paquetes principales de CLI en cmd/appname/
Use espacios de trabajo para repositorios con varios módulos, pero incluya go.work en gitignore
Evite el anidamiento profundo: como máximo, 3 o 4 niveles de paquetes

Comprobación rápida

¿Quién puede importar un paquete situado en un directorio internal/?

Resumen: paquetes internos y espacios de trabajo

Resumen:

internal/ restringe las importaciones al árbol de directorios padre; el compilador hace cumplir esta restricción
Use internal/ para ocultar los detalles de implementación a los consumidores externos
go work init crea un espacio de trabajo para el desarrollo local con varios módulos
Los espacios de trabajo sustituyen las directivas replace para el desarrollo local
Incluya go.work y go.work.sum en gitignore

Preguntas frecuentes

¿La lección «Packages internos y workspaces» es gratis?

Sí — el texto completo de «Packages internos y workspaces» 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 «Packages internos y workspaces»?

internal/, directivas replace y go work 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 4 de 4.

¿Cuánto tiempo toma la lección «Packages internos y workspaces»?

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

← Volver a Go Academy