Golang importerer lokal pakke

I Go refererer en pakke til en samling GO -kildekodefiler i samme katalog som er samlet sammen. Vanligvis vil du bruke disse pakkene til å eksportere og importere kode mellom dem. Dette gjør igjen koden modulær og enkel å vedlikeholde.

Imidlertid, hvis du bare kommer inn på Go -programmeringsspråket, kan det være ganske vanskelig å finne ut hvordan du importerer lokal pakke. Det er det denne opplæringen handler om.

Golang -pakke

For bedre å forstå hva som er en GO -pakke, la oss ta et prosjekt som heter arbeidsområdet mitt. Inne i arbeidsområdet -katalogen har du 3 flere kataloger kalt Dir1, Dir2 og Dir3.

Derfor er katalogtreet som vist:

└─── Workspace
├───Dir1
├───Dir2
└───Dir3

Dette betyr at arbeidsområdet prosjekt har 3 pakker. Hver fil opprettet under hver katalog blir en del av den pakken (katalog).

Husk at hovedprosjektet er det som er kjent som hovedpakken. I de fleste tilfeller finner du filer som Main.gå med den første kodelinjen som ”

pakkehoved

Når du går tilbake til arbeidsområdet -prosjektet, vil du den første oppføringen i hver av filene med navnet på pakken de hører hjemme.

Et eksempel er som:

Pakke Dir1 // for filer i Dir1
Pakke Dir2 // for filer i Dir2
pakke dir3 // for dir3

Hver fil i en pakke kan eksportere koden. Andre filer i prosjektet kan deretter referere til den pakken (katalog) og importere koden fra filene. Dette lar deg bare importere en enkelt pakke, og all koden i filene under den pakken vil være tilgjengelig for bruk.

For å lage en ny pakke i prosjektet ditt, kan du bare opprette en ny katalog.

La oss se på et praktisk eksempel for å lage GO -pakker.

Golang initialiserer modulen

Det første trinnet når importpakker er å initialisere en ny modul. Du kan gjøre det ved å kjøre kommandoen:

gå mod init

For eksempel i arbeidsområdet -katalogen kan vi opprette en ny modul som:

gå mod init arbeidsområdet

Når du har kjørt Go Mod Init, skaper det en gang.Mod -fil som holder oversikt over moduler du importerer. Filen inneholder også informasjon som modulnavnet, GO -versjon osv.

Tenk på det som pakken.JSON -fil i node.

Husk navngivningen av modulene dine, da du vil kreve det når du importerer pakkene dine. Et eksempel på Go.Mod -fil er som vist:

Modul Workspace
gå 1.17

Siden vi ikke har noen eksterne pakker, inneholder filen modulenavnet og GO -versjonen.

Golang Create Package

Som nevnt, for å lage en pakke i GO -prosjektet ditt, oppretter du en ny katalog og legger til kildekodefilene under den pakken.

La oss for eksempel lage GO -kildefiler for DIR1, DIR2 og DIR3 -pakker.

$ Touch Dir1/Dir1.gå
$ Touch Dir2/Dir12.gå
$ Touch Dir3/Dir3.gå

I den første linjen i hver fil, inkluderer du pakken navneområdet som:

Pakke Dir1 // erstatt Dir2 med navnet på pakken

La oss deretter legge til litt kode i hver av disse filene.

// dir1.gå
Pakke Dir1
funcsayhello () streng
Returner "Hei fra Package Dir1"

// Dir2.gå
Pakke Dir2
funcsayrunning () streng
Returner "Jeg kjører fra Package Dir2"

// dir3.gå
Pakke DIR3
funcsaybye () streng
Returner "Farvel fra Package Dir3"

Ovennevnte eksempler er enkle. De er bare funksjoner som returnerer en strengverdi fra hver pakke.

Merk: For å eksportere en variabel eller en funksjon fra en GO -pakke, må du forsikre deg om at du starter navnet på funksjonen eller variabelen med en store bokstaver.

Igjen: ☝ ☝

Golang importerer lokale pakker

Det siste trinnet er å importere dine lokale pakker, slik at du kan bruke koden i hver og en av dem. I roten til prosjektet ditt, også.gå fil.

Deretter legger du til følgende linjer for å importere dine lokale pakker:

pakkehoved
import (
"FMT"
"Workspace/Dir1"
"Workspace/Dir2"
"Workspace/Dir3"
)
FUNCMAIN ()
fmt.Println (Dir1.Si hei())
fmt.Println (Dir2.SayRunning ())
fmt.Println (Dir3.Saybye ())

I eksemplet over legger vi til 3 importklausuler for å importere alle pakkene i programmet vårt.

Når vi er importert, kan vi bruke den eksporterte koden i pakkene.

Vi kan deretter kjøre koden i Main.gå fil som:

$ go run main.gå
Hei fra pakken Dir1
Jeg kjører fra pakkedir2
Farvel fra Package Dir3

Du vil se utdataene som eksportert av funksjonene fra pakkene.

Konklusjon

I denne artikkelen diskuterte vi hvordan du kan eksportere og importere kode ved hjelp av GO -pakker. Pakker er en veldig praktisk og ren måte å organisere koden din og beholde lesbarhet og vedlikehold. Vi håper du likte!