Go Academy · Lektion

Interne Packages und Workspaces

internal/, replace-Direktiven und go work

Interne Packages und Workspaces ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Das internal/-Verzeichnis

Packages innerhalb eines internal/-Verzeichnisses können nur von Code im übergeordneten Verzeichnisbaum importiert werden. Dadurch wird die Kapselung von Packages erzwungen:

// 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

internal/-Packages verwenden

Code innerhalb desselben Moduls (oberhalb des internal/-Verzeichnisses) kann interne Packages ohne Einschränkungen importieren:

// 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)
}

Warum internal/ verwenden?

Vorteile der internal/-Konvention:

Verhindert, dass andere Module von Implementierungsdetails abhängig werden
Ermöglicht freies Refactoring, ohne externe Aufrufer zu beeinträchtigen
Vermittelt klar: Dies ist nicht Teil der öffentlichen API
Die standardmäßigen Go-Tools erzwingen die Einschränkung zur Compile-Zeit

Go-Workspaces — go work

Go 1.18 führte Workspaces ein, um gleichzeitig mit mehreren lokalen Modulen zu arbeiten, ohne replace-Direktiven zu verwenden:

# 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

Synchronisieren Sie Workspace-Abhängigkeiten mit 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 ./...

Workspace vs. replace-Direktive

Vergleich zweier Ansätze für die lokale Entwicklung mit mehreren Modulen:

// 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

Anwendungsfälle für Workspaces

Wann Sie Go-Workspaces verwenden sollten:

Eine Bibliothek und ihren Consumer gleichzeitig entwickeln
Monorepo mit mehreren Modulen, die aufeinander verweisen
Änderungen an einem gemeinsamen Modul vor der Veröffentlichung testen
Parallel zur eigenen Anwendung an einem Fork einer Abhängigkeit arbeiten

go work add und go work use

Verwalten Sie Workspace-Einträge mit den Unterbefehlen von 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 und Workspace gemeinsam verwenden

Interne Packages und Workspaces lassen sich in Monorepos problemlos kombinieren:

// 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)

Bewährte Vorgehensweisen für die Package-Organisation

Empfehlungen für das Layout von Go-Projekten:

Flache Package-Struktur für kleine Projekte — vermeiden Sie eine zu frühe Strukturierung
Verwenden Sie internal/ für Implementierungsdetails, die nicht für die externe Nutzung bestimmt sind
Legen Sie CLI-main-Packages unter cmd/appname/ ab
Verwenden Sie Workspaces für Repositories mit mehreren Modulen, aber nehmen Sie go.work in die Gitignore auf
Vermeiden Sie tiefe Verschachtelungen — maximal 3–4 Package-Ebenen

Wissenscheck

Wer kann ein Package in einem internal/-Verzeichnis importieren?

Zusammenfassung: Interne Packages und Workspaces

Zusammenfassung:

internal/ beschränkt Importe auf den übergeordneten Verzeichnisbaum — der Compiler erzwingt diese Einschränkung
Verwenden Sie internal/, um Implementierungsdetails vor externen Nutzern zu verbergen
go work init erstellt einen Workspace für die lokale Entwicklung mit mehreren Modulen
Workspaces ersetzen replace-Direktiven bei der lokalen Entwicklung
Nehmen Sie go.work und go.work.sum in die Gitignore auf

Häufig gestellte Fragen

Ist die Lektion „Interne Packages und Workspaces“ kostenlos?

Ja — der vollständige Text von „Interne Packages und Workspaces“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Interne Packages und Workspaces“?

internal/, replace-Direktiven und go work Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Interne Packages und Workspaces“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Go Academy