Antwort.

Go unterstützt grundsätzlich keine optionalen Parameter und Standardwerte für Funktionsargumente — jede Funktion akzeptiert nur die Gruppe von Argumenten, die in ihrer Signatur angegeben ist. Diese Designentscheidung hängt mit der allgemeinen Einfachheit des Modells und der Vorhersehbarkeit des Codes zusammen.

Hintergrund

In anderen Sprachen, wie Python oder C++, erlauben optionale/Standardparameter eine flexible Bestimmung des Verhaltens der Funktion. In Go wurde dies zugunsten von Lesbarkeit und Eindeutigkeit aufgegeben.

Problem

Wenn man eine API flexibel gestalten möchte, kann man nicht einfach Standardwerte festlegen — man muss alle Parameter explizit übergeben oder Umgehungsmuster verwenden. Dies erschwert die Unterstützung einer großen Anzahl von Optionen und kann zu einer Zunahme der Anzahl überladener Funktionen führen.

Lösung

In Go werden für diese Flexibilität zwei Ansätze verwendet:

Parameterstruktur — eine Struktur wird erstellt mit einer Gruppe von Optionsfeldern, die an die Funktion übergeben werden kann. Innerhalb der Struktur können Standardwerte explizit festgelegt werden.
Variadische Funktionen (functional options pattern) — ein Muster mit der Übergabe von Einstellfunktionen, die die Konfiguration eines Objekts ändern.

Beispiel für den Ansatz mit einer Struktur:

typ QueryOptions struct {
    Limit  int
    Offset int
}

func QueryDB(opts QueryOptions) {
    if opts.Limit == 0 {
        opts.Limit = 10 // Standard
    }
    // ...
}

QueryDB(QueryOptions{Limit: 100})

Oder über funktionale Optionen:

typ Config struct {
    Timeout int
}

typ Option func(*Config)

func WithTimeout(t int) Option {
    return func(cfg *Config) { cfg.Timeout = t }
}

func Do(opts ...Option) {
    cfg := Config{Timeout: 5} // Standard
    for _, o := range opts {
        o(&cfg)
    }
    // ...
}

Do(WithTimeout(10)) // Aufruf mit Option
Do()                // Aufruf mit Standard

Schlüsselfeatures:

Es gibt keine optionalen/Standardparameter auf Sprachebene
Flexibilität wird entweder über Strukturen oder funktionale Muster erreicht
Alles ist explizit, ohne Magie — es ist immer klar, was und wie übergeben wird.

Trickfragen.

Kann ein Standardwert bei der Funktionsdeklaration angegeben werden, z. B. func F(a int = 10)?

Nein, in Go ist eine solche Schreibweise nicht möglich — nur eine strenge Liste erforderlicher Parameter.

Was passiert, wenn eine Funktion mit einem Slice vom Typ ...interface{} deklariert wird und ihr 0 Argumente übergeben werden?

Das Slice hat eine Länge von 0 (nil), die Funktion erhält ein leeres Slice.

Beispielcode:

func PrintAll(args ...interface{}) {
    fmt.Println(len(args)) // 0, wenn keine Parameter übergeben werden
}

PrintAll() // ok

Kann man Funktionen in Go nach der Anzahl oder dem Typ der Parameter überladen (overload)?

Nein, die Überladung von Funktionen wird in Go nicht unterstützt — doppelte Funktionsnamen mit unterschiedlichen Signaturen sind nicht zulässig.

Typische Fehler und Anti-Muster

Versuchen, Überladung durch variadische Schnittstellen (...interface{}) zu implementieren, indem man komplexe Typprüfungen manuell durchführt.
API übermäßig auf Dutzende von Parametern erweitern — das erschwert die Unterstützung.
Werte in Funktionen fest kodieren, ohne Möglichkeit zur Anpassung.

Beispiel aus dem Leben

Negativer Fall

Die API-Funktion hat Dutzende von Parametern, viele von ihnen vom gleichen Typ, was häufig zu Verwirrungen über die Reihenfolge führt:

Vorteile:

Alles ist klar definiert.

Nachteile:

Fehler aufgrund von unklaren Argumenten.
Unklarheiten über die Standardwerte.

Positiver Fall

Verwendung einer Optionsstruktur oder funktionaler Optionen, die Parameter haben explizite Namen: