Go (également connu sous le nom de Golang) est un langage de programmation open-source, statiquement typé. Il a été développé à l'origine par Google. Certaines fonctionnalités notables de Go incluent la simplicité, la haute performance, la lisibilité et l'efficacité.
Comme tout autre langage de programmation de premier plan, la bibliothèque standard de Go offre un riche ensemble de packages. Cependant, nous pouvons également étendre les fonctionnalités en incorporant des packages tiers. Ce guide va vous montrer comment importer des packages et les incorporer dans vos projets Go.
Prérequis
Pour suivre ce guide, vous aurez besoin des composants suivants préparés à votre disposition :
- Un serveur Ubuntu correctement configuré. En savoir plus sur la configuration de votre propre serveur Ubuntu sur CloudSigma.
- L'environnement de programmation Go. Vous pouvez utiliser ce guide sur l'installation de Go sur Ubuntu.
- Un éditeur de texte moderne, par exemple, Vim, Sublime Text, Atom, Visual Studio Code, Brackets, etc. Ce guide utilisera Visual Studio Code .
Étape 1 – Installation de Go
Nous avons déjà abordé l'installation du cœur du langage de programmation Go sur Ubuntu 20.04. Cependant, il existe une méthode alternative plus simple : g (un gestionnaire de versions Go léger).
La raison pour laquelle nous allons utiliser g est qu'aucune des versions de Go disponibles dans les dépôts de packages d'Ubuntu ou snap ne propose la dernière version de Go disponible (v1.18 au moment de la rédaction de ce guide). Il est toujours recommandé d'utiliser la dernière version disponible de tout package de langage de programmation.
La commande suivante exécutera le g script d'installation :
|
1 |
wget -qO- https://git.io/g-install | sh -s |
Pour que les modifications prennent effet, vous devez redémarrer la session shell. Après le redémarrage, vérifiez l'installation :
|
1 |
go version |
|
1 |
which go |
Après avoir installé Go, il est également recommandé d'installer gopls . C'est le serveur de langage Go officiel. Il est compatible avec de nombreux éditeurs de texte comme VS Code, Vim, Emacs, Sublime Text, Atom et bien d'autres. Exécutez la commande suivante :
|
1 |
go install golang.org/x/tools/gopls@latest |
Notre environnement de programmation Go est maintenant prêt.
Étape 2 – Création d'un script Go d'exemple
Tous les codes présentés dans ce guide tiendront dans un seul script Go. Créez un script Go d'exemple :
|
1 |
touch practice.go |
Après avoir apporté des modifications au script, nous pouvons l'exécuter à l'aide de la commande Go suivante :
|
1 |
go run practice.go |
Ici, le compilateur Go exécutera le code en mode interpréteur.
Étape 3 – Utilisation des packages de la bibliothèque standard
Go est livré avec une vaste collection dans sa bibliothèque standard. Elle se compose de nombreux packages, par exemple :
- fmt: Implémente des E/S formatées avec des fonctions analogues au C ( printf et scanf ).
- http: Ce package fournit des fonctions pour créer des services web, envoyer et récupérer des données via le http protocole, etc.
Pour incorporer un package dans un projet Go, il doit être implémenté à l'aide de l'instruction import . L'instruction est déclarée par le mot-clé import accompagné des noms des packages. Par exemple, pour importer math/rand , l'instruction d'importation ressemblerait à ceci :
|
1 |
import "math/rand" |
Le code suivant implémente diverses fonctions du package math/rand :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main import "math/rand" func main() { for i := 0; i < 10; i++ { println(rand.Intn(25)) } } |
Ce code montre une boucle for simple qui affiche 10 entiers aléatoires (de 0 à 24) à l'écran. Ici :
- rand.Int() : Cet appel de fonction renvoie un entier aléatoire.
- rand.Intn() : Agit de manière similaire à rand.Int() mais accepte un paramètre qui définit la plage des entiers aléatoires (de 0 au nombre spécifié).
Ensuite, exécutez le code :
|
1 |
go run practice.go |
La sortie ressemblera à ceci :
Notez que la sortie sera exactement la même car la graine du générateur de nombres aléatoires est une valeur fixe par défaut. C'est la nature d'un générateur de nombres pseudo-aléatoires. Vous pouvez en savoir plus sur la graine aléatoire ici.
Étape 4 – Importer plusieurs packages
Les projets plus grands et plus complexes doivent intégrer plusieurs packages. Comment les importer dans votre code Go ? Une option valide consiste à utiliser des instructions d'importation individuelles pour chaque package importé. Cependant, cette approche est inefficace par rapport à la structure d'importation suivante :
|
1 2 3 4 5 6 7 8 9 |
import ( "<package_1>" "<package_2>" "<package_3>" ) |
Ici, une seule instruction d'importation intègre plusieurs packages en même temps. Cela réduit la quantité de code à écrire tout en améliorant la lisibilité.
Le code suivant met cette fonctionnalité en action :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main import ( "fmt" "math/rand" ) func main() { for i := 0; i < 10; i++ { fmt.Printf("%d) %d\n", i, rand.Intn(25)) } } |
Exécutez le code :
|
1 |
go run practice.go |
La sortie ressemblera à ceci :
Étape 5 – Installer des bibliothèques Go supplémentaires
La bibliothèque standard de Go est fournie avec de nombreux packages utiles. Ceux-ci sont, par conception, à usage général. Cela permet aux développeurs de créer leurs propres packages par-dessus la bibliothèque standard pour répondre à leurs besoins spécifiques. Consultez le site officiel base de données des packages Go.
What if you need to implement a third-party Go package? Go ships with the go install command ( go get is deprecated). It can grab any third-party Go package from the internet.
Pour la démonstration, nous allons installer le package cobra-cli . La commande Go suivante va télécharger et installer les fichiers nécessaires et intégrer le package dans le système de bibliothèque Go :
|
1 |
go install github.com/spf13/cobra-cli@latest |
Le binaire de cobra-cli devrait se trouver à l'emplacement suivant :
|
1 |
ls -l $GOPATH/bin |
Les autres fichiers du package devraient se trouver à l'emplacement suivant :
|
1 |
ls -l $GOPATH/pkg/mod/github.com/spf13 |
À partir de Go v1.11, les modules Go définissent la version du package que vous souhaitez importer. Ceci est expliqué en détail ici : GitHub des modules Go.
Étape 6 – Alias de package
Dans diverses situations, vous pouvez rencontrer des conflits de noms de packages entre les packages locaux et importés. C'est là que l'utilisation d'alias peut résoudre la collision. La structure d'alias ressemble à ceci :
|
1 |
import <alias> "import_package_name" |
Modifions notre programme Go simple pour incorporer fmt_alias comme alias pour le package fmt :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main import ( fmt_alias "fmt" "math/rand" ) func main() { for i := 0; i < 10; i++ { fmt_alias.Printf("%d) %d\n", i, rand.Intn(25)) } } |
Notez qu'au lieu d'utiliser fmt.Printf() , nous utilisons l'alias de package fmt_alias.Printf() .
Cependant, Go n'est pas très favorable aux alias. Lorsque vous utilisez des alias pour éviter une collision de noms d'importation, il est recommandé de créer un alias pour l'importation la plus locale ou spécifique au projet. Par exemple, si vous souhaitez avoir à la fois un package local strings et un package système strings , vous devriez alors créer un alias pour le package local, pas pour le package système.
La meilleure pratique consiste à éviter les collisions de noms dès le départ.
Étape 7 – Formatage des importations
Nous avons appris à déclarer toutes les importations à l'aide d'une seule instruction import . Et si vous aviez plusieurs importations ? Par exemple :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import ( "fmt" "os" "github.com/example/foo" "github.com/example/bar" "math/rand" "github.com/abc/pqr/xyz" ) |
Le formatage des imports trie les packages dans un ordre spécifique, améliorant ainsi la cohérence du code. Comme il ne fait que trier l'ordre des imports, il évite également les commits aléatoires. Il évite aussi les modifications de code inutiles et les revues de code confuses.
La plupart des éditeurs modernes formateront automatiquement les imports pour vous. Alternativement, ils prennent en charge goimports. C’est une pratique courante dans l'industrie d'utiliser goimports au lieu de trier manuellement les imports. De plus, goimports reflète également les changements de style dans le code.
Voici ce à quoi le bloc import peut ressembler après l'application de goimports :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import ( fmt_alias "fmt" "math/rand" "os" "github.com/example/foo" "github.com/example/bar" "github.com/abc/pqr/xyz" ) |
Remarquez-vous un motif ?
- Toutes les bibliothèques standard sont regroupées en premier.
- Les groupes sont séparés par des lignes vides, ce qui améliore la lisibilité du code.
Dernières réflexions
L'importation en Go est une fonctionnalité puissante qui permet d'appeler des fonctions non intégrées à Go. Bien que la bibliothèque standard propose de nombreux packages d'usage général, Go prend également en charge les packages tiers. Ce guide montre comment importer des packages Go intégrés et tiers.
Dans ce guide, nous avons exécuté nos programmes Go à l'aide de l'interpréteur. Cependant, vous pouvez compiler le code en binaires autonomes pour de meilleures performances. Vous pouvez en savoir plus sur la compilation de programmes Go ici. Si vous souhaitez apprendre à déployer une application web Go avec Nginx, consultez ce tutoriel. De plus, vous pouvez jeter un œil à notre guide qui présente comment écrire vos propres packages Go.
Êtes-vous un développeur Go ? CloudSigma propose la prise en charge de l'API Go pour une intégration transparente avec vos projets.
Bon développement !
Commentaires
Aucun commentaire pour l'instant. Soyez le premier.