Go Academy · Les

Meervoudige returnwaarden

Tuplewaarden en het error-patroon teruggeven

Les 2 van 412 stappen

Meervoudige returnwaarden is een gratis Go Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Go Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Go Academy bevat in totaal 4 lessen.

Waarom meerdere returnwaarden?

Functies in Go kunnen meerdere waarden retourneren, waardoor uitvoerparameters of uitzonderingen niet nodig zijn. Het meest voorkomende patroon is het retourneren van een resultaat en een fout:

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

Meerdere returnwaarden verwerken

Aanroepers ontvangen alle returnwaarden als een tuple. Gebruik _ om waarden die je niet nodig hebt weg te gooien:

result, err := divide(10, 3)
if err != nil {
    log.Fatal(err)
}
fmt.Println(result)

value, _ := divide(8, 2) // discard error

Benoemde returnwaarden

Returnwaarden kunnen een naam krijgen, waardoor ze variabelen binnen de functie worden:

func minMax(nums []int) (min, max int) {
    min, max = nums[0], nums[0]
    for _, n := range nums[1:] {
        if n < min { min = n }
        if n > max { max = n }
    }
    return // naked return
}

Naakte returns

Een return zonder argumenten retourneert de benoemde retourvariabelen. Gebruik dit spaarzaam — alleen in korte functies waarvan de namen voor zichzelf spreken:

Korte functies: acceptabel
Lange functies: vermindert de leesbaarheid — geef de voorkeur aan expliciete returns

Het patroon (waarde, fout)

Het gebruikelijke patroon voor foutafhandeling in Go:

func readConfig(path string) (Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return Config{}, fmt.Errorf("read config: %w", err)
    }
    var cfg Config
    return cfg, json.Unmarshal(data, &cfg)
}

Negeer fouten nooit

Fouten negeren met _ is gevaarlijk. Goede werkwijzen:

Controleer elke fout, tenzij je een specifieke reden hebt om dat niet te doen
Voorzie fouten van context met fmt.Errorf("op: %w", err)
Gebruik log.Fatal of panic alleen aan de grenzen van het programma, niet diep in bibliotheken

Drie retourwaarden

Sommige functies retourneren drie waarden, hoewel dit minder vaak voorkomt:

func parseIPPort(s string) (ip string, port int, err error) {
    // ... parsing logic
    return
}

Structs retourneren versus meerdere waarden

Wanneer retourneer je een struct en wanneer meerdere waarden:

2-3 sterk gerelateerde waarden: meerdere retourwaarden zijn prima
4 of meer waarden of optionele velden: gebruik een struct
Het patroon (waarde, fout): altijd meerdere retourwaarden

Toewijzen aan bestaande variabelen

Gebruik = (niet :=) bij het toewijzen aan variabelen die buiten de aanroep al zijn gedeclareerd:

var cfg Config
var err error
cfg, err = loadConfig()
if err != nil { ... }

Meerdere retourwaarden in method chaining

Go ondersteunt geen method chaining rechtstreeks op meerdere retourwaarden (anders dan Rusts Result.map). Gebruik tussentijdse variabelen om fouten bij elke stap af te handelen:

data, err := fetchData(url)
if err != nil { return err }
parsed, err := parseData(data)
if err != nil { return err }
return save(parsed)

Korte controle

Wat doet een naked return in Go?

Beantwoord dit in de interactieve les

Samenvatting: meerdere retourwaarden

Meerdere retourwaarden zijn een belangrijk Go-idioom:

Functies kunnen meerdere waarden retourneren in een lijst tussen haakjes
Het patroon (waarde, fout) komt overal voor — controleer de fout altijd
Benoemde retourvariabelen maken naked returns mogelijk (gebruik ze spaarzaam)
Gebruik _ om waarden die je niet nodig hebt weg te gooien
Geef voor schonere API's de voorkeur aan meerdere retourwaarden boven uitvoerparameters

Volgende onderwerp: variadische functies.

Gratis beginnen

Leer Go met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Meervoudige returnwaarden” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Go Academy, waaronder “Meervoudige returnwaarden”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Go Academy bevat in totaal 4 lessen.

Wat leer ik in “Meervoudige returnwaarden”?

Tuplewaarden en het error-patroon teruggeven Je oefent met Go Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Go Academy te beginnen?

Ervaring vooraf is niet nodig. Go Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Meervoudige returnwaarden”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Go Academy?

Ja. Elke les over Go Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Go Academy