Interfejs error
Idiomaticzne zwracanie i sprawdzanie błędów
Interfejs error to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.
Filozofia obsługi błędów w Go
Go obsługuje błędy jako wartości, a nie wyjątki. Funkcje zwracają error jako ostatnią wartość zwracaną. Wywołujący musi jawnie go sprawdzić:
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)
}Interfejs error
Wbudowany error jest prostym interfejsem:
// Built into Go — no import needed
type error interface {
Error() string
}
// Any type with Error() string satisfies it
// nil means no errorZwracanie błędów
Funkcje, które mogą zakończyć się niepowodzeniem, zwracają (value, error). Zwracaj nil, gdy nie wystąpił błąd:
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)
}Wzorzec if err != nil
Sprawdzanie if err != nil jest najczęściej stosowaną konstrukcją w Go. Zawsze obsługuj błędy — nie ignoruj ich:
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 — proste wartości błędów
errors.New tworzy prosty błąd ze stałym komunikatem:
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 — sformatowane komunikaty błędów
fmt.Errorf tworzy błędy z kontekstem na podstawie sformatowanych ciągów znaków:
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
}Błędy sentinelowe
Błędy sentinelowe to wartości błędów na poziomie pakietu, używane do porównywania tożsamości:
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")
}
}Ignorowanie błędów jest błędem
Go wymaga użycia każdej zadeklarowanej zmiennej — ale ignorowanie błędów za pomocą _ kompiluje się poprawnie i jest częstym błędem, którego należy unikać:
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
}Kontekst błędu: dodawanie informacji
Podczas propagowania błędów w górę stosu wywołań dodaj kontekst opisujący operację, która się nie powiodła:
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
}Zwracanie wielu błędów
Funkcje mogą zwracać błędy z wielu punktów, w których może wystąpić niepowodzenie. Sprawdzaj każdy z nich:
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)
}Szybkie sprawdzenie
Co oznacza zwrócona wartość błędu nil w Go?
Podsumowanie: interfejs error
Najważniejsze pojęcia związane z obsługą błędów:
- Error to wbudowany interfejs:
Error() string - Zwracaj
(value, error)— nil oznacza powodzenie errors.Newsłuży do prostych błędów, afmt.Errorfdo błędów sformatowanych- Zawsze sprawdzaj
if err != nil - Dodawaj kontekst podczas propagowania błędów w górę stosu
- Nigdy nie ignoruj błędów po cichu
Często zadawane pytania
Czy lekcja „Interfejs error” jest bezpłatna?
Tak — pełny tekst „Interfejs error” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Interfejs error”?
Idiomaticzne zwracanie i sprawdzanie błędów Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Go Academy?
Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.
Ile czasu zajmuje lekcja „Interfejs error”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?
Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.