Exercice de dactylographie: Programmation en langage Go

Programmer en Go et pratiquer la dactylographie vont de pair. Go impose une syntaxe stricte et utilise des caractères spéciaux qui peuvent poser des difficultés lorsqu'on tape rapidement. Une accolade manquante ou un opérateur mal écrit provoque immédiatement une erreur de compilation.

Qu'est-ce qui caractérise la syntaxe de Go ?

Go est un langage compilé (anglais : compiled language) au style clair et minimaliste. Le code commence toujours par une déclaration package. Les imports sont regroupés en blocs. Les fonctions se déclarent avec le mot-clé func et utilisent des accolades {}. L'indentation n'est pas optionnelle : Go impose la mise en forme via go fmt. Les points-virgules ne sont pas écrits, mais le compilateur les insère automatiquement en fin de ligne.

package main

import "fmt"

func main() {
 fmt.Println("Hello, Go")
}

Caractères importants

On rencontre souvent dans le code Go les accolades {}, les parenthèses (), les crochets [], les guillemets ", les backticks `, l'opérateur d'affectation courte := et l'opérateur de canal <-.

Variables et déclarations

Go distingue var et l'affectation courte :=. Cet opérateur combine deux symboles et revient en permanence dans le code.

var count int = 10
message := "typed correctly"

Structures de contrôle

Go propose if, for et switch. Pas de while. Les opérateurs de comparaison ==, !=, <, > et l'incrément ++ doivent être tapés avec précision.

for i := 0; i < 5; i++ {
 if i%2 == 0 {
 fmt.Println("even")
 }
}

Fonctions et retours multiples

Une fonction peut retourner plusieurs valeurs. Cela implique des virgules supplémentaires dans les listes de retour et les affectations.

func divide(a, b int) (int, error) {
 if b == 0 {
 return 0, fmt.Errorf("division by zero")
 }
 return a/b, nil
}

result, err := divide(10, 2)

Slices, maps et littéraux composés

Les crochets [] et les accolades {} reviennent souvent. Les maps utilisent aussi les deux-points : entre clés et valeurs.

nums := []int{1, 2, 3}
scores := map[string]int{"alice": 5, "bob": 7}

Structs et méthodes

Le type struct regroupe des données. Les méthodes se déclarent avec un receiver et s'appellent avec le point ..

type User struct {
 Name string
}

func (u User) Greet() string {
 return "Hello " + u.Name
}

u := User{Name: "A"}
fmt.Println(u.Greet())

Interfaces

Les interfaces sont satisfaites implicitement, sans mot-clé comme implements.

type Stringer interface {
 String() string
}

Concurrence et canaux

L'opérateur de canal <- est spécifique à Go. Il sert autant à envoyer (ch <- valeur) qu'à recevoir (valeur := <-ch).

ch := make(chan int)
go func() { ch <- 42 }()
value := <-ch

Chaînes et runes

Go utilise les guillemets doubles pour les chaînes, les backticks pour les raw strings et les guillemets simples pour les runes.

text := "normal string"
raw := `path\to\file`
r := 'a'

Indentation et formatage

Go impose un style unique. Les accolades et les retours à la ligne doivent être placés correctement. Une erreur fréquente est un Enter après return.

Résumé

En Go, les caractères essentiels sont : accolades {}, parenthèses (), crochets [], opérateur := et flèche de canal <-. Les maîtriser permet de coder vite et sans erreur.