Les conditions en Go

Les conditions permettent à un programme de choisir quoi faire selon une valeur booléenne. Go propose deux outils : l’instruction if et l’instruction switch. Les conditions ne sont jamais entre parenthèses, et les accolades sont toujours obligatoires.

if, else if et else

Un if exécute son bloc lorsque la condition vaut true. Vous enchaînez des alternatives avec else if et prévoyez un cas par défaut avec else.

age := 20
if age >= 18 {
	fmt.Println("Vous pouvez voter.")
} else if age >= 16 {
	fmt.Println("Presque l’âge.")
} else {
	fmt.Println("Trop jeune pour voter.")
}

Une seule branche s’exécute : Go évalue les conditions de haut en bas et s’arrête à la première qui vaut true.

Le if avec une instruction courte

Un if peut commencer par une instruction courte exécutée avant la condition. Toute variable qu’elle déclare est limitée au if et à ses branches else, ce qui garde les valeurs éphémères hors de la fonction. C’est la façon idiomatique de traiter une erreur là où elle apparaît :

if n, err := strconv.Atoi("42"); err == nil {
	fmt.Println(n + 1)
} else {
	fmt.Println("pas un nombre :", err)
}

Ici, n et err n’existent plus après le bloc if : ils ne peuvent donc ni polluer le reste de la fonction ni être réutilisés par erreur.

switch

Un switch compare une valeur à plusieurs cas. Contrairement au C, Go n’enchaîne pas sur le cas suivant : vous n’écrivez jamais break. Un même cas peut aussi correspondre à une liste de valeurs.

switch jour {
case "Sam", "Dim":
	fmt.Println("week-end")
default:
	fmt.Println("jour de semaine")
}

Un switch sans expression (un switch sans tag) remplace élégamment une longue chaîne de if/else if : le premier cas dont la condition vaut true l’emporte.

switch {
case note >= 90:
	fmt.Println("A")
case note >= 80:
	fmt.Println("B")
default:
	fmt.Println("C ou moins")
}

Opérateurs de comparaison et booléens

Les conditions se construisent avec les opérateurs de comparaison — ==, !=, <, <=, >, >= — combinés aux opérateurs booléens && (et), || (ou) et ! (non). && et || sont à court-circuit : ils s’arrêtent dès que le résultat est connu.

if n > 0 && n%2 == 0 {
	fmt.Println("positif et pair")
}

Un exemple complet

Le programme ci-dessous analyse une chaîne, classe le nombre et illustre les deux formes de switch. Il compile et s’exécute tel quel.

package main

import (
	"fmt"
	"strconv"
)

func main() {
	raw := "42"

	// if avec instruction courte : n et err sont limités au if.
	n, err := strconv.Atoi(raw)
	if err != nil {
		fmt.Printf("%q n’est pas un nombre valide\n", raw)
		return
	}

	// if / else if / else avec opérateurs de comparaison et booléens.
	if n > 0 && n%2 == 0 {
		fmt.Printf("%d est positif et pair\n", n)
	} else if n > 0 {
		fmt.Printf("%d est positif et impair\n", n)
	} else if n == 0 {
		fmt.Println("la valeur est zéro")
	} else {
		fmt.Printf("%d est négatif\n", n)
	}

	// switch sans tag : le premier cas vrai gagne, sans break.
	switch {
	case n < 10:
		fmt.Println("un chiffre")
	case n < 100:
		fmt.Println("deux chiffres")
	default:
		fmt.Println("beaucoup de chiffres")
	}

	// switch à expression avec une liste de cas.
	switch n % 3 {
	case 0:
		fmt.Println("divisible par trois")
	case 1, 2:
		fmt.Println("non divisible par trois")
	}
}

Son exécution affiche :

42 est positif et pair
deux chiffres
divisible par trois

Erreurs fréquentes

• Mettre des parenthèses autour de la condition. Écrivez if n > 0 {, pas if (n > 0) {. gofmt ne les enlève pas, mais ce n’est pas idiomatique.
• Attendre un enchaînement. En Go, un cas ne se poursuit pas dans le suivant. Listez plusieurs valeurs dans un même cas au lieu d’empiler des cas vides.
• Comparer des types incompatibles. == exige le même type des deux côtés ; convertissez d’abord une valeur, par exemple float64(i) == f.

À vous de jouer

Avec note := 84, affichez une seule lettre : A pour 90 ou plus, B pour 80 à 89, C pour 70 à 79, et F sinon.

package main

import "fmt"

func main() {
	note := 84

	switch {
	case note >= 90:
		fmt.Println("A")
	case note >= 80:
		fmt.Println("B")
	case note >= 70:
		fmt.Println("C")
	default:
		fmt.Println("F")
	}
}

Résumé

• if, else if et else exécutent exactement une branche, sans parenthèses.
• La forme if à instruction limite la portée d’une valeur à sa propre vérification.
• Un switch n’enchaîne jamais par défaut ; un switch sans tag remplace les longues chaînes de if.

Ensuite, apprenez à répéter du travail avec les boucles en Go, puis à regrouper votre logique dans des fonctions.