Antwoord.

Go ondersteunt principieel geen optionele parameters en standaardwaarden voor functiewaarden — elke functie accepteert alleen de set van parameters die in zijn handtekening is gespecificeerd. Deze ontwerp beslissing is gerelateerd aan de algemene eenvoud van het model en de voorspelbaarheid van de code.

Geschiedenis van de kwestie

In andere talen, zoals Python of C++, stellen optionele/standaard parameters je in staat om het gedrag van een functie flexibel te definiëren. In Go is dit opgeofferd ten gunste van leesbaarheid en eenduidigheid.

Probleem

Wanneer je een API flexibel wilt maken, is het onmogelijk om eenvoudig standaardwaarden op te geven — je moet expliciet alle parameters doorgeven of omleidingspatronen gebruiken. Dit bemoeilijkt het onderhoud van een groot aantal opties en kan leiden tot een toename van het aantal overbelaste functies.

Oplossing

In Go worden twee benaderingen gebruikt voor dergelijke flexibiliteit:

Parameter-structuur — een structuur wordt gemaakt met een set opties, die kan worden doorgegeven aan de functie. Binnen de structuur kunnen standaardwaarden expliciet worden ingesteld.
Variabele functies (functional options pattern) — patroon waarbij functies voor instellingen worden doorgegeven die de configuratie van het object wijzigen.

Voorbeeld van de benadering via een structuur:

type QueryOptions struct {
    Limit  int
    Offset int
}

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

QueryDB(QueryOptions{Limit: 100})

Of via functionele opties:

type Config struct {
    Timeout int
}

type Option func(*Config)

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

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

Do(WithTimeout(10)) // oproep met optie
Do()                // oproep met standaard

Belangrijke kenmerken:

Geen optionele/standaardparameters op taalkundig niveau
Flexibiliteit wordt bereikt via structuren of functionele patronen
Alles is expliciet, zonder magie — het is altijd duidelijk wat en hoe wordt doorgegeven

Vragen met een vangst.

Kan je een standaardwaarde definieëren bij het declareren van een functie, bijvoorbeeld func F(a int = 10)?

Nee, in Go is het onmogelijk om dergelijke notatie te declareren — alleen een strikte opsomming van vereiste parameters is toegestaan.

Wat gebeurt er als je een functie declareert met een slice van het type ...interface{} en 0 argumenten doorgeeft?

De slice zal een lengte van 0 hebben (nil), de functie ontvangt een lege slice.

Voorbeeld code:

func PrintAll(args ...interface{}) {
    fmt.Println(len(args)) // 0 als er geen parameters worden doorgegeven
}

PrintAll() // ok

Kan je functies overbelasten (overload) op basis van het aantal of type parameters in Go?

Nee, functieoverbelasting wordt in Go niet ondersteund — duplicaten van functienamen met verschillende handtekeningen zijn niet toegestaan.

Typische fouten en anti-patronen

Proberen om overbelasting te implementeren via variabele interfaces ( ...interface{} ), met handmatige typecontroles die moeilijk zijn
Overmatig uitbreiden van de API tot tientallen parameters — dit bemoeilijkt het onderhoud
Hardgecodeerde waarden binnen functies zonder de mogelijkheid voor configuratie

Voorbeeld uit het leven

Negatieve case

Een API functie heeft tientallen parameters, veel van dezelfde type, waardoor ze verkeerd worden verwisseld:

Voordelen:

Alles is expliciet vastgesteld

Nadelen:

Fouten door onduidelijke argumenten
Onzekerheid over welke standaardwaarden er zijn

Positieve case

Gebruik van een optiestructuur of functionele opties, parameters hebben duidelijke namen: