Comment écrire des packages Go

Un package Go se compose de fichiers Go situés dans le même répertoire, au début desquels se trouve la même expression de package . Les packages qui se connectent aux programmes vous permettent d'étendre leurs capacités. Certains packages font partie de la bibliothèque Go standard. Cela signifie que si vous utilisez Go, ils sont déjà installés. D'autres packages sont installés à l'aide de la commande go get . Vous pouvez également écrire vos propres Go-packages, créer des fichiers dans des répertoires spéciaux et respecter les règles de conception des packages.



Le matériel, dont nous publions la traduction aujourd'hui, est un guide pour le développement de Go-packages pouvant être connectés à d'autres fichiers.

Prérequis

• Configurez votre environnement logiciel Go (découvrez comment procéder ici ). Créez un espace de travail Go (le cinquième point du matériel ci-dessus lui est dédié). Dans la section suivante de ce document, vous trouverez des exemples dont la reproduction est recommandée à la maison. Vous pouvez donc mieux y faire face.
• Pour approfondir vos connaissances sur GOPATH - jetez un œil à ce matériel.

Écriture et importation de packages

L'écriture de code de package est identique à l'écriture de code Go standard. Les packages peuvent contenir des déclarations de fonctions, de types et de variables, qui peuvent ensuite être utilisées dans d'autres programmes Go.

Avant de commencer à créer un nouveau package, nous devons accéder à l'espace de travail Go. Il est situé sur le chemin spécifié par la variable GOPATH . Par exemple, que notre organisation s'appelle gopherguides . En même temps, nous, en tant que référentiel, utilisons GitHub . Cela conduit au fait que, le long du chemin spécifié par GOPATH , nous avons la structure de dossiers suivante:

 └── $GOPATH    └── src        └── github.com            └── gopherguides 

Nous allons nommer le package que nous développerons dans ce guide, greet . Pour ce faire, créez le répertoire d' greet dans le répertoire gopherguides . Par conséquent, la structure de dossiers existante prendra la forme suivante:

 └── $GOPATH    └── src        └── github.com            └── gopherguides                └── greet 

Nous sommes maintenant prêts à ajouter le premier fichier au répertoire d' greet . En règle générale, un fichier qui est le point d'entrée d'un package est appelé de la même manière que le répertoire du package. Dans ce cas, cela signifie que nous, dans le répertoire d' greet , créons le greet.go :

 └── $GOPATH    └── src        └── github.com            └── gopherguides                └── greet                    └── greet.go 

Dans ce fichier, nous pouvons écrire du code que nous voulons réutiliser dans nos projets. Dans ce cas, nous allons créer la fonction Hello , qui affiche le texte Hello, World! .

Ouvrez le fichier greet.go dans un éditeur de texte et ajoutez-y le code suivant:

 package greet import "fmt" func Hello() {    fmt.Println("Hello, World!") } 

Analysons le contenu de ce fichier. La première ligne de chaque fichier doit contenir le nom du package dans lequel nous travaillons. Puisque nous sommes dans le package greet , le mot-clé package est utilisé ici, suivi du nom du package:

 package greet 

Cela indique au compilateur d'accepter tout ce qui se trouve dans le fichier dans le cadre du package d' greet .

Ensuite, les packages nécessaires sont importés à l'aide de l'instruction import . Dans ce cas, nous n'avons besoin que d'un seul paquet - fmt :

 import "fmt" 

Et enfin, nous créons la fonction Hello . Elle utilisera les capacités du package fmt pour afficher la chaîne Hello, World! :

 func Hello() {    fmt.Println("Hello, World!") } 

Maintenant, après la création du package d' greet , vous pouvez l'utiliser dans n'importe quel autre package. Créons un nouveau package dans lequel nous utiliserons le package de greet .

À savoir, nous allons créer un example package. Pour ce faire, nous partirons des mêmes hypothèses à partir desquelles nous avons procédé, en créant le package de greet . Commencez par créer l' example dossier dans le dossier gopherguides :

 └── $GOPATH    └── src        └── github.com            └── gopherguides                    └── example 

Créez maintenant un fichier qui est le point d'entrée du package. Nous considérons ce package comme un programme exécutable et non comme un package dont le code devrait être utilisé dans d'autres packages. Les fichiers qui sont les points d'entrée des programmes sont généralement appelés main.go :

 └── $GOPATH    └── src        └── github.com            └── gopherguides                └── example                    └── main.go 

Ouvrez le fichier main.go dans l'éditeur et main.go code suivant, qui vous permet d'utiliser les capacités du package de greet :

 package main import "github.com/gopherguides/greet" func main() {    greet.Hello() } 

Nous avons importé le package de main.go dans le fichier main.go , ce qui signifie que pour appeler la fonction déclarée dans ce package, nous devons utiliser la notation par points. Une notation par points est une construction dans laquelle un point est placé entre le nom du package et le nom de la ressource de ce package à utiliser. Par exemple, dans le package d' greet , la fonction Hello joue le rôle d'une ressource. Si vous devez appeler cette fonction, la notation par points est utilisée : greet.Hello() .

Vous pouvez maintenant ouvrir le terminal et exécuter le programme:

 go run main.go 

Après cela, le terminal affichera les éléments suivants:

 Hello, World! 

Voyons maintenant comment utiliser les variables déclarées dans les packages. Pour ce faire, ajoutez la déclaration de variable au greet.go :

 package greet import "fmt" var Shark = "Sammy" func Hello() {    fmt.Println("Hello, World!") } 

Ouvrez le fichier main.go et ajoutez-y une ligne où la fonction fmt.Println() est utilisée pour afficher la valeur de la variable Shark déclarée dans le greet.go . À savoir, main.go sous la forme suivante:

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark) } 

Exécutez à nouveau le programme:

 go run main.go 

Maintenant, elle affichera les éléments suivants:

 Hello, World! Sammy 

Voyons maintenant comment déclarer des types dans des packages. Créez un type Octopus avec les champs Name et Color et créez une méthode de type. Cette méthode, lorsqu'elle est appelée, renvoie le contenu spécialement traité des champs Octopus . greet.go au formulaire suivant:

 package greet import "fmt" var Shark = "Sammy" type Octopus struct {    Name string    Color string } func (o Octopus) String() string {    return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func Hello() {    fmt.Println("Hello, World!") } 

Maintenant, ouvrez main.go , créez une instance de la structure du nouveau type et référez-vous à sa méthode String() :

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark)    oct := greet.Octopus{        Name: "Jesse",        Color: "orange",    }    fmt.Println(oct.String()) } 

Après avoir créé une instance d' Octopus aide d'une construction qui ressemble à oct := greet.Octopus , vous pouvez accéder aux méthodes et propriétés du type à partir de l' main.go fichier main.go Cela, en particulier, vous permet d'utiliser la commande oct.String() située à la fin du fichier main.go sans recourir à greet . De plus, on peut, par exemple, se référer au champ de la structure Color utilisant la construction oct.Color . En même temps, comme lorsque nous avons appelé la méthode, nous n'accédons pas au message d' greet .

La méthode String du type Octopus utilise la fonction fmt.Sprintf pour former la phrase et renvoie, en utilisant return , le résultat, la chaîne, à l'appel de méthode (dans ce cas, cet endroit se trouve dans main.go ).

Exécutez à nouveau le programme:

 go run main.go 

Il affichera les éléments suivants sur la console:

 Hello, World! Sammy The octopus's name is "Jesse" and is the color orange. 

Maintenant que nous avons équipé Octopus de la méthode String , nous avons un mécanisme de sortie d'informations de type adapté à la réutilisation. Si à l'avenir vous devez changer le comportement de cette méthode, qui peut être utilisée dans de nombreux projets, il suffira d'éditer une fois son code greet.go .

Exportation d'entité

Vous avez peut-être remarqué que tout ce que nous avons travaillé lors de l'accès au package d' greet a des noms qui commencent par une majuscule. Go n'a pas de modificateurs d'accès comme public , private ou protected , qui sont dans d'autres langues. La visibilité des entités pour les mécanismes externes est contrôlée par le fait par quelle lettre, avec une petite ou une grande, commence leur nom. Par conséquent, les types, variables, fonctions dont les noms commencent par une majuscule sont disponibles en dehors du package actuel. Le code visible en dehors du package est appelé exporté.

Si vous équipez le type Octopus d'une nouvelle méthode appelée reset , cette méthode peut être appelée à partir du package de main.go , mais pas à partir du fichier main.go , qui est en dehors du package de main.go . Voici une version mise à jour greet.go :

 package greet import "fmt" var Shark = "Sammy" type Octopus struct {    Name string    Color string } func (o Octopus) String() string {    return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func (o Octopus) reset() {    o.Name = ""    o.Color = "" } func Hello() {    fmt.Println("Hello, World!") } 

Essayons d'appeler reset depuis le fichier main.go :

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark)    oct := greet.Octopus{        Name: "Jesse",        Color: "orange",    }    fmt.Println(oct.String())    oct.reset() } 

Cela entraînera l'erreur de compilation suivante:

 oct.reset undefined (cannot refer to unexported field or method greet.Octopus.reset) 

Pour exporter la méthode de reset Octopus , vous devez la renommer en remplaçant la première lettre, minuscule r , par une majuscule R Pour ce faire, nous greet.go :

 package greet import "fmt" var Shark = "Sammy" type Octopus struct {    Name string    Color string } func (o Octopus) String() string {    return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func (o Octopus) Reset() {    o.Name = ""    o.Color = "" } func Hello() {    fmt.Println("Hello, World!") } 

Cela conduira au fait que nous pourrons appeler Reset partir d'autres packages et sans rencontrer de messages d'erreur:

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark)    oct := greet.Octopus{        Name: "Jesse",        Color: "orange",    }    fmt.Println(oct.String())    oct.Reset()    fmt.Println(oct.String()) } 

Exécutez le programme:

 go run main.go 

Voici ce qui arrive à la console:

 Hello, World! Sammy The octopus's name is "Jesse" and is the color orange The octopus's name is "" and is the color . 

En appelant la méthode Reset , nous avons effacé les champs Name et Color de notre instance Octopus . Par conséquent, lorsque vous appelez String , où le contenu des champs Name et Color était précédemment affiché, rien ne s'affiche désormais.

Résumé

L'écriture de packages Go n'est pas différente de l'écriture de code Go standard. Cependant, placer le code du package dans leurs propres répertoires permet d'isoler le code, qui peut être utilisé dans n'importe quel autre projet Go. Ici, nous avons parlé de la façon de déclarer des fonctions, des variables et des types dans des packages, examiné comment utiliser ces entités en dehors des packages et trouvé où stocker les packages conçus pour leur utilisation répétée.

Chers lecteurs! Quels programmes écrivez-vous habituellement sur Go? Utilisez-vous des packages propriétaires?