Learning Go

Voici mes observations après ma dernière scéance de lecture du livre Learning Go: An Idiomatic Approach to Real-World Go Programming.

Constantes

Go ne contient pas de moyen de savoir si une valeur calculée pendant l’exécution est immuable.

x := 5
y := 6
const z = x + y // x + y (value of type int) is not constant

Une constante typée est uniquement compatible avec son type (float32), tandis qu’une constante non typée est plus malléable.

const pi1 = 3.1416
const pi2 float32 = 3.1416

var y float64 = 10 * pi1
var x float64 = 10 * pi2 // cannot use 10 * pi2 (constant 31.416 of type float32) as float64 value in variable declaration

Nommer une variable x

Go vise la simplicité du code, et une pratique souvent considérée comme réservée aux débutants est pourtant mise en avant par la communauté Go :

Nommer les variables par la première lettre de ce qu’elles représentent.

Vous allez me dire : Mais voyons, tout le monde nous enseigne exactement le contraire !

Et oui, je ne suis pas fan non plus, mais il y a une raison. La vision de Go est que si vous n’êtes pas capable de suivre une ou plusieurs variables nommées w, r, b, etc., c’est que votre code est mal conçu, mal divisé ou trop long.

Je comprends cette vision, mais dans la plupart des cas, les développeurs Go économisent environ 4 ou 5 lettres par mot, ce qui, selon moi, ne change absolument rien à la longueur du code et rend simplement la lecture plus difficile, même si le code est simple.

Exemple tiré de la documentation de la bibliothèque net/http :

http.Handle("/foo", fooHandler)

http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
})

log.Fatal(http.ListenAndServe(":8080", nil))

Array et Slice

Le type array dans Go n’est pas aussi utile que dans la plupart des langages classiques. En effet, il est beaucoup plus rigide.

Un array ne peut pas être déclaré sans une longueur.

var tableau [3]int
var tableau = [3]int{1, 2, 3}

Cet array n’est pas un array de type int avec une longueur de 3. La variable tableau est du type array int de longueur 3.

var tableau = [3]int{1, 2, 3}
var tableau1 [4]int

Ainsi, tableau et tableau1 ne sont même pas du même type.

C’est là que le slice entre en jeu. Il ressemble beaucoup plus à un array traditionnel. Avant de lire ce chapitre, je ne savais même pas qu’il y avait deux types !

var tableau = []int{1, 2, 3}
var tableau1 = []int{5, 6, 7}

tableau = append(tableau, 12)
longueur := len(tableau) // 4
capacité := cap(tableau) // 6
estÉgal := slices.Equal(tableau1, tableau) // false

Le slice possède quelques méthodes prédéfinies très utiles comme append, len et Equal, mais cap est peu courant dans la plupart des langages.

cap représente la capacité du slice. Lorsqu’on ajoute une valeur avec append, Go doit allouer plus de mémoire pour le slice. Par exemple, si la capacité initiale de tableau est 3, dès qu’on appelle append, Go double cette capacité, qui devient alors 6.