Guida a Go · 5/6
Per ora questo capitolo è disponibile solo in inglese.
Go has no exceptions. Errors are ordinary values that functions return and callers inspect right where the call happens. Testing is just as down to earth: the standard testing package and the go test command cover most needs without any third-party framework. This chapter covers error values, wrapping, panic and recover, and how to write tests and benchmarks.
error is a built-in interface with a single method, Error() string. A function that can fail returns an error as its last result, and nil means success. Callers check it immediately with if err != nil.
import (
"errors"
"fmt"
"strconv"
)
var ErrEmpty = errors.New("empty input") // sentinel error, exported for comparison
func parseAge(s string) (int, error) {
if s == "" {
return 0, ErrEmpty
}
n, err := strconv.Atoi(s)
if err != nil {
return 0, fmt.Errorf("parse age %q: %w", s, err)
}
if n < 0 {
return 0, fmt.Errorf("age cannot be negative: %d", n)
}
return n, nil
}The repeated if err != nil can look noisy, but it makes every failure path visible in the code. By convention, error strings start lowercase and have no trailing punctuation, because they are often embedded inside other messages.
Using the %w verb in fmt.Errorf wraps the original error: you add context while keeping the cause reachable. To test for a specific error, use errors.Is instead of ==. To pull out an error of a particular type, use errors.As. Both walk the entire chain of wrapped errors.
type NotFoundError struct {
ID string
}
func (e *NotFoundError) Error() string { return "not found: " + e.ID }
func load(id string) error {
return fmt.Errorf("load: %w", &NotFoundError{ID: id})
}
func main() {
_, err := parseAge("")
if errors.Is(err, ErrEmpty) {
fmt.Println("nothing to parse")
}
err = load("42")
var nf *NotFoundError
if errors.As(err, &nf) {
fmt.Println("missing ID:", nf.ID)
}
fmt.Println(err) // load: not found: 42
}Formatting an error with %v instead keeps the text but severs the link to the cause. Choose %w when callers should be able to inspect the underlying error, and %v when it is an implementation detail you would rather not commit to. To combine several errors into one, use errors.Join.
panic is for situations that ordinary error handling cannot sensibly deal with: programmer mistakes and states that should be impossible. The runtime itself panics on things like an out-of-range index or a write to a map. A panic unwinds the stack, running deferred calls along the way, and crashes the program if nothing stops it.
nilrecover only works inside a deferred function. It stops an in-progress panic and returns the value that was passed to panic. Its main legitimate use is at boundaries, for example so that one bad request does not take down an entire server.
func safeDivide(a, b int) (result int, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("recovered: %v", r)
}
}()
return a / b, nil // panics at runtime when b is 0
}
func main() {
_, err := safeDivide(1, 0)
fmt.Println(err) // recovered: runtime error: integer divide by zero
}Libraries should not let panics escape to their callers; return an error instead. Assigning to a named result such as err inside the deferred function is how the recovered failure gets reported back.
Test files end in _test.go. Test functions start with Test and take a *testing.T, and go test discovers and runs them. t.Errorf records a failure and keeps going, while t.Fatalf stops the current test right away.
// file: age_test.go
package main
import (
"errors"
"testing"
)
func TestParseAgeEmpty(t *testing.T) {
_, err := parseAge("")
if !errors.Is(err, ErrEmpty) {
t.Fatalf("want ErrEmpty, got %v", err)
}
}The most common Go testing style is the table-driven test: list inputs and expected outputs in a slice of structs, then loop over it. Running each case through t.Run makes it a named subtest, so failures say exactly which case broke and you can rerun just that one.
func TestParseAge(t *testing.T) {
tests := []struct {
name string
in string
want int
wantErr bool
}{
{"valid", "30", 30, false},
{"not a number", "abc", 0, true},
{"negative", "-1", 0, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := parseAge(tt.in)
if (err != nil) != tt.wantErr {
t.Fatalf("err = %v, wantErr %v", err, tt.wantErr)
}
if got != tt.want {
t.Errorf("parseAge(%q) = %d, want %d", tt.in, got, tt.want)
}
})
}
}Benchmark functions start with Benchmark and take a *testing.B. Put the code you want to measure inside a for b.Loop() loop and the framework decides how many iterations it needs for a stable result. Older code uses the equivalent for i := 0; i < b.N; i++ form.
func BenchmarkParseAge(b *testing.B) {
for b.Loop() {
parseAge("42")
}
}go test ./... # every package
go test -v -run 'TestParseAge/negative' . # one subtest, verbose
go test -race ./... # with the data race detector
go test -cover ./... # coverage summary
go test -bench . -benchmem # benchmarks plus allocation statserror as the last result and check if err != nil right away.fmt.Errorf("context: %w", err) and inspect with errors.Is and errors.As.panic for the truly unrecoverable, and recover only at boundaries inside defer.TestXxx(t *testing.T) functions in _test.go files; table-driven tests with t.Run are the norm.BenchmarkXxx(b *testing.B) and go test -bench.
0 commenti
Accedi · Accedi per lasciare un commento.