Go
Pacchi

Initalizzazione del pacchetto

Il pacchetto può avere metodi init che vengono eseguiti solo una volta prima di main.

package usefull

func init() {
    // init code
}

Se si desidera eseguire l'inizializzazione del pacchetto senza fare riferimento a nulla, utilizzare la seguente espressione di importazione.

import _ "usefull"

Gestire le dipendenze del pacchetto

Un metodo comune per scaricare le dipendenze di Go è utilizzando il comando go get <package> , che salverà il pacchetto nella directory globale / condivisa $GOPATH/src . Ciò significa che una singola versione di ciascun pacchetto sarà collegata a ciascun progetto che la include come dipendenza. Ciò significa anche che quando un nuovo sviluppatore distribuisce il tuo progetto, go get l'ultima versione di ciascuna dipendenza.

Tuttavia è possibile mantenere coerente l'ambiente di costruzione, collegando tutte le dipendenze di un progetto nella directory del vendor/ . Mantenere le dipendenze vendute e il repository del progetto consente di eseguire il controllo delle versioni per progetto e fornire un ambiente coerente per la build.

Ecco come sarà la struttura del tuo progetto:

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

Usando un diverso nome di pacchetto e cartella

Va perfettamente bene usare un nome di pacchetto diverso dal nome della cartella. Se lo facciamo, dobbiamo ancora importare il pacchetto in base alla struttura della directory, ma dopo l'importazione dobbiamo farvi riferimento con il nome che abbiamo usato nella clausola del pacchetto.

Ad esempio, se hai una cartella $GOPATH/src/mypck , e in essa abbiamo un file a.go :

package apple

const Pi = 3.14

Utilizzando questo pacchetto:

package main

import (
    "mypck"
    "fmt"
)

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

Anche se questo funziona, dovresti avere una buona ragione per deviare il nome del pacchetto dal nome della cartella (o potrebbe diventare fonte di incomprensioni e confusione).

A cosa serve questo?

Semplice. Un nome pacchetto è un identificatore di Go:

identifier = letter { letter | unicode_digit } .

Che consente di utilizzare lettere unicode negli identificatori, ad esempio αβ è un identificatore valido in Go. I nomi delle cartelle e dei file non sono gestiti da Go ma dal sistema operativo e diversi sistemi di file hanno restrizioni diverse. Esistono in realtà molti file system che non consentirebbero tutti gli identificatori di Go validi come nomi di cartelle, quindi non si sarebbe in grado di assegnare un nome ai pacchetti che altrimenti le specifiche della lingua consentirebbero.

Avendo la possibilità di utilizzare diversi nomi di pacchetti rispetto alle loro cartelle di contenimento, hai la possibilità di nominare realmente i tuoi pacchetti che cosa consente la specifica della lingua, indipendentemente dal sistema operativo e file sottostante.

Importazione di pacchetti

Puoi importare un singolo pacchetto con l'istruzione:

import "path/to/package"

o raggruppare più importazioni insieme:

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

Verrà visualizzato nei percorsi di import corrispondenti all'interno di $GOPATH per i file .go e consente di accedere ai nomi esportati tramite packagename.AnyExportedName .

Puoi anche accedere ai pacchetti locali all'interno della cartella corrente facendo precedere i pacchetti con ./ . In un progetto con una struttura come questa:

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

Puoi chiamarlo in main.go per importare il codice in file1.go e file2.go :

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

Dato che i nomi dei pacchetti possono collidere in diverse librerie, è possibile che si desideri creare un alias di un pacchetto con un nuovo nome. Puoi farlo anteponendo la tua dichiarazione di importazione con il nome che desideri utilizzare.

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

Questo ti permette di accedere al precedente pacchetto fmt usando fmt.* E il secondo pacchetto fmt usando tfmt.* .

È inoltre possibile importare il pacchetto nel proprio spazio dei nomi, in modo da poter fare riferimento ai nomi esportati senza il package. prefisso utilizzando un singolo punto come alias:

import (
    . "fmt"
)

L'esempio precedente importa fmt nello spazio dei nomi globale e consente di chiamare, ad esempio, direttamente Printf : Playground

Se importi un pacchetto ma non usi nessuno dei suoi nomi esportati, il compilatore Go stamperà un messaggio di errore. Per aggirare questo problema, puoi impostare l'alias sul carattere di sottolineatura:

import (
    _ "fmt"
)

Questo può essere utile se non si accede direttamente a questo pacchetto, ma è necessario eseguire le sue funzioni init .

Nota:

Poiché i nomi dei pacchetti si basano sulla struttura delle cartelle, qualsiasi modifica nei nomi delle cartelle e dei riferimenti di importazione (inclusa la distinzione tra maiuscole e minuscole) causerà un errore di compilazione "collisione di importazione senza distinzione tra maiuscole e minuscole" in Linux e OS-X, che è difficile da tracciare e aggiusta (il messaggio di errore è piuttosto criptico per i comuni mortali poiché cerca di esprimere il contrario - che, il confronto non è riuscito a causa della distinzione tra maiuscole e minuscole).

ex: "percorso / su / Pacchetto1" vs "percorso / su / pacchetto1"

Esempio dal vivo: https://github.com/akamai-open/AkamaiOPEN-edgegrid-golang/issues/2