Go
paket

Paketinitiering

Paketet kan ha init som körs endast en gång före huvud.

package usefull

func init() {
    // init code
}

Om du bara vill köra paketinitieringen utan att hänvisa till något från det använder du följande importuttryck.

import _ "usefull"

Hantera paketberoende

Ett vanligt sätt att ladda ner Go-beroenden är genom att använda kommandot go get <package> , vilket sparar paketet i den globala / delade $GOPATH/src katalogen. Detta innebär att en enda version av varje paket kommer att kopplas till varje projekt som inkluderar det som ett beroende. Detta innebär också att när en ny utvecklare använder ditt projekt kommer de att go get den senaste versionen av varje beroende.

Du kan dock hålla byggmiljön konsekvent genom att fästa alla beroenden för ett projekt i vendor/ katalogen. Genom att hålla leverantörsberoenden som begås tillsammans med projektets lager kan du göra versionberoende per projekt och ge en enhetlig miljö för din byggnad.

Så här ser projektets struktur ut:

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

Använda olika paket- och mappnamn

Det är helt bra att använda ett annat paketnamn än mappnamnet. Om vi gör det måste vi fortfarande importera paketet baserat på katalogstrukturen, men efter importen måste vi hänvisa till det med det namn vi använde i paketklausulen.

Om du till exempel har en mapp $GOPATH/src/mypck , och i den har vi en fil a.go :

package apple

const Pi = 3.14

Använda detta paket:

package main

import (
    "mypck"
    "fmt"
)

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

Även om detta fungerar bör du ha en god anledning att avvika paketnamnet från mappnamnet (eller så kan det bli källa till missförstånd och förvirring).

Vad är det för detta?

Enkel. Ett paketnamn är en Go- identifierare :

identifier = letter { letter | unicode_digit } .

Vilket gör det möjligt att använda unicode-bokstäver i identifierare, t.ex. αβ är en giltig identifierare i Go. Mapp- och filnamn hanteras inte av Go utan av operativsystemet, och olika filsystem har olika begränsningar. Det finns faktiskt många filsystem som inte tillåter alla giltiga Go-identifierare som mappnamn, så du skulle inte kunna namnge dina paket vad som annars språkspecifikationen skulle tillåta.

Med alternativet att använda olika paketnamn än deras mappar, har du möjlighet att verkligen namnge dina paket vad språkspecifikationen tillåter, oavsett underliggande operativsystem och filsystem.

Importerar paket

Du kan importera ett enda paket med uttalandet:

import "path/to/package"

eller gruppera flera import tillsammans:

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

Detta kommer att se ut i motsvarande import inne i $GOPATH för .go filer och låter dig komma åt exporterade namn genom packagename.AnyExportedName .

Du kan också komma åt lokala paket inuti den aktuella mappen genom att förordna paket med ./ . I ett projekt med en struktur som denna:

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

Du kan ringa detta i main.go för att importera koden i file1.go och file2.go :

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

Eftersom paketnamn kan kollidera i olika bibliotek kanske du vill alias ett paket till ett nytt namn. Du kan göra detta genom att prefixa ditt import-uttalande med det namn du vill använda.

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

Detta tillåter dig åtkomst till det tidigare fmt paketet med fmt.* Och det senare fmt paketet med tfmt.* .

Du kan också importera paketet till det egna namnområdet, så att du kan hänvisa till de exporterade namnen utan package. prefix med en enda punkt som alias:

import (
    . "fmt"
)

Ovanför exempel importerar fmt till det globala namnområdet och låter dig ringa till exempel Printf direkt: Playground

Om du importerar ett paket men inte använder något av det exporterade namnet kommer Go-kompilatorn att skriva ut ett felmeddelande. För att kringgå detta kan du ställa in aliaset till understrecket:

import (
    _ "fmt"
)

Detta kan vara användbart om du inte kommer åt detta paket direkt men behöver att det är init funktioner för att köra.

Notera:

Eftersom paketnamnen är baserade på mappstrukturen, kommer eventuella ändringar i mappnamn och importreferenser (inklusive känslighetsfall) att orsaka ett sammanställningstidsfel "case-okänslig importkollision" i Linux & OS-X, vilket är svårt att spåra och fixa (felmeddelandet är ganska kryptiskt för bara dödliga eftersom det försöker förmedla det motsatta - att jämförelsen misslyckades på grund av känslig känsla).

ex: "sökväg / till / paket1" vs "sökväg / till / paket1"

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