Go
Pakketjes

Pakketinitialisatie

Pakket kan init methoden hebben die slechts één keer voor main worden uitgevoerd.

package usefull

func init() {
    // init code
}

Als u alleen de initialisatie van het pakket wilt uitvoeren zonder ernaar te verwijzen, gebruikt u de volgende importexpressie.

import _ "usefull"

Pakketafhankelijkheden beheren

Een veelgebruikte manier om Go-afhankelijkheden te downloaden is met de opdracht go get <package> , waarmee het pakket wordt opgeslagen in de algemene / gedeelde map $GOPATH/src . Dit betekent dat een enkele versie van elk pakket wordt gekoppeld aan elk project dat het als afhankelijkheid bevat. Dit betekent ook dat wanneer er een nieuwe ontwikkelaars uw project zet, zullen ze go get de laatste versie van elk afhankelijkheid.

U kunt de bouwomgeving echter consistent houden door alle afhankelijkheden van een project aan de vendor/ map te koppelen. Door afhankelijkheid van verkopers samen te houden met de repository van uw project, kunt u versiebeheer per project uitvoeren en een consistente omgeving voor uw build bieden.

Zo ziet de structuur van uw project eruit:

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

Gebruik een ander pakket en mapnaam

Het is prima om een andere pakketnaam dan de mapnaam te gebruiken. Als we dit doen, moeten we het pakket nog steeds importeren op basis van de mapstructuur, maar na het importeren moeten we ernaar verwijzen met de naam die we in de pakketclausule hebben gebruikt.

Als u bijvoorbeeld een map $GOPATH/src/mypck , en daarin een bestand a.go :

package apple

const Pi = 3.14

Gebruik dit pakket:

package main

import (
    "mypck"
    "fmt"
)

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

Hoewel dit werkt, zou u een goede reden moeten hebben om de pakketnaam af te wijken van de mapnaam (of het kan een bron van misverstanden en verwarring worden).

Wat is het nut hiervan?

Gemakkelijk. Een pakketnaam is een Go- idetifier :

identifier = letter { letter | unicode_digit } .

Hiermee kunnen unicode-letters worden gebruikt in ID's, bijvoorbeeld αβ is een geldige ID in Go. Map- en bestandsnamen worden niet afgehandeld door Go maar door het besturingssysteem, en verschillende bestandssystemen hebben verschillende beperkingen. Er zijn eigenlijk veel bestandssystemen die niet alle geldige Go-id's toestaan als mapnamen, dus je zou je pakketten niet kunnen noemen wat anders de taalspecificatie zou toestaan.

Met de optie om verschillende pakketnamen te gebruiken dan hun mappen, hebt u de optie om uw pakketten echt een naam te geven wat de taalspecificatie toestaat, ongeacht het onderliggende besturingssysteem en bestandssysteem.

Pakketten importeren

U kunt een enkel pakket importeren met de instructie:

import "path/to/package"

of groepeer meerdere importen samen:

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

Dit zal in de overeenkomstige import in de $GOPATH voor .go bestanden kijken en geeft u toegang tot geëxporteerde namen via packagename.AnyExportedName .

U kunt ook toegang krijgen tot lokale pakketten in de huidige map door pakketten vooraf te plaatsen met ./ . In een project met een structuur als deze:

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

Je zou dit in main.go kunnen noemen om de code in file1.go en file2.go :

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

Omdat pakketnamen in verschillende bibliotheken kunnen botsen, wilt u misschien een pakket een alias toewijzen aan een nieuwe naam. Dit kunt u doen door uw import-statement te laten voorafgaan door de naam die u wilt gebruiken.

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

Hiermee hebt u toegang tot het voormalige fmt pakket met fmt.* En het laatste fmt pakket met tfmt.* .

U kunt het pakket ook in de eigen naamruimte importeren, zodat u naar de geëxporteerde namen zonder het package. kunt verwijzen package. voorvoegsel met een enkele punt als alias:

import (
    . "fmt"
)

Bovenstaand voorbeeld importeert fmt in de globale naamruimte en laat u bijvoorbeeld rechtstreeks Printf aanroepen: Playground

Als u een pakket importeert maar geen van de geëxporteerde namen gebruikt, drukt de Go-compiler een foutmelding af. Om dit te omzeilen, kunt u de alias instellen op het onderstrepingsteken:

import (
    _ "fmt"
)

Dit kan handig zijn als u dit pakket niet rechtstreeks opent, maar de init functies nodig hebt om het uit te voeren.

Notitie:

Omdat de pakketnamen op de mapstructuur zijn gebaseerd, zullen wijzigingen in de mapnamen en importreferenties (inclusief hoofdlettergevoeligheid) een compilatietijd veroorzaken "hoofdletterongevoelige importbotsing" in Linux & OS-X, die moeilijk te traceren is en verhelpen (de foutmelding is nogal cryptisch voor alleen stervelingen omdat het probeert het tegenovergestelde over te brengen - dat de vergelijking mislukte vanwege hoofdlettergevoeligheid).

bijv: "pad / naar / pakket1" versus "pad / naar / pakket1"

Live voorbeeld: https://github.com/akamai-open/AkamaiOPEN-edgegrid-golang/issues/2