Go
Paquets

Initalisation des colis

Package peut avoir des méthodes d' init qui ne sont exécutées qu'une seule fois avant main.

package usefull

func init() {
    // init code
}

Si vous souhaitez simplement exécuter l'initialisation du package sans faire référence à quoi que ce soit, utilisez l'expression d'importation suivante.

import _ "usefull"

Gestion des dépendances de package

Un moyen courant de télécharger des dépendances Go consiste à utiliser la commande go get <package> , qui enregistre le paquet dans le répertoire global / shared $GOPATH/src . Cela signifie qu'une seule version de chaque package sera liée à chaque projet qui l'inclut en tant que dépendance. Cela signifie également que lorsqu'un nouveau développeur déploie votre projet, il va go get la dernière version de chaque dépendance.

Cependant, vous pouvez garder l'environnement de construction cohérent en attachant toutes les dépendances d'un projet dans le répertoire vendor/ . Conserver les dépendances vendues avec le référentiel de votre projet vous permet de gérer les versions de dépendance par projet et de fournir un environnement cohérent pour votre génération.

Voici à quoi ressemblera la structure de votre projet:

$GOPATH/src/
├── github.com/username/project/
|   ├── main.go 
|   ├── vendor/
|   |   ├── github.com/pkg/errors
|   |   ├── github.com/gorilla/mux

Utiliser un nom de paquet et de dossier différent

Il est parfaitement correct d'utiliser un nom de package autre que le nom du dossier. Si nous le faisons, nous devons toujours importer le package en fonction de la structure du répertoire, mais après l'importation, nous devons nous référer au nom utilisé dans la clause du package.

Par exemple, si vous avez un dossier $GOPATH/src/mypck , et que nous y avons un fichier a.go :

package apple

const Pi = 3.14

Utiliser ce package:

package main

import (
    "mypck"
    "fmt"
)

func main() {
    fmt.Println(apple.Pi)
}

Même si cela fonctionne, vous devriez avoir une bonne raison de dévier le nom du package du nom du dossier (ou cela peut devenir une source de malentendu et de confusion).

A quoi ça sert?

Simple. Un nom de package est un identifiant Go:

identifier = letter { letter | unicode_digit } .

Ce qui permet d'utiliser des lettres Unicode dans les identifiants, par exemple αβ est un identifiant valide dans Go. Les noms de dossiers et de fichiers ne sont pas gérés par Go mais par le système d'exploitation, et différents systèmes de fichiers ont des restrictions différentes. Il existe en fait de nombreux systèmes de fichiers qui ne permettraient pas à tous les identificateurs Go valides de devenir des noms de dossiers. Vous ne pourriez donc pas nommer vos packages autrement que ce que la spécification de langage autoriserait.

Ayant la possibilité d'utiliser des noms de paquetages différents de leurs dossiers, vous avez la possibilité de nommer vraiment vos paquets en fonction des spécifications du langage, quel que soit le système d'exploitation et de fichiers sous-jacent.

Importation de paquets

Vous pouvez importer un seul package avec l'instruction:

import "path/to/package"

ou regrouper plusieurs importations ensemble:

import (
    "path/to/package1"
    "path/to/package2"
)

Cela va chercher dans les correspondants import chemins à l' intérieur du $GOPATH pour .go fichiers et vous permet d' accéder aux noms exportés par packagename.AnyExportedName .

Vous pouvez également accéder aux packages locaux à l’intérieur du dossier en cours en préfaçant les packages avec ./ . Dans un projet avec une structure comme celle-ci:

project
├── src
│   ├── package1
│   │   └── file1.go
│   └── package2
│       └── file2.go
└── main.go

Vous pouvez appeler cela dans main.go pour importer le code dans file1.go et file2.go :

import (
    "./src/package1"
    "./src/package2"
)

Étant donné que les noms de paquetages peuvent entrer en conflit dans différentes bibliothèques, vous souhaiterez peut-être attribuer un nom à un seul paquet. Vous pouvez le faire en préfixant votre instruction import avec le nom que vous souhaitez utiliser.

import (
    "fmt" //fmt from the standardlibrary
    tfmt "some/thirdparty/fmt" //fmt from some other library
)

Cela vous permet d'accéder à l'ancien paquetage fmt en utilisant fmt.* Et le dernier paquetage fmt en utilisant tfmt.* .

Vous pouvez également importer le package dans le propre espace de noms afin de pouvoir vous référer aux noms exportés sans le package. préfixe utilisant un seul point comme alias:

import (
    . "fmt"
)

L'exemple ci-dessus importe fmt dans l'espace de noms global et vous permet d'appeler, par exemple, Printf directement: Playground

Si vous importez un paquet mais n'utilisez aucun de ses noms exportés, le compilateur Go imprimera un message d'erreur. Pour contourner cela, vous pouvez définir l'alias sur le trait de soulignement:

import (
    _ "fmt"
)

Cela peut être utile si vous n'accédez pas directement à ce paquet mais que vous avez besoin de ses fonctions init pour les exécuter.

Remarque:

Comme les noms de package sont basés sur la structure des dossiers, toute modification des noms de dossier et des références d’importation (y compris la casse) provoquera une erreur de compilation "collision à l’importation insensible à la casse" sous Linux et OS-X. et corriger (le message d'erreur est un peu mystérieux pour les simples mortels car il essaie de transmettre le contraire - la comparaison a échoué en raison de la sensibilité à la casse).

ex: "path / to / Package1" vs "path / to / package1"

Exemple en direct: https://github.com/akamai-open/AkamaiOPEN-edgegrid-golang/issues/2