If else w Go: składnia, if z inicjalizacją i if err != nil

if w Go nie ma nawiasów wokół warunku, zawsze wymaga klamer i może zaczynać się od krótkiej instrukcji, która deklaruje zmienne o zasięgu ograniczonym do tego if.

package main

import "fmt"

func grade(score int) string {
	var g string
	if score >= 90 {
		g = "A"
	} else if score >= 80 {
		g = "B"
	} else if score >= 70 {
		g = "C"
	} else {
		g = "F"
	}
	return g
}

func main() {
	for _, s := range []int{95, 83, 70, 42} {
		fmt.Println(s, grade(s))
	}
}

Warunki są sprawdzane od góry i wykonuje się pierwsza prawdziwa gałąź. else if i else są opcjonalne.

Zasady składni

Trzy zasady różnią się od C, Javy i JavaScriptu:

1. Brak nawiasów wokół warunku. if (x > 5) się kompiluje, ale gofmt usuwa nawiasy.
2. Klamry są obowiązkowe, nawet dla jednej instrukcji. Nie istnieje if x > 5 return bez klamer.
3. else stoi w tej samej linii co klamra zamykająca. Go wstawia średnik po } na końcu linii, więc to nie działa:

if x > 5 {
	fmt.Println("big")
}
else {
	fmt.Println("small")
}

syntax error: unexpected keyword else, expected }

Pisz } else { w jednej linii.

Warunek musi być typu bool. Go nie traktuje 0, "" ani nil jako fałszu, więc if count {} i if name {} się nie kompilują. Porównuj jawnie: if count > 0, if name != "", if user != nil.

Łącz warunki przez && (i), || (lub) i ! (nie). Zarówno &&, jak i || działają na skróty, dzięki czemu sprawdzanie nil jest bezpieczne:

if user != nil && user.IsAdmin() {
	// user.IsAdmin() is only called when user is not nil
}

if z instrukcją inicjującą

if może wykonać jedną krótką instrukcję przed warunkiem, oddzieloną średnikiem. Zadeklarowane w niej zmienne są widoczne w każdej gałęzi tego if, a nigdzie za nim:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	inputs := []string{"42", "-7", "abc"}

	for _, in := range inputs {
		if n, err := strconv.Atoi(in); err != nil {
			fmt.Printf("%q is not a number\n", in)
		} else if n < 0 {
			fmt.Printf("%d is negative\n", n)
		} else {
			fmt.Printf("%d doubled is %d\n", n, n*2)
		}
		// n and err do not exist here
	}

	stock := map[string]int{"apples": 3}
	if qty, ok := stock["apples"]; ok {
		fmt.Println("apples in stock:", qty)
	}
	if _, ok := stock["pears"]; !ok {
		fmt.Println("no pears")
	}
}

Ten wzorzec trzyma krótkotrwałe zmienne z dala od otaczającego zasięgu. Pojawia się bez przerwy przy odczycie z mapy (v, ok := m[k]), asercjach typu (s, ok := v.(string)) i błędach.

Druga strona medalu: jeśli potrzebujesz wartości za if, zadeklaruj ją wcześniej. Częsty błąd to umieszczenie wyniku w instrukcji inicjującej, a potem próba użycia go niżej.

Idiom if err != nil

Funkcje, które mogą zawieść, zwracają error na końcu. Sprawdź go od razu, obsłuż lub zwróć i kontynuuj szczęśliwą ścieżkę bez wcięcia:

package main

import (
	"errors"
	"fmt"
	"strconv"
)

func parseAge(s string) (int, error) {
	n, err := strconv.Atoi(s)
	if err != nil {
		return 0, fmt.Errorf("age %q: %w", s, err)
	}
	if n < 0 || n > 150 {
		return 0, errors.New("age out of range")
	}
	return n, nil
}

func main() {
	for _, s := range []string{"34", "x", "200"} {
		age, err := parseAge(s)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("age:", age)
	}
}

Zwróć uwagę, że po if err != nil { return ... } nie ma else. Styl Go to obsłużyć błąd, zwrócić i zostawić normalny przepływ przy lewym marginesie. Strona o obsłudze błędów opisuje opakowywanie błędów i sprawdzanie ich typów.

Wczesne powroty zamiast zagnieżdżania

Głęboko zagnieżdżone bloki if trudno się czyta. Odwróć warunki i wracaj wcześnie; każde sprawdzenie czyta się wtedy jak strażnik:

// Nested
func canCheckout(u *User, cart *Cart) bool {
	if u != nil {
		if u.Verified {
			if len(cart.Items) > 0 {
				return true
			}
		}
	}
	return false
}

// Guards
func canCheckout(u *User, cart *Cart) bool {
	if u == nil || !u.Verified {
		return false
	}
	if len(cart.Items) == 0 {
		return false
	}
	return true
}

Programiści Go nazywają to trzymaniem szczęśliwej ścieżki przy lewej krawędzi. Lintery, takie jak revive, zgłaszają else po bloku kończącym się return, bo takie else dodaje wcięcie bez żadnej korzyści.

if/else a switch

Długi łańcuch else if, który porównuje jedną wartość z kilkoma przypadkami, czyta się lepiej jako switch. switch bez wyrażenia zastępuje łańcuch if/else if z dowolnymi warunkami:

switch {
case score >= 90:
	return "A"
case score >= 80:
	return "B"
default:
	return "F"
}

Używaj if dla jednej lub dwóch gałęzi, a switch, gdy jest ich trzy lub więcej.

Brak operatora trójargumentowego

Go nie ma cond ? a : b. Przypisz wartość przez if:

label := "odd"
if n%2 == 0 {
	label = "even"
}

Strona o operatorze trójargumentowym wyjaśnia dlaczego i pokazuje alternatywy.

Częste błędy

• Przesłanianie przez :=. if x, err := f(); err == nil { ... } deklaruje nowe x tylko dla if. Zewnętrzne x nie zostaje zaktualizowane.
• Przypisanie w warunku. if x = 5 {} to błąd kompilacji (cannot use assignment x = 5 as value), a nie cichy błąd jak w C. Użyj ==.
• Porównywanie liczb zmiennoprzecinkowych przez ==. if total == 0.3 zawodzi dla obliczonych wartości. Porównuj z tolerancją.
• Sprawdzanie niewłaściwego błędu. Po a, err := f() i b, err := g() upewnij się, że każde if err != nil stoi zaraz po swoim wywołaniu.

if x > 10 {
	fmt.Println("big")
} else if x > 5 {
	fmt.Println("medium")
} else {
	fmt.Println("small")
}