Go Academy · Lektion

Konstruktor-Patterns

Idiomatiche Go-Konstruktoren erstellen

Konstruktor-Patterns ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Warum Konstruktoren?

Go besitzt kein new-Schlüsselwort für Typen und keine Klassenkonstruktoren. Üblicherweise verwendet man eine Funktion namens New..., die Eingaben validiert und einen initialisierten Wert oder Pointer zurückgibt.

Einfache New-Funktion

Geben Sie einen Pointer zurück, damit der Aufrufer mit einer gemeinsam verwendeten Instanz arbeitet:

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

Validierung in Konstruktoren

Konstruktoren eignen sich gut, um Eingaben zu validieren und einen Fehler zurückzugeben:

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

Functional-Options-Pattern

Das Functional-Options-Pattern ermöglicht optionale Konfiguration, ohne die API zu verändern:

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

Builder-Pattern

Bei komplexen Objekten verkettet das Builder-Pattern Setter-Methoden und gibt das Ergebnis zurück:

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

Wert oder Pointer zurückgeben

Geben Sie einen Wert zurück, wenn das Struct klein und unveränderlich ist, und einen Pointer, wenn das Struct groß oder veränderlich ist oder Interfaces implementiert:

Kleine Konfigurations-Structs → Wert
Zustandsbehaftete Objekte (Server, Client, Pool) → Pointer
Wenn ein Interface mit Pointer-Receivern implementiert wird → Pointer

Pattern für Standardwerte

Verwenden Sie eine Defaults-Funktion oder ein Struct-Literal, um sinnvolle Standardwerte festzulegen, bevor Sie Optionen anwenden:

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
}

Singleton-Pattern

Verwenden Sie sync.Once, um eine gemeinsam verwendete Ressource genau einmal zu initialisieren:

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
}

Konstruktoren testen

Konstruktoren, die Fehler zurückgeben, lassen sich leicht testen:

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
}

init() vermeiden

init()-Funktionen werden automatisch ausgeführt und sind schwer zu testen. Bevorzugen Sie explizite Konstruktoren, die Fehler zurückgeben, gegenüber einer impliziten Initialisierung in init().

Kurze Überprüfung

Was erreicht das Functional-Options-Pattern?

Zusammenfassung: Konstruktor-Patterns

Die wichtigsten Erkenntnisse:

Verwenden Sie New...-Funktionen als Konstruktoren
Geben Sie bei fehlgeschlagener Validierung Fehler zurück
Functional Options für flexible optionale Konfiguration
Builder-Pattern für komplexe Abfrage- und Konfigurationsobjekte
Bevorzugen Sie explizite Konstruktoren gegenüber init()

Übungsaufgabe

Implementieren Sie einen NewHTTPClient-Konstruktor mit Functional Options. Unterstützen Sie die Optionen WithTimeout, WithBaseURL und WithMaxRetries.

Häufig gestellte Fragen

Ist die Lektion „Konstruktor-Patterns“ kostenlos?

Ja — der vollständige Text von „Konstruktor-Patterns“ 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 „Konstruktor-Patterns“?

Idiomatiche Go-Konstruktoren erstellen 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 3 von 4.

Wie lange dauert die Lektion „Konstruktor-Patterns“?

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