0Pricing
Go Academy · Lezione

Package interni e workspace

internal/, direttive replace e go work

Package interni e workspace è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

La directory internal/

I pacchetti all'interno di una directory internal/ possono essere importati solo dal codice che si trova nell'albero di directory del genitore. Questo impone l'incapsulamento dei pacchetti:

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

Usare i pacchetti internal/

Il codice dello stesso modulo (al di sopra della directory internal/) può importare liberamente i pacchetti interni:

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

Perché usare internal/?

Vantaggi della convenzione internal/:

  • Impedisce agli altri moduli di dipendere dai dettagli di implementazione
  • Permette di effettuare il refactoring liberamente senza interrompere i chiamanti esterni
  • Segnala chiaramente che questo non fa parte dell'API pubblica
  • Gli strumenti standard di Go applicano la restrizione in fase di compilazione

Aree di lavoro Go — go work

Go 1.18 ha introdotto le aree di lavoro per lavorare contemporaneamente con più moduli locali senza direttive 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

Sincronizza le dipendenze dell'area di lavoro 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 ./...

Area di lavoro e direttiva replace a confronto

Confronto tra due approcci per lo sviluppo locale con più moduli:

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

Casi d'uso delle aree di lavoro

Quando usare le aree di lavoro Go:

  • Sviluppare contemporaneamente una libreria e il relativo consumer
  • Gestire un monorepo con più moduli che fanno riferimento l'uno all'altro
  • Testare le modifiche a un modulo condiviso prima di pubblicarlo
  • Lavorare sul fork di una dipendenza insieme alla propria app

go work add e go work use

Gestisci le voci dell'area di lavoro con i sottocomandi di 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/ e workspace insieme

I pacchetti interni e le aree di lavoro si combinano naturalmente nei monorepo:

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

Best practice per l'organizzazione dei pacchetti

Raccomandazioni per la struttura dei progetti Go:

  • Struttura dei pacchetti piatta per i progetti piccoli: evita di organizzare il codice troppo presto
  • Usa internal/ per i dettagli di implementazione non destinati all'uso esterno
  • Colloca i pacchetti main delle CLI in cmd/appname/
  • Usa le aree di lavoro per i repository con più moduli, ma aggiungi go.work al gitignore
  • Evita la nidificazione profonda: non superare 3-4 livelli di pacchetti

Verifica rapida

Chi può importare un pacchetto in una directory internal/?

Riepilogo: pacchetti interni e aree di lavoro

Riepilogo:

  • internal/ limita gli import all'albero di directory del genitore; la restrizione viene applicata dal compilatore
  • Usa internal/ per nascondere i dettagli di implementazione ai consumer esterni
  • go work init crea un'area di lavoro per lo sviluppo locale con più moduli
  • Le aree di lavoro sostituiscono le direttive replace durante lo sviluppo locale
  • Aggiungi go.work e go.work.sum al gitignore

Domande Frequenti

La lezione «Package interni e workspace» è gratuita?

Sì — il testo completo di «Package interni e workspace» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «Package interni e workspace»?

internal/, direttive replace e go work Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Package interni e workspace»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Package: organizzare il codice Go
  2. Moduli Go con go mod
  3. Aggiungere dipendenze esterne
  4. Package interni e workspace
← Torna a Go Academy