Go Academy · Lezione

Modelli per i costruttori

Creare costruttori idiomatici in Go

Modelli per i costruttori è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Perché utilizzare i costruttori

Go non ha una parola chiave new per i tipi né costruttori di classe. La convenzione consiste nell'utilizzare una funzione denominata New... che convalida gli input e restituisce un valore o un puntatore inizializzato.

Funzione New semplice

Restituisca un puntatore per garantire che il chiamante lavori con un'istanza condivisa:

package main
import "fmt"

type Server struct {
    Host string
    Port int
}

func NewServer(host string, port int) *Server {
    return &Server{Host: host, Port: port}
}

func main() {
    s := NewServer("localhost", 8080)
    fmt.Println(s.Host, s.Port)
}

Convalida nei costruttori

I costruttori sono il punto ideale per convalidare gli input e restituire un errore:

package main
import ("errors"; "fmt")

type Config struct{ Workers int }

func NewConfig(workers int) (*Config, error) {
    if workers < 1 {
        return nil, errors.New("workers must be >= 1")
    }
    return &Config{Workers: workers}, nil
}

func main() {
    c, err := NewConfig(4)
    fmt.Println(c, err)
}

Pattern delle opzioni funzionali

Il pattern delle opzioni funzionali consente una configurazione facoltativa senza modificare l'API:

package main
import "fmt"

type Server struct{ host string; port int; timeout int }
type Option func(*Server)

func WithPort(p int) Option    { return func(s *Server) { s.port = p } }
func WithTimeout(t int) Option { return func(s *Server) { s.timeout = t } }

func NewServer(host string, opts ...Option) *Server {
    s := &Server{host: host, port: 8080, timeout: 30}
    for _, o := range opts { o(s) }
    return s
}

func main() {
    s := NewServer("localhost", WithPort(9090), WithTimeout(60))
    fmt.Println(s.port, s.timeout)
}

Pattern builder

Per gli oggetti complessi, il pattern builder concatena i metodi setter e restituisce il risultato:

package main
import "fmt"

type QueryBuilder struct{ table, where string; limit int }

func (q *QueryBuilder) Table(t string) *QueryBuilder { q.table = t; return q }
func (q *QueryBuilder) Where(w string) *QueryBuilder { q.where = w; return q }
func (q *QueryBuilder) Limit(n int)   *QueryBuilder { q.limit = n; return q }
func (q *QueryBuilder) Build() string {
    return fmt.Sprintf("SELECT * FROM %s WHERE %s LIMIT %d", q.table, q.where, q.limit)
}

func main() {
    sql := (&QueryBuilder{}).Table("users").Where("age>18").Limit(10).Build()
    fmt.Println(sql)
}

Restituire un valore o un puntatore

Restituisca un valore quando la struct è piccola e immutabile; restituisca un puntatore quando la struct è grande, mutabile o implementa interfacce:

Struct di configurazione piccole → valore
Oggetti con stato (server, client, pool) → puntatore
Se implementa un'interfaccia con receiver tramite puntatore → puntatore

Pattern dei valori predefiniti

Utilizzi una funzione defaults o un literal di struct per impostare valori predefiniti appropriati prima di applicare le opzioni:

package main
import "fmt"

type Cache struct{ maxSize int; ttlSecs int }

func defaultCache() Cache { return Cache{maxSize: 100, ttlSecs: 300} }

func NewCache(opts ...func(*Cache)) *Cache {
    c := defaultCache()
    for _, o := range opts { o(&c) }
    return &c
}

func main() {
    c := NewCache(func(c *Cache) { c.maxSize = 500 })
    fmt.Println(c.maxSize, c.ttlSecs) // 500 300
}

Pattern singleton

Utilizzi sync.Once per inizializzare una risorsa condivisa esattamente una volta:

package main
import ("fmt"; "sync")

type DB struct{ DSN string }

var (
    instance *DB
    once     sync.Once
)

func GetDB(dsn string) *DB {
    once.Do(func() { instance = &DB{DSN: dsn} })
    return instance
}

func main() {
    db1 := GetDB("postgres://...")
    db2 := GetDB("ignored")
    fmt.Println(db1 == db2) // true
}

Testare i costruttori

I costruttori che restituiscono errori sono facili da testare:

package main
import ("errors"; "fmt")

type Pool struct{ size int }

func NewPool(size int) (*Pool, error) {
    if size <= 0 { return nil, errors.New("size must be positive") }
    return &Pool{size: size}, nil
}

func main() {
    _, err := NewPool(-1)
    fmt.Println(err) // size must be positive
    p, _ := NewPool(5)
    fmt.Println(p.size) // 5
}

Evitare init()

Le funzioni init() vengono eseguite automaticamente e sono difficili da testare. Preferisca costruttori espliciti che restituiscono errori all'inizializzazione implicita in init().

Verifica rapida

Quale risultato ottiene con il pattern delle opzioni funzionali?

Riepilogo: pattern dei costruttori

Punti chiave:

Utilizzi le funzioni New... come costruttori
Restituisca errori in caso di mancata convalida
Utilizzi le opzioni funzionali per una configurazione facoltativa flessibile
Utilizzi il pattern builder per oggetti complessi di query o configurazione
Preferisca i costruttori espliciti a init()

Traccia per l'esercizio

Implementi un costruttore NewHTTPClient utilizzando le opzioni funzionali. Supporti le opzioni WithTimeout, WithBaseURL e WithMaxRetries.

Domande Frequenti

La lezione «Modelli per i costruttori» è gratuita?

Sì — il testo completo di «Modelli per i costruttori» è 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 «Modelli per i costruttori»?

Creare costruttori idiomatici in Go 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 3 di 4.

Quanto tempo richiede la lezione «Modelli per i costruttori»?

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