TOC

Importation de packages dans Go

introduction

Il y aura des moments où votre code aura besoin de fonctionnalités supplémentaires en dehors de votre programme actuel. Dans ces cas, vous pouvez utiliser des packages pour rendre votre programme plus sophistiqué. Un package représente tous les fichiers d'un même répertoire sur le disque. Les packages peuvent définir des fonctions, des types et des interfaces que vous pouvez référencer dans d'autres fichiers ou packages Go.

Ce tutoriel vous guidera à travers l’installation, l’importation et la création de pseudonymes.

Paquets de bibliothèque standard

La bibliothèque standard livrée avec Go est un ensemble de packages. Ces packages contiennent la plupart des éléments fondamentaux nécessaires à l’écriture de logiciels modernes. Par exemple, le packagefmt contient des fonctions de base pour le formatage et l'impression des chaînes. Le packagenet/http contient des fonctions qui permettent à un développeur de créer des services Web, d'envoyer et de récupérer des données via le protocolehttp, etc.

Pour utiliser les fonctions d'un package, vous devez accéder au package avec une instructionimport. Une instructionimport est constituée du mot-cléimport avec le nom du package.

Par exemple, dans le fichier programme Gorandom.go, vous pouvez importer le packagemath/rand pour générer des nombres aléatoires de cette manière:

random.go

import "math/rand"

Lorsque nous importons un paquet, nous le rendons disponible dans notre programme actuel en tant qu'espace de nommage séparé. Cela signifie que nous devrons nous référer à la fonction endot notation, comme enpackage.function.

En pratique, une fonction du packagemath/rand pourrait ressembler à ces exemples:

  • rand.Int() qui appelle la fonction pour renvoyer un entier aléatoire.

  • rand.Intn() qui appelle la fonction pour renvoyer un élément aléatoire de0 jusqu'au nombre spécifié fourni.

Créons une bouclefor pour montrer comment nous allons appeler une fonction du packagemath/rand dans notre programmerandom.go:

random.go

package main

import "math/rand"

func main() {
  for i := 0; i < 10; i++ {
    println(rand.Intn(25))
  }
}

Ce programme importe d'abord le packagemath/rand sur la troisième ligne, puis se déplace dans une bouclefor qui s'exécutera 10 fois. Dans la boucle, le programme imprimera un entier aléatoire dans la plage de0 à25. L'entier25 est passé àrand.Intn() comme paramètre.

Lorsque nous exécutons le programme avecgo run random.go, nous recevrons 10 entiers aléatoires en sortie. Celles-ci étant aléatoires, vous obtiendrez probablement des entiers différents à chaque fois que vous exécuterez le programme. La sortie ressemblera à ceci: 

Output6
12
22
9
6
18
0
15
6
0

Les entiers ne seront jamais inférieurs à 0 ni supérieurs à 24.

Lors de l'importation de plusieurs packages, vous pouvez utiliser les() pour créer un bloc. En utilisant un bloc, vous pouvez éviter de répéter le mot-cléimport sur chaque ligne. Cela rendra votre code plus propre:

random.go

import (
  "fmt"
  "math/rand"
)

Pour utiliser le package supplémentaire, nous pouvons maintenant formater la sortie et imprimer l'itération sur laquelle chaque nombre aléatoire a été généré pendant la boucle:

random.go

package main

import (
  "fmt"
  "math/rand"
)

func main() {
  for i := 0; i < 10; i++ {
    fmt.Printf("%d) %d\n", i, rand.Intn(25))
  }
}

Maintenant, lorsque nous exécutons notre programme, nous recevons une sortie qui ressemble à ceci: 

Output0) 6
1) 12
2) 22
3) 9
4) 6
5) 18
6) 0
7) 15
8) 6
9) 0

Dans cette section, nous avons appris à importer des packages et à les utiliser pour écrire un programme plus sophistiqué. Jusqu'à présent, nous n'avons utilisé que des packages de la bibliothèque standard. Voyons ensuite comment installer et utiliser des packages écrits par d’autres développeurs.

Installation de packages

Bien que la bibliothèque standard soit livrée avec de nombreux packages intéressants et utiles, ils sont intentionnellement conçus pour êtregeneral purpose et non de nature spécifique. Cela permet aux développeurs de construire leurs propres packages sur la bibliothèque standard pour leurs propres besoins.

La chaîne d'outils Go est livrée avec la commandego get. Cette commande vous permet d'installer des packages tiers dans votre environnement de développement local et de les utiliser dans votre programme.

Lors de l'utilisation dego get pour installer des packages tiers, il est courant qu'un package soit référencé par son chemin canonique. Ce chemin peut également être un chemin vers un projet public hébergé dans un référentiel de code tel que GitHub. En tant que tel, si vous souhaitez importer le packageflect, vous utiliserez le chemin canonique complet: 

go get github.com/gobuffalo/flect

L'outilgo get trouvera le package, sur GitHub dans ce cas, et l'installera dans vos$GOPATH.

Pour cet exemple, le code serait installé dans ce répertoire: 

$GOPATH/src/github.com/gobuffalo/flect

Les paquetages sont souvent mis à jour par les auteurs originaux pour résoudre des problèmes ou ajouter de nouvelles fonctionnalités. Dans ce cas, vous souhaiterez peut-être utiliser la dernière version de ce package pour tirer parti des nouvelles fonctionnalités ou du bogue résolu. Pour mettre à jour un package, vous pouvez utiliser l'indicateur-u avec la commandego get: 

go get -u github.com/gobuffalo/flect

Cette commande aura également Go installera le paquet s'il n'est pas trouvé localement. S'il est déjà installé, Go tentera de mettre à jour le paquet vers la dernière version.

La commandego get récupère toujours la dernière version du package disponible. Toutefois, il se peut que des mises à jour de versions précédentes du paquet soient encore plus récentes que vous utilisez et qu'il serait utile de les mettre à jour dans votre programme. Pour récupérer cette version spécifique du package, vous devez utiliser un outilPackage Management, tel queGo Modules.

À partir de Go 1.11, les modules Go sont utilisés pour gérer la version du package que vous souhaitez importer. Le sujet de la gestion des paquets dépasse le cadre de cet article, mais vous pouvez en savoir pluson the Go Modules GitHub page.

Aliasing des paquets importés

Vous souhaiterez peut-être modifier le nom d'un package si un package local porte déjà le même nom qu'un package tiers que vous utilisez. Dans ce cas, aliaser votre importation est le meilleur moyen de gérer la collision. Vous pouvez modifier les noms des packages et leurs fonctions dans Go en plaçant un nomalias devant le package importé.

La construction de cette déclaration ressemble à ceci: 

import another_name "package"

Dans cet exemple, modifiez le nom du packagefmt dans le fichier programmerandom.go. Nous allons changer le nom du package defmt enf afin de l'abréger. Notre programme modifié ressemblera à ceci:

random.go

package main

import (
 f "fmt"
  "math/rand"
)

func main() {
  for i := 0; i < 10; i++ {
    f.Printf("%d) %d\n", i, rand.Intn(25))
  }
}

Dans le programme, nous nous référons maintenant à la fonctionPrintf en tant quef.Printf plutôt quefmt.Printf.

Alors que d'autres langues préfèrent utiliser un alias pour créer un paquet plus facilement dans le programme, Go ne le fait pas. Par exemple, aliaser le packagefmt versf ne serait pas cohérent avec lesstyle guide.

Lorsque vous renommez des importations pour éviter une collision de noms, vous devez essayer de renommer l'importation la plus locale ou la plus spécifique au projet. Par exemple, si vous aviez un packagelocal appeléstrings, et que vous deviez également importer le packagesystem appeléstrings, vous préféreriez renommer votre package local plutôt que le système paquet. Autant que possible, il vaut mieux éviter la collision de noms.

Dans cette section, nous avons appris comment aliaser une importation pour éviter une collision avec une autre importation de notre programme. Il est important de garder à l'esprit que la lisibilité et la clarté de votre programme sont importantes. Par conséquent, vous ne devriez utiliser que l'aliasing pour rendre le code plus lisible ou pour éviter une collision de noms.

Mise en forme des importations

En formatant les importations, vous pouvez trier les packages dans un ordre spécifique qui rendra votre code plus cohérent. De plus, cela empêchera des commits aléatoires lorsque la seule chose qui change est l'ordre de tri des importations. Étant donné que le formatage des importations empêchera les commits aléatoires, cela évitera une perte inutile de code et des révisions de code source de confusion.

La plupart des éditeurs formateront automatiquement les importations pour vous ou vous permettront de configurer votre éditeur pour utilisergoimports. Il est considéré comme une pratique courante d'utilisergoimports dans votre éditeur, car essayer de maintenir manuellement l'ordre de tri de vos importations peut être fastidieux et sujet à des erreurs. De plus, si des modifications de style sont apportées,goimports sera mis à jour pour refléter ces modifications de style. Cela garantit que vous, et quiconque travaille sur votre code, disposerez d'un style cohérent dans vos blocs d'importation.

Voici à quoi peut ressembler un exemple de bloc d'importation avant le formatage: 

import (
  "fmt"
  "os"
  "github.com/digital/ocean/godo"
  "github.com/sammy/foo"
  "math/rand"
  "github.com/sammy/bar"
)

En exécutant l'outilgoimport (ou avec la plupart des éditeurs qui l'ont installé, enregistrer le fichier le lancera pour vous), vous aurez maintenant le format suivant: 

import (
  "fmt"
  "math/rand"
  "os"

  "github.com/sammy/foo"
  "github.com/sammy/bar"

  "github.com/digital/ocean/godo"
)

Notez qu’il regroupe d’abord tous les packages de bibliothèque standard, puis les packages tiers avec des lignes vides. Cela facilite la lecture et la compréhension des packages utilisés.

Dans cette section, nous avons appris que l'utilisation degoimports conservera tous nos blocs d'importation correctement formatés et évitera une rotation inutile du code entre les développeurs travaillant sur les mêmes fichiers.

Conclusion

Lorsque nous importons des packages, nous pouvons appeler des fonctions qui ne sont pas intégrées à Go. Certains paquets font partie de la bibliothèque standard qui s'installe avec Go, et certains seront installés viago get.

L'utilisation de packages nous permet de rendre nos programmes plus robustes et puissants au fur et à mesure que nous exploitons le code existant. Nous pouvons également utilisercreate our own packages pour nous-mêmes et pour d'autres programmeurs dans de futurs programmes.

Related