Go Academy · Lekcja

Wiele wartości zwracanych

Zwracanie krotek i wzorzec error

Wiele wartości zwracanych to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 2 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.

Dlaczego wiele wartości zwracanych?

Funkcje w języku Go mogą zwracać wiele wartości, dzięki czemu nie trzeba używać parametrów wyjściowych ani wyjątków. Najczęstszy wzorzec polega na zwracaniu wyniku i błędu:

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

Obsługa wielu wartości zwracanych

Wywołujący otrzymuje wszystkie wartości zwracane jako krotkę. Użyj _, aby odrzucić niepotrzebne wartości:

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

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

Nazwane wartości zwracane

Wartości zwracane mogą mieć nazwy, dzięki czemu stają się zmiennymi dostępnymi wewnątrz funkcji:

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
}

Zwroty bez argumentów

Instrukcja return bez argumentów zwraca nazwane zmienne zwracane. Należy używać tego oszczędnie — tylko w krótkich funkcjach, w których nazwy jasno określają znaczenie:

Krótkie funkcje: rozwiązanie akceptowalne
Długie funkcje: pogarsza czytelność — preferowane są jawne instrukcje return

Wzorzec (value, error)

Najbardziej typowy wzorzec obsługi błędów w języku 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)
}

Nigdy nie należy ignorować błędów

Ignorowanie błędów za pomocą _ jest niebezpieczne. Najlepsze praktyki:

Należy sprawdzać każdy błąd, chyba że istnieje konkretny powód, aby tego nie robić
Należy opakowywać błędy w dodatkowy kontekst za pomocą fmt.Errorf("op: %w", err)
log.Fatal lub panic należy stosować wyłącznie na granicach programu, a nie głęboko w bibliotekach

Zwracanie trzech wartości

Niektóre funkcje zwracają trzy wartości, choć zdarza się to rzadziej:

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

Zwracanie struktur a wielu wartości

Kiedy zwracać strukturę, a kiedy wiele wartości:

2–3 silnie powiązane wartości: wiele wartości zwracanych jest odpowiednim rozwiązaniem
4 lub więcej wartości albo pola opcjonalne: należy użyć struktury
Wzorzec (value, error): zawsze należy zwracać wiele wartości

Przypisywanie do istniejących zmiennych

Należy używać = (a nie :=) podczas przypisywania do zmiennych zadeklarowanych już przed wywołaniem:

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

Wiele wartości zwracanych w łańcuchowaniu metod

Go nie obsługuje bezpośredniego łańcuchowania metod na wielu zwracanych wartościach (w przeciwieństwie do Result.map w Rust). Należy używać zmiennych pośrednich, aby obsługiwać błędy na każdym etapie:

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

Szybkie sprawdzenie

Co robi niejawny zwrot w języku Go?

Podsumowanie: wiele wartości zwracanych

Wiele wartości zwracanych to jeden z podstawowych idiomów języka Go:

Funkcje mogą zwracać wiele wartości w ujętej w nawiasy liście
Wzorzec (value, error) jest stosowany bardzo często — zawsze należy sprawdzać błąd
Nazwane zmienne zwracane umożliwiają niejawne zwroty (należy używać ich oszczędnie)
Należy używać _, aby odrzucać niepotrzebne wartości
W celu tworzenia przejrzystych interfejsów API należy preferować wiele wartości zwracanych zamiast parametrów wyjściowych

Dalej: funkcje wariadyczne.

Często zadawane pytania

Czy lekcja „Wiele wartości zwracanych” jest bezpłatna?

Tak — pełny tekst „Wiele wartości zwracanych” 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 „Wiele wartości zwracanych”?

Zwracanie krotek i wzorzec error Ć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 2 z 4.

Ile czasu zajmuje lekcja „Wiele wartości zwracanych”?

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.

Wszystkie lekcje w tym kursie

← Powrót do Go Academy