Att förstå GOPATH

Introduktion

Denna artikel hjälper dig att förstå vad GOPATH är, hur det fungerar och hur du ställer in det. Detta är ett viktigt steg för att sätta upp en Go-utvecklingsmiljö, samt för att förstå hur Go hittar, installerar och bygger källfiler. I den här artikeln kommer vi att använda GOPATH när vi hänvisar till begreppet mappstruktur som vi kommer att diskutera. Vi kommer att använda $GOPATH för att referera till den miljövariabel som Go använder för att hitta mappstrukturen.

En Go Workspace är hur Go hanterar våra källfiler, kompilerade binärer och cachade objekt som används för snabbare kompilering senare. Det är typiskt, och rekommenderas också, att bara ha ett Go Workspace, även om det är möjligt att ha flera utrymmen. GOPATH fungerar som rotmapp för ett arbetsutrymme.

Inställning av miljövariabeln $GOPATH

Miljövariabeln $GOPATH listar platser där Go ska leta efter Go Workspaces.

Som standard antar Go att vår GOPATH-plats ligger på $HOME/go, där $HOME är rotkatalogen för vårt användarkonto på vår dator. Vi kan ändra detta genom att ställa in miljövariabeln $GOPATH. För ytterligare studier, följ den här handledningen om att läsa och ställa in miljövariabler i Linux.

För mer information om hur du ställer in variabeln $GOPATH, se Go-dokumentationen.

Den här serien går dessutom igenom att installera Go och ställa in en Go-utvecklingsmiljö.

$GOPATH är inte $GOROOT

Det är i $GOROOT som Go:s kod, kompilator och verktyg bor – detta är inte vår källkod. $GOROOT är vanligtvis något i stil med /usr/local/go. Vår $GOPATH är vanligtvis något i stil med $HOME/go.

Vi behöver inte specifikt ställa in $GOROOT-variabeln längre, men den refereras fortfarande i äldre material.

Nu ska vi diskutera strukturen i Go Workspace.

Anatomi av Go Workspace

Inuti en Go Workspace, eller GOPATH, finns det tre kataloger: bin, pkg och src. Var och en av dessa kataloger har en speciell betydelse för Go-verktygskedjan.

.├── bin├── pkg└── src └── github.com/foo/bar └── bar.go

Låt oss ta en titt på var och en av dessa kataloger.

Katalogen $GOPATH/bin är den katalog där Go placerar binärfiler som go install kompilerar. Vårt operativsystem använder miljövariabeln $PATH för att hitta binära program som kan köras utan en fullständig sökväg. Det rekommenderas att lägga till den här katalogen till vår globala $PATH-variabel.

Om vi till exempel inte lägger till $GOPATH/bin till $PATH för att exekvera ett program därifrån måste vi köra:

$GOPATH/bin/myapp

När $GOPATH/bin läggs till $PATH kan vi göra samma anrop på följande sätt:

myapp

Den $GOPATH/pkg-katalogen är den plats där Go lagrar förkompilerade objektfiler för att påskynda senare kompilering av program. Typiskt sett kommer de flesta utvecklare inte att behöva komma åt den här katalogen. Om du får problem med kompileringen kan du säkert radera den här katalogen och Go kommer sedan att bygga upp den igen.

Den src-katalogen är den katalog där alla våra .go-filer, eller källkoden, måste finnas. Detta ska inte förväxlas med källkoden som Go-verktyget använder, som finns i $GOROOT. När vi skriver Go-program, paket och bibliotek kommer vi att placera dessa filer under $GOPATH/src/path/to/code.

Vad är paket?

Go-kod är organiserad i paket. Ett paket representerar alla filer i en enda katalog på disken. En katalog kan endast innehålla vissa filer från samma paket. Paket lagras, tillsammans med alla användarskrivna Go-källfiler, under katalogen $GOPATH/src. Vi kan förstå paketupplösning genom att importera olika paket.

Om vår kod finns på $GOPATH/src/blue/red bör dess paketnamn vara red.

Importeringsangivelsen för red-paketet skulle vara:

import "blue/red"

Paket som finns i källkodsförvaringsställen, som GitHub och BitBucket, har hela förvaringsställets fullständiga plats som en del av sin importväg.

Till exempel skulle vi importera källkoden på https://github.com/gobuffalo/buffalo med hjälp av följande importväg:

import "github.com/gobuffalo/buffalo"

Därmed skulle den här källkoden finnas på följande plats på disken:

$GOPATH/src/github.com/gobuffalo/buffalo

Slutsats

I den här artikeln diskuterade vi GOPATH som en uppsättning mappar som Go förväntar sig att vår källkod ska finnas inom, samt vad dessa mappar är och vad de innehåller. Vi diskuterade hur man ändrar den platsen från standardvärdet $HOME/go till användarens val genom att ställa in miljövariabeln $GOPATH. Slutligen diskuterade vi hur Go söker efter paket inom denna mappstruktur.

Go Modules introducerades i Go 1.11 och syftar till att ersätta Go Workspaces och GOPATH. Det rekommenderas att börja använda moduler, men vissa miljöer, t.ex. företagsmiljöer, är kanske inte redo att använda moduler.

Den GOPATH är en av de knepigare aspekterna av att ställa in Go, men när den väl är inställd kan vi oftast glömma den.