Go

Aujourd'hui au programme : les boucles, le switch et les fonctions.

Après mes lectures de cette semaine, j'ai appris plusieurs choses, certaines étranges et d'autres vraiment intéressantes. Les voici :

Les Boucles en Go Go propose quatre façons de définir une boucle :

La boucle traditionnelle (type for classique)

for i := 0; i < 10; i++ {
	// du code
}

La boucle while (Go utilise for à la place)

i := 0
for i < 10 {
	i++
}

La boucle infinie (qui peut servir de do-while)

i := 0
for {
	// Code à exécuter au moins une fois
	if i >= 10 {
		break
	}
	i++
}

La boucle for range (style Python)

tab := []int{2, 4, 6, 8}
for index, valeur := range tab {
	fmt.Println(index, valeur)
}

L'objectif de Go est d'avoir le moins de mots-clés possible. C'est probablement la raison pour laquelle il n'existe pas de while ou do-while. Cela peut sembler contre-intuitif pour ceux qui ont appris la programmation en Java ou C#, mais toutes les fonctionnalités essentielles sont présentes.

Ignorer une variable avec _

Tu nous as dit l'autre jour que tout le monde doit utiliser des variables. Mais que faire si on n'a pas besoin de l'index dans une boucle ?

Que ce soit pour une variable dans une boucle ou une valeur retournée par une fonction, il est possible d'utiliser _ si on ne souhaite pas la récupérer :

tab := []int{2, 4, 6, 8}
for _, valeur := range tab {
	fmt.Println(valeur)
}

Le Switch en Go

Voici un exemple d'utilisation du switch :

mots := []string{"hello", "bye", "byebye"}
for _, mot := range mots {
	switch longueur := len(mot); longueur {
		case 4:
			fmt.Println(longueur) // Disponible dans tout le switch
		case 3:
			lenMot := len(mot) // Disponible dans le case 3: seulement
			fmt.Println(lenMot)
		default:
			fmt.Println("trop long")
	}
}

Moi non plus, je ne comprenais pas au début, mais maintenant, j'ai compris comment fonctionne le switch en Go. Dans un switch, il est possible de définir une variable (longueur ici), qui sera accessible dans tout le bloc switch.

En revanche, si tu déclares une variable dans un case spécifique (ex: lenMot), elle ne sera disponible que dans ce case.

Autre particularité de Go : il n'y a pas besoin d'ajouter break à la fin d'un case, contrairement à d'autres langages.

Utiliser switch sans variable (comme une série de if-else) Dans la plupart des langages, switch compare une seule variable, mais en Go, on peut l'utiliser comme une série de if-else :

for i := 1; i <= 100; i++ {
	switch {
		case i < 25:
			fmt.Println("trop bas")
		case i >= 25 && i < 75:
			fmt.Println("encore trop bas")
		case i >= 75 && i < 100:
			fmt.Println("tu t'approches")
		default:
			fmt.Println("bravo!")
	}
}

Ce n'est pas une excuse pour remplacer tous les if-else par des switch, mais cela permet parfois d'écrire un code plus compact.

Les Fonctions en Go

Les fonctions en Go sont des "first-class citizens", ce qui signifie qu'elles peuvent être assignées à des variables.

import (
	"fmt"
	"errors"
)

func division(num, denum int) (int, int, error) {
	if denum == 0 {
		return 0, 0, errors.New("division par 0")
	}
	return num / denum, num % denum, nil
}

func main() {
	resultat, reste, err := division(7, 2)
	if err != nil {
	// Gestion de l'erreur
		fmt.Println(err)
		return
	}
	fmt.Println(resultat, reste)
}

Quelques remarques sur cette fonction :

1️⃣ Dans la déclaration des paramètres, on peut écrire num, denum int plutôt que num int, denum int lorsque les deux ont le même type.

2️⃣ Contrairement à Python, retourner plusieurs valeurs ne signifie pas retourner un tuple. En fait, Go n'a pas de tuples.

C'est pourquoi cette ligne provoque une erreur de compilation :

result := division(7, 2) // Erreur de compilation : trop de valeurs retournées
 

3️⃣nil n'est pas null, mais il y ressemble. On en parlera plus en détail la semaine prochaine. 🚀