Go Academy · Lezione

Package: organizzare il codice Go

Dichiarazioni dei package, import e nomi esportati

Package: organizzare il codice Go è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Che cos'è un pacchetto?

Ogni file sorgente Go appartiene a un pacchetto. Il nome del pacchetto compare all'inizio di ogni file. I pacchetti raggruppano il codice correlato e controllano la visibilità:

// file: math/calc.go
package math

// Exported — accessible from other packages (capital letter)
func Add(a, b int) int { return a + b }

// Unexported — package-private (lowercase)
func helper() int { return 42 }

Dichiarazione del pacchetto e percorso di importazione

Il nome del pacchetto (breve) è diverso dal percorso di importazione (percorso completo del modulo/directory):

// Import path: github.com/myapp/util/stringutil
// Package name: stringutil (last segment by convention)
package stringutil

func Reverse(s string) string {
    r := []rune(s)
    for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    return string(r)
}

Importare pacchetti

Usa import per importare altri pacchetti. Go richiede che tutti gli import vengano utilizzati:

package main

import (
    "fmt"                         // standard library
    "strings"                     // standard library
    "github.com/myapp/util/math"  // third-party or local
)

func main() {
    fmt.Println(strings.ToUpper("hello"))
    fmt.Println(math.Add(1, 2))
}

Identificatori esportati e non esportati

Gli identificatori che iniziano con una lettera maiuscola sono esportati (pubblici). Quelli che iniziano con una lettera minuscola sono non esportati (privati del pacchetto):

package server

// Exported: accessible from other packages
type Server struct {
    Addr    string   // exported field
    timeout int      // unexported field
}

// Exported method
func (s *Server) Start() error { return nil }

// Unexported helper
func (s *Server) listen() {}

Il pacchetto main e func main

Il pacchetto main è speciale: definisce un eseguibile. La funzione main è il punto di ingresso:

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
    // Program starts here and ends here
}

// All other packages are libraries — no main() needed

Funzione init()

Ogni pacchetto può avere una o più funzioni init(), che vengono eseguite automaticamente prima di main() e nell'ordine in cui sono dichiarate:

package config

import "fmt"

var DB string

func init() {
    DB = "localhost:5432/mydb"
    fmt.Println("config package initialized")
}

// init runs once when the package is first imported
// Multiple init() functions per file/package are allowed

Import vuoto per gli effetti collaterali

Importa un pacchetto solo per gli effetti collaterali della sua funzione init() usando l'identificatore vuoto:

package main

import (
    "database/sql"
    _ "github.com/lib/pq"  // registers PostgreSQL driver via init()
)

func main() {
    db, err := sql.Open("postgres", "host=localhost dbname=test")
    _ = db
    _ = err
}

Import con alias

Rinomina un pacchetto durante l'importazione per evitare conflitti tra nomi o per brevità:

package main

import (
    "fmt"
    gomath "math"              // alias to avoid collision
    mymath "github.com/me/math"
)

func main() {
    fmt.Println(gomath.Sqrt(16))     // 4
    fmt.Println(mymath.Add(1, 2))    // 3
}

Convenzioni per i nomi dei pacchetti

Convenzioni per i nomi dei pacchetti Go:

Brevi, in minuscolo e composti da una sola parola: http, json, fmt
Corrispondono al nome della directory: util/stringutil/ → pacchetto stringutil
Niente trattini bassi o camelCase nei nomi dei pacchetti
Evita nomi generici come util, common, helper
Il nome del pacchetto fa parte dell'identificatore: preferisci http.Client a httplib.HTTPClient

Importazioni circolari

Go NON consente importazioni circolari. Il pacchetto A non può importare B se B importa A. Risolvi il problema estraendo il codice condiviso in un terzo pacchetto:

// WRONG: A imports B, B imports A — compile error
// package a imports "myapp/b"
// package b imports "myapp/a"

// SOLUTION: extract shared types to package c
// package a imports "myapp/c"
// package b imports "myapp/c"
// No circular dependency

Verifica rapida

Che cosa rende esportato un identificatore in Go?

Riepilogo: pacchetti

Concetti chiave sui pacchetti:

Ogni file inizia con package name
Maiuscolo = esportato (pubblico), minuscolo = non esportato (privato del pacchetto)
Importa usando il percorso completo e usa il nome breve del pacchetto
init() viene eseguita automaticamente prima di main()
Import vuoto _ "pkg" solo per gli effetti collaterali
Le importazioni circolari non sono consentite

Domande Frequenti

La lezione «Package: organizzare il codice Go» è gratuita?

Sì — il testo completo di «Package: organizzare il codice Go» è 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: organizzare il codice Go»?

Dichiarazioni dei package, import e nomi esportati 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 1 di 4.

Quanto tempo richiede la lezione «Package: organizzare il codice Go»?

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

← Torna a Go Academy