De error-interface
Fouten op idiomatische wijze teruggeven en controleren
De error-interface is een gratis Go Academy-les op CoddyKit. Dit is les 1 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.
Go's foutfilosofie
Go verwerkt fouten als waarden, niet als uitzonderingen. Functies retourneren een error als laatste retourwaarde. De aanroeper moet deze expliciet controleren:
package main
import ("fmt"; "strconv")
func main() {
n, err := strconv.Atoi("abc")
if err != nil {
fmt.Println("error:", err) // handle it
return
}
fmt.Println(n)
}De error-interface
De ingebouwde error is een eenvoudige interface:
// Built into Go — no import needed
type error interface {
Error() string
}
// Any type with Error() string satisfies it
// nil means no errorFouten retourneren
Functies die kunnen mislukken retourneren (value, error). Retourneer nil als er geen fout is:
package main
import ("fmt"; "errors")
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("division by zero")
}
return a / b, nil
}
func main() {
result, err := divide(10, 0)
if err != nil {
fmt.Println("error:", err)
return
}
fmt.Println(result)
}Het patroon if err != nil
De controle if err != nil is het meestgebruikte Go-idioom. Handel fouten altijd af — negeer ze niet:
package main
import ("fmt"; "os")
func main() {
f, err := os.Open("config.json")
if err != nil {
fmt.Println("open error:", err)
return
}
defer f.Close()
// use f...
_ = f
}errors.New — eenvoudige foutwaarden
errors.New maakt een eenvoudige fout met een vaste melding:
package main
import ("fmt"; "errors")
var ErrNotFound = errors.New("not found")
func findByID(id int) (string, error) {
data := map[int]string{1: "Alice"}
v, ok := data[id]
if !ok {
return "", ErrNotFound
}
return v, nil
}
func main() {
_, err := findByID(99)
fmt.Println(err) // not found
}fmt.Errorf — opgemaakte foutmeldingen
fmt.Errorf maakt fouten met context uit opgemaakte tekenreeksen:
package main
import "fmt"
func openConfig(path string) error {
// Add context to the error message
return fmt.Errorf("openConfig %s: file not found", path)
}
func main() {
err := openConfig("/etc/app/config.yaml")
fmt.Println(err)
// openConfig /etc/app/config.yaml: file not found
}Sentinelfouten
Sentinelfouten zijn foutwaarden op pakketniveau die worden gebruikt voor identiteitsvergelijking:
package main
import ("fmt"; "errors")
var (
ErrTimeout = errors.New("timeout")
ErrPermission = errors.New("permission denied")
)
func doRequest() error { return ErrTimeout }
func main() {
err := doRequest()
if errors.Is(err, ErrTimeout) {
fmt.Println("request timed out — retrying")
}
}Fouten negeren is een bug
Go vereist dat je elke gedeclareerde variabele gebruikt — maar fouten negeren met _ compileert zonder problemen en is een veelgemaakte fout die je moet vermijden:
package main
import "os"
func bad() {
os.Remove("temp.txt") // silently ignores error — bad practice
}
func good() error {
if err := os.Remove("temp.txt"); err != nil {
return err // propagate
}
return nil
}Foutcontext: informatie toevoegen
Voeg bij het doorgeven van fouten naar boven in de aanroepstack context toe die beschrijft welke bewerking is mislukt:
package main
import "fmt"
func readConfig(path string) ([]byte, error) {
return nil, fmt.Errorf("readConfig: %w", fmt.Errorf("file %s not found", path))
}
func setup() error {
_, err := readConfig("/etc/app.cfg")
if err != nil {
return fmt.Errorf("setup: %w", err) // wrap with context
}
return nil
}
func main() {
err := setup()
fmt.Println(err) // setup: readConfig: file /etc/app.cfg not found
}Meerdere foutretourwaarden
Functies kunnen fouten retourneren vanaf meerdere punten waarop ze kunnen mislukken. Controleer elk punt:
package main
import ("fmt"; "strconv")
func parseRange(minStr, maxStr string) (int, int, error) {
min, err := strconv.Atoi(minStr)
if err != nil { return 0, 0, fmt.Errorf("min: %w", err) }
max, err := strconv.Atoi(maxStr)
if err != nil { return 0, 0, fmt.Errorf("max: %w", err) }
if min > max { return 0, 0, fmt.Errorf("min %d > max %d", min, max) }
return min, max, nil
}
func main() {
lo, hi, err := parseRange("1", "10")
if err != nil { fmt.Println(err); return }
fmt.Println(lo, hi)
}Korte controle
Wat betekent een nil-fout als retourwaarde in Go?
Samenvatting: de error-interface
Belangrijke concepten voor foutafhandeling:
- Error is een ingebouwde interface:
Error() string - Retourneer
(value, error)— nil betekent succes errors.Newvoor eenvoudige fouten,fmt.Errorfvoor opgemaakte fouten- Controleer altijd
if err != nil - Voeg context toe wanneer je fouten naar boven in de stack doorgeeft
- Negeer fouten nooit stilzwijgend
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
Veelgestelde vragen
Is de les “De error-interface” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Go Academy, waaronder “De error-interface”, 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 “De error-interface”?
Fouten op idiomatische wijze teruggeven en controleren 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 1 van 4.
Hoe lang duurt de les “De error-interface”?
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.