Golang, souvent appelé simplement Go, est un langage de programmation open source conçu par Google et publié en 2009. Créé par Robert Griesemer, Rob Pike et Ken Thompson, ce langage vise à offrir une solution rapide, efficace, et facilement maintenable pour le développement logiciel moderne, notamment dans les systèmes distribués, le cloud, et les infrastructures back-end.
Pour quels domaines d'application ?
Le langage Go est d’un intérêt particulier dans différents domaines, dont notamment :
- Systèmes cloud et distribués : Go est souvent utilisé dans les environnements de cloud computing où il est particulièrement prisé pour les applications en cloud natif et microservices.
- Infrastructures back-end : Étant un langage compilé très performant, Go est une excellente option pour les back-end de plateformes de grande envergure, telles que les systèmes de gestion de données et les API.
- Services web : De nombreuses entreprises l’utilisent pour développer des programmes Go qui sont fiables et scalables, comme Docker ou Kubernetes.
Avantages et inconvénients
Golang présente de nombreux avantages, mais il a aussi des inconvénients qu’il est important de considérer.
Avantages
Inconvénients
Simplicité : Sa syntaxe est simple, claire et facile à lire.
Absence de génériques : Jusqu’à récemment, Go ne proposait pas de génériques, ce qui pouvait rendre certaines structures de données plus complexes à manipuler.
Performances élevées : Go est un langage compilé, ce qui le rend rapide à l’exécution, proche du niveau des performances du C ou du C++.
Syntaxe rudimentaire : La simplicité peut avoir un coût. Par exemple, le langage manque de certaines abstractions avancées que l’on trouve dans d’autres langages.
Gestion de la concurrence : Les goroutines sont un mécanisme puissant permettant la concurrence de manière efficace et simple.
Gestion des erreurs : Le traitement des erreurs est volontairement verbeux, ce qui peut rendre le code Go plus long et plus difficile à lire.
Cross-compilation : Go permet de compiler du code source pour plusieurs plateformes avec une grande facilité.
Riche écosystème de bibliothèques : Il offre un écosystème riche en bibliothèques et outils.
Structure du langage
Go est un langage relativement proche du C en termes de syntaxe.
Les paquets
Un paquet (package) est une unité de modularité et de distribution. Chaque fichier Go fait partie d’un paquet, et les paquets permettent de réutiliser du code d’une manière structurée.
- package main : Ce paquet particulier indique le point d’entrée d’un programme exécutable. Si vous développez une application, celle-ci doit inclure le paquet main.
- Les autres paquets peuvent être importés pour fournir des fonctionnalités supplémentaires, comme fmt pour la gestion des entrées/sorties.
Les imports
Les imports en Go permettent d’utiliser des paquets externes ou des paquets de la bibliothèque standard pour enrichir les fonctionnalités de votre programme.
Par exemple, le code suivant importe un paquet (fmt) de la bibliothèque standard :
import "fmt"
Les imports multiples sont possible, de la façon suivante :
import (
"fmt"
"time"
)
Les fonctions
Les fonctions en Go sont des blocs de code qui effectuent une tâche spécifique. La fonction main est obligatoire car elle constitue le point de départ de tout programme Go.
La fonction suivante, nommée Hello prend un nom en paramètre et retourne une salutation :
func hello(name string) string {
return "Hello, " + name
}
Les variables
Les variables sont déclarées avec le mot-clé var, mais peuvent aussi être définies plus succinctement avec l’opérateur := pour une déclaration implicite.
L’exemple suivant montre une première variable déclarée explicitement comme une chaîne de caractère, et une seconde déclaré implicitement comme un entier.
var message string = "Hello World!"
nombre := 42
Le typage
Go est un langage à typage statique : chaque variable est déterminée au moment de la compilation.
Le contrôle de flux
En Go, le contrôle de flux comprend les instructions classiques comme if…else, for et switch. En revanche, il ne possède pas de boucle while, bien que for peut être utilisée de manière similaire.
Ici, la boucle imprime les chiffres de 0 à 9 :
for i := 0; i < 10; i++ {
fmt.Println(i)
}
La boucle if suivante affiche si le nombre est pair ou impair :
number := 7
if number%2 == 0 {
fmt.Println("The number is even")
} else {
fmt.Println("The number is odd")
}
L’instruction switch suivante évalue la valeur dans la variable day et exécute le bloc correspondant :
day := "tuesday"
switch day {
case "monday":
fmt.Println("Start of the week")
case "tuesday":
fmt.Println("Second day of the week")
case "wednesday":
fmt.Println("Middle of the week")
default:
fmt.Println("Day not specified")
}
Structure des données
Plusieurs structures de données sont possibles, comme les tableaux, les slices, les maps et les structs.
- Les slices permettent de manipuler des séquences de données de manière flexible :
numbers := []int{1, 2, 3, 4, 5}
fmt.Println(numbers)
- Les maps sont une collection de paires clé-valeur, à l’instar des dictionnaires dans d’autres langages :
capitals := map[string]string{"France": "Paris", "Italy": "Roma"}
fmt.Println(capitals["France"])
Commandes de base
Golang dispose de plusieurs commandes de base pour faciliter la gestion et l’exécution du code :
- go fmt : Formate automatiquement le code Go pour le rendre plus lisible.
- go run : Compile et exécute le code Go directement.
- go test : Fournit un framework intégré pour l’écriture et l’exécution de tests unitaires.
- go build : Compile le code source pour produire un exécutable.
capitals := map[string]string{"France": "Paris", "Italy": "Roma"}
fmt.Println(capitals["France"])
Goroutine et concurrence
L’une des caractéristiques les plus puissantes de Go est sa capacité à gérer la concurrence à l’aide des goroutines. Ce sont des fonctions qui s’exécutent de manière concurrente avec le reste du programme. Pour lancer une goroutine, il suffit de préfixer un appel de fonction avec le mot-clé go.
Voici un exemple :
package main
import (
"fmt"
"time"
)
func worker(mytask string) {
for i := 0; i < 3; i++ {
fmt.Printf("%s : iteration %d\n", mytask, i)
time.Sleep(500 * time.Millisecond)
}
}
func main() {
go worker("Task1")
go worker("Task2")
worker("Main task")
// Waiting for goroutine to end
time.Sleep(2 * time.Second)
}
Les goroutines Task1 et Task2 s’exécutent en parallèle avec Main task.
Conclusion
Golang est un langage puissant. Sa simplicité, sa gestion efficace de la concurrence via les goroutines, et la qualité de ses outils et bibliothèques en font un choix attrayant pour de nombreux projets modernes.
