If else en Golang : syntaxe, instruction d'initialisation et if err != nil

Le if de Go n'a pas de parenthèses autour de la condition, exige toujours des accolades, et peut commencer par une courte instruction qui déclare des variables dont la portée se limite au 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))
	}
}

Les conditions sont testées de haut en bas et la première branche vraie s'exécute. else if et else sont facultatifs.

Règles de syntaxe

Trois règles diffèrent de C, Java et JavaScript :

1. Pas de parenthèses autour de la condition. if (x > 5) compile, mais gofmt retire les parenthèses.
2. Les accolades sont obligatoires, même pour une seule instruction. Il n'existe pas de if x > 5 return sans accolades.
3. else se place sur la même ligne que l'accolade fermante. Go insère un point-virgule après une } en fin de ligne, donc ceci échoue :

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

syntax error: unexpected keyword else, expected }

Écrivez } else { sur une seule ligne.

La condition doit être un bool. Go ne traite pas 0, "" ou nil comme faux, donc if count {} et if name {} ne compilent pas. Comparez explicitement : if count > 0, if name != "", if user != nil.

Combinez les conditions avec && (et), || (ou) et ! (non). && et || s'évaluent en court-circuit, ce qui rend les tests de nil sûrs :

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

if avec une instruction d'initialisation

Un if peut exécuter une courte instruction avant la condition, séparée par un point-virgule. Les variables qui y sont déclarées sont visibles dans toutes les branches de ce if, et nulle part après :

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")
	}
}

Ce motif garde les variables à courte durée de vie hors de la portée environnante. On le voit sans cesse avec les recherches dans une map (v, ok := m[k]), les assertions de type (s, ok := v.(string)) et les erreurs.

Le revers : si vous avez besoin de la valeur après le if, déclarez-la plutôt avant. Une erreur fréquente consiste à placer un résultat dans l'instruction d'initialisation puis à essayer de l'utiliser plus bas.

L'idiome if err != nil

Les fonctions qui peuvent échouer renvoient une error en dernier. Vérifiez-la immédiatement, traitez-la ou renvoyez-la, et continuez le chemin nominal sans indentation :

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)
	}
}

Remarquez qu'il n'y a pas de else après if err != nil { return ... }. Le style Go traite l'erreur, retourne, et laisse le flux normal contre la marge gauche. La page sur la gestion des erreurs couvre l'enveloppement et la vérification des types d'erreur.

Retours anticipés plutôt qu'imbrication

Des blocs if profondément imbriqués sont difficiles à lire. Inversez les conditions et retournez tôt ; chaque vérification se lit alors comme une garde :

// 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
}

Les développeurs Go appellent cela garder le chemin nominal aligné à gauche. Des linters comme revive signalent un else après un bloc qui se termine par return, parce que ce else ajoute de l'indentation pour rien.

if/else ou switch

Une longue chaîne de else if qui teste une valeur contre plusieurs cas se lit mieux sous forme de switch. Un switch sans expression remplace une chaîne if/else if de conditions quelconques :

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

Utilisez if pour une ou deux branches, et switch à partir de trois.

Pas d'opérateur ternaire

Go n'a pas de cond ? a : b. Affectez avec un if :

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

La page sur l'opérateur ternaire explique pourquoi et montre les alternatives.

Erreurs courantes

• Le masquage avec :=. if x, err := f(); err == nil { ... } déclare un nouveau x uniquement pour le if. Un x extérieur n'est pas mis à jour.
• Une affectation dans la condition. if x = 5 {} est une erreur de compilation (cannot use assignment x = 5 as value), pas un bug silencieux comme en C. Utilisez ==.
• Comparer des flottants avec ==. if total == 0.3 échoue pour des valeurs calculées. Comparez avec une tolérance.
• Vérifier la mauvaise erreur. Après a, err := f() et b, err := g(), assurez-vous que chaque if err != nil suit directement son appel.

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