J’ai toujours été très admiratif de Joël Spolsky (créateur de Trello qu’il a revendu $425M) et de ses articles excellents. Il les a retirés de son wiki mais je les ai récupérés, et je vous les mets à disposition ici, avec, pour chaque article le lien d’origine.

• Unicode : le minimum absolu que tout développeur doit savoir
• La loi des abstractions qui fuient

Mémo go

Uniquement des notes sur ce qui est « original » dans le langage « go », par rapport aux autres langages.

Variables

Déclaration

Par rapport à tous les autres langages, il faut le faire à l’envers :
var x int
Et pour un tableau : var [nom] [[longueur]][type], exemple :
var s [3]int

Initialisation avec des valeurs

Pas d’explication, un exemple direct suffit : arr := [2]int{2, 4}

Inférence de type

Une déclaration complète d’une variable serait var i int = 12
Une déclaration ultra simplifiée acceptable est i := 12 et dans ce cas, Go va tenter de deviner le type (« type inference »).

Comparaison de tableaux

La déclaration de variables se fait toujours en précisant la longueur, et au moment de comparer, il faut que les tableaux aient exactement la même longueur, sinon on aura une erreur. C’est pour cela que les tableaux sont moins utilisés que le type slice.

Comparaison = avoir des types identiques

Go n’essaie jamais de transformer les variables en booléens pour pouvoir les comparer, c’est à nous transformer une variable ou l’autre de manière à ce qu’elles aient toujours le même type.

Création d’une variable dans un « if »

Exemple direct : if b:= a / 2; b > 5 {...} else {...}
La variable b n’existera que dans le bloc if / else.

Boucle for / range

s := "Bonjour"
for k, v := range s {
    fmt.Println(k, v, string(v))
}

k correspond à l’index, et n’est pas toujours incrémenté que de 1, selon l’encodage. C’est la méthode à utiliser pour parcourir une chaîne en utf8. Car via un classique for, Go parcourra la chaîne « à la » C, c’est à dire que un caractère = un octet (ce qui n’est pas le cas en utf8).

Switch / case

Par défaut, les « break » sont implicites, pas besoin de les mettre. Si on veut exécuter l’instruction du « case » suivant (= comme en C ou JavaScript), il faut le dire explicitement via « fallthrough« .

Il est possible de créer une variable qui ne vivra que le temps du switch / case, exemple :

switch l := len(word); word {
    ...blabla...
}

Contrairement aux autres langages, il ne faut pas mettre plusieurs case d’affilée pour gérer plusieurs cas au même endroit, il suffit de les séparer par une virgule, exemple pour continuer le précédent :

switch l := len(word); word {
case 1 < l && l < 10, word == "ok":
    fmt.Println("Soit mot : 1 < longueur < 10, soit il vaut 'ok'")
}

Fonctions

Appels

Tous les appels de fonction sont par valeur. Jamais par référence. Nombre, booléen, ainsi que les tableaux.

Retours

Le type résultat de retour est après les parenthèses des paramètres et avant l’accolade ouvrante :
func mult(a, b) int {
    return a + b
}

Vous pouvez renvoyer plusieurs valeurs ! Les résultats de retour sont entre parenthèse après les parenthèses des paramètres et avant l’accolade ouvrante :
func divAndRemainder(a, b) (int, int) {
    return a / b, a % b
}
d, r := divAndRemainder(2, 3)
d, _ := divAndRemainder(2, 3)
_, d := divAndRemainder(2, 3)


Vous pouvez nommer les paramètres de retour et les « remplir » dans la fonction. Il faut simplement ajouter return sans rien pour qu’il renvoie le retour sans y toucher :
func divAndRemainder(a, b) (div, remainder int) {
    div = a / b
    remainder = a % b
    return
}
d, r := divAndRemainder(2, 3)
d, _ := divAndRemainder(2, 3)
_, d := divAndRemainder(2, 3)


Fonctions en tant que variable

Exemple direct :
func myFunc() {
    f := func(a int) int {
        return a + 1
    }
    fmt.Println(f(1))
}

Fonctions en tant que paramètres

Exemple direct d’un paramètre qui doit être « une fonction qui prend un entier en tant que paramètre et renvoie un entier » :
func myFunc(a int, f func(int) int) {
    fmt.Println(f(a))
}

Tableaux

Base : var a [2]int

fmt.Println("Array a", a, len(a))

Mieux : slice var a []int

La différence entre slice et array ? On ne précise pas le nombre d’éléments.

Pointeurs

Très proche du C. Un exemple direct suffit :
var p *int
i := 4 // int declaration
p = &i // assign the address of the variable to the pointer
*p = 45 // change the value of the variable i
fmt.Println(p, *p) // prints address then value

Switch / case

C’est l’inverse du C : les break sont implicites, et si on veut vraiment continuer sur le case suivant, il faut utiliser le mot-clé fallthrough :

switch i := myfunc(); {
case i < 0:
    fmt.Println("negative")
    fallthrough
case i == 0:
    fmt.Println("zero")
default:
    fmt.Println("positive")
}

Conversions

Bizzareries

Pointeurs et structures

Vous pouvez déclarer une structure, et la créer dynamiquement, puis créer un pointeur vers elle. En C, quand on utilise les pointeurs, l’indirection pour accéder aux membres est "->", donc on ne peut pas se tromper. Ici, on utilise la même syntaxe, que ce soit avec une structure, directement, ou avec un pointeur, donc indirectement. Exemple concret :

type People struct {
    name string
    height int
}
var value People
value.name = "Olivier"
value.height = 190
ptr := &value
ptr.name = "Thibault"
ptr.height = 185

Donc on écrit value.name et ptr.name alors que l’un est une struct et l’autre un pointeur. Je n’aime pas du tout cela, cela prête clairement à confusion.

Astuces classiques

Site officiel

Packages

Curl hints / aide

curl -v -H "Host:www.djangoproject.com" https://www.olivierpons.fr/