Comment écrire des paquets dans Go

Un paquet est composé de fichiers Go qui résident dans le même répertoire et qui ont la même instruction de paquet au début. Vous pouvez inclure des fonctionnalités supplémentaires à partir de packages pour rendre vos programmes plus sophistiqués. Certains packages sont disponibles via la bibliothèque Go Standard et sont donc installés avec votre installation Go. D’autres peuvent être installés avec la commande + go get + de Go. Vous pouvez également créer vos propres packages Go en créant des fichiers Go dans le même répertoire que celui dans lequel vous souhaitez partager du code, à l’aide de l’instruction de package nécessaire.

Ce tutoriel vous guidera dans la rédaction de packages Go à utiliser dans d’autres fichiers de programmation.

Conditions préalables

Configurez un environnement de programmation Go en suivant l’un des didacticiels de la page https://www.digitalocean.com/community/tutorial_series/how-to-install-and-set-up-a-local-programming-environment-for-go [Comment installer et configurer un environnement de programmation local pour Go]. Créez votre espace de travail Go après l’étape 5 des didacticiels relatifs à l’environnement de programmation local. Pour suivre l’exemple et les conventions de dénomination dans cet article, lisez la première section Écrire et importer des packages.
Pour approfondir vos connaissances sur GOPATH, lisez notre article Comprendre GOPATH.

Écrire et importer des paquets

Écrire un paquet, c’est comme écrire n’importe quel autre fichier Go. Les packages peuvent contenir des définitions de fonctions, types et https://www.digitalocean.com/community/tutorials/how. -to-use-variables-and-constantes-in-go # compréhension-variables [variables] pouvant ensuite être utilisées dans d’autres programmes Go.

Avant de créer un nouveau package, nous devons figurer dans notre espace de travail Go. Ceci est typiquement sous notre + gopath +. Pour l’exemple, dans ce tutoriel, nous appellerons le paquet + greet +. Pour ce faire, nous avons créé un répertoire nommé + greet + dans notre + gopath + sous notre espace projet. Si notre organisation était + gopherguides +, et que nous voulions créer le paquet + greet + sous l’organisation tout en utilisant Github comme référentiel de code, notre répertoire ressemblerait à ceci:

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

Le répertoire + greet + se trouve dans le répertoire + gopherguides +:

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

Enfin, nous pouvons ajouter le premier fichier de notre répertoire. Il est considéré comme une pratique courante que le fichier + primary ou` + entry point` dans un paquet porte le nom du répertoire. Dans ce cas, nous créerions un fichier nommé + greet.go + dans le répertoire + greet +:

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

Avec le fichier créé, nous pouvons commencer à écrire notre code que nous voulons réutiliser ou partager entre projets. Dans ce cas, nous allons créer une fonction appelée + Hello + qui affiche + Hello World.

Ouvrez votre fichier + greet.go + dans votre éditeur de texte et ajoutez le code suivant:

salut.go

package greet

import "fmt"

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

Brisons ce premier fichier. La première ligne de chaque fichier nécessite le nom du + package + dans lequel vous travaillez. Comme vous êtes dans le paquet + greet +, vous utilisez le mot clé + package + suivi du nom du paquet:

package greet

Cela indiquera au compilateur de traiter tout le contenu du fichier comme faisant partie du paquet + greet +.

Ensuite, vous déclarez tout autre paquet que vous devez utiliser avec l’instruction + import +. Vous n’en utilisez qu’un dans ce fichier, le package + fmt +:

import "fmt"

Enfin, vous créez la fonction + Hello +. Il utilisera le paquetage + fmt + pour imprimer + Hello, World! +:

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

Maintenant que vous avez écrit le paquet + greet +, vous pouvez l’utiliser dans n’importe quel autre paquet que vous créez. Créons un nouveau package dans lequel vous utiliserez votre package `+ greet + '.

Vous allez créer un paquet nommé + exemple +, ce qui signifie que vous avez besoin d’un répertoire nommé + exemple +. Créez ce paquet dans votre organisation + gopherguides +, afin que la structure de répertoires ressemble à ceci:

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

Maintenant que vous avez votre répertoire pour votre nouveau package, vous pouvez créer le fichier de point d’entrée. Comme il s’agit d’un programme exécutable, il est recommandé de nommer le fichier de points d’entrée + main.go +:

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

Dans votre éditeur de texte, ouvrez + main.go + et ajoutez le code suivant pour appeler le paquet + greet +:

main.go

package main

import "github.com/gopherguides/greet"

func main() {
   greet.Hello()
}

Comme vous importez un package, vous devez appeler la fonction en référençant le nom du package en notation par points. Dot notation est la pratique qui consiste à mettre un point +. + Entre le nom du paquet que vous utilisez et la ressource de ce paquet que vous voulez utiliser. Par exemple, dans votre paquet + greet +, vous avez la fonction + Hello + en tant que ressource. Si vous souhaitez appeler cette ressource, vous utilisez la notation par points de + greet.Hello () +.

Maintenant, vous pouvez ouvrir votre terminal et exécuter le programme sur la ligne de commande:

go run main.go

Lorsque vous le faites, vous recevrez le résultat suivant:

OutputHello, World!

Pour voir comment utiliser les variables dans un package, ajoutons une définition de variable dans votre fichier + greet.go +:

salut.go

package greet

import "fmt"



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

Ensuite, ouvrez votre fichier + main.go + et ajoutez la ligne en surbrillance suivante pour appeler la variable de + greet.go + dans une fonction + fmt.Println () +:

main.go

package main

import (
   "fmt"

   "github.com/gopherguides/greet"
)

func main() {
   greet.Hello()


}

Une fois que vous exécutez à nouveau le programme:

go run main.go

Vous recevrez le résultat suivant:

OutputHello, World!
Sammy

Enfin, définissons également un type dans le fichier + greet.go +. Vous créerez le type + Octopus + avec les champs + name + et + color +, et une fonction qui imprimera les champs à l’appel:

salut.go

package greet

import "fmt"

var Shark = "Sammy"










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

Ouvrez + main.go + pour créer une instance de ce type à la fin du fichier:

main.go

package main

import (
   "fmt"

   "github.com/gopherguides/greet"
)

func main() {
   greet.Hello()

   fmt.Println(greet.Shark)







}

Une fois que vous avez créé une instance de type + Octopus + avec + oct: = greet.Octopus +, vous pouvez accéder aux fonctions et aux champs de ce type dans l’espace de noms du fichier + main.go +. Cela vous permet d’écrire + oct.String () + sur la dernière ligne sans appeler + greet +. Vous pouvez également, par exemple, appeler l’un des champs de types tels que + oct.Color + sans faire référence au nom du paquetage + greet +.

La méthode + String + sur le type + Octopus + utilise la fonction + fmt.Sprintf + pour créer une phrase et + renvoie + le résultat, une chaîne, à l’appelant (dans ce cas, votre programme principal) .

Lorsque vous exécutez le programme, vous recevrez le résultat suivant:

go run main.go

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

En créant la méthode + String sur` + Octopus`, vous disposez désormais d’un moyen réutilisable pour imprimer des informations sur votre type personnalisé. Si vous souhaitez modifier le comportement de cette méthode à l’avenir, il vous suffit de modifier cette méthode.

Code exporté

Vous avez peut-être remarqué que toutes les déclarations du fichier + greet.go + que vous avez appelé étaient en majuscule. Go n’a pas le concept de modificateurs + public,` + private et + protected comme le font les autres langages. La visibilité externe est contrôlée par la capitalisation. Les types, variables, fonctions, etc., commençant par une lettre majuscule sont disponibles publiquement en dehors du package actuel. Un symbole visible en dehors de son emballage est considéré comme étant + exporté +.

Si vous ajoutez une nouvelle méthode à + Octopus + appelée + reset +, vous pouvez l’appeler depuis le paquet + greet +, mais pas depuis votre fichier + main.go +, qui se trouve en dehors du + greet + paquet:

salut.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 Hello() {
   fmt.Println("Hello, World!")
}

Si vous essayez d’appeler + reset + à partir du fichier + main.go +:

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())


}

Vous recevrez l’erreur de compilation suivante:

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

Pour + exporter la fonctionnalité` + reset` de + Octopus To, mettez en majuscule le` + R + dans + reset + `:

salut.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) eset() {
   o.Name = ""
   o.Color = ""
}

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

En conséquence, vous pouvez appeler + Reset + depuis votre autre paquet sans erreur:

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())



   fmt.Println(oct.String())
}

Maintenant, si vous exécutez le programme:

go run main.go

Vous recevrez le résultat suivant:

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

En appelant + Reset +, vous avez effacé toutes les informations des champs + Nom + et + + Couleur +. Lorsque vous appelez la méthode + String, elle n’imprimera rien là où` + nom` et + couleur W apparaissent normalement car les champs sont maintenant vides.

Conclusion

Écrire un package Go revient à écrire n’importe quel autre fichier Go, mais le placer dans un autre répertoire vous permet d’isoler le code et de le réutiliser ailleurs. Ce didacticiel expliquait comment écrire des définitions dans un paquet, montrait comment utiliser ces définitions dans un autre fichier de programmation Go et expliquait les options permettant de conserver le paquet pour y accéder.

TOC

Comment écrire des paquets dans Go

Conditions préalables

Écrire et importer des paquets

Code exporté

Conclusion

Related