Meer informatie over pakketten

Voltooid

Pakketten in Go zijn als bibliotheken of modules in andere programmeertalen. U kunt uw code verpakken en ergens anders opnieuw gebruiken. De broncode van een pakket kan worden gedistribueerd in meer dan één .go bestand. Tot nu toe hebben we het main pakket geschreven en hebben we enkele verwijzingen naar andere systeemeigen pakketten gemaakt.

In deze sectie leert u wat een pakket is. U leert ook hoe u er een maakt en hoe u externe pakketten gebruikt.

Hoofdpakket

Zoals u misschien al hebt opgemerkt, moet zelfs het eenvoudigste programma in Go deel uitmaken van een pakket. Meestal is het standaardpakket het main pakket, het pakket dat we tot nu toe hebben gebruikt. Als een programma deel uitmaakt van het main pakket, genereert Go een binair bestand. Wanneer dat bestand wordt uitgevoerd, wordt de functie aangeroepen main() .

Met andere woorden, wanneer u het main pakket gebruikt, produceert uw programma een zelfstandig uitvoerbaar bestand. Maar wanneer een programma deel uitmaakt van een ander pakket dan main, genereert Go geen binair bestand. Er wordt een pakketarchiefbestand gegenereerd (een bestand met de .a extensie).

In Go volgen pakketnamen een conventie. Een pakket maakt gebruik van het laatste deel van het importpad als naam. De Go-standaardbibliotheek bevat bijvoorbeeld een pakket met de naam math/cmplx, dat nuttige code biedt voor het werken met complexe getallen. Het importpad van dit pakket is math/cmplxen u importeert het als volgt:

import "math/cmplx"

Als u naar objecten in het pakket wilt verwijzen, gebruikt u de pakketnaam, cmplxzoals deze:

cmplx.Inf()

Laten we een pakket maken.

Een pakket maken

Maak een nieuwe map in de map met de $GOPATH/src naam calculator. Maak een bestand met de naam sum.go. De structuurmap moet er als volgt uitzien:

src/
  calculator/
    sum.go

Initialiseer het sum.go bestand met de naam van het pakket:

package calculator

U kunt nu beginnen met het schrijven van de functies en variabelen voor het pakket. In tegenstelling tot andere programmeertalen biedt Go niet de public of private trefwoorden om aan te geven of een variabele of functie kan worden aangeroepen van buiten of binnen het pakket. Maar Go volgt twee eenvoudige regels:

• Als u iets privé wilt maken, start u de naam met een kleine letter.
• Als u iets openbaar wilt maken, start u de naam met een hoofdletter.

Laten we dus de volgende code toevoegen aan het rekenmachinepakket dat we maken:

package calculator

var logMessage = "[LOG]"

// Version of the calculator
var Version = "1.0"

func internalSum(number int) int {
    return number - 1
}

// Sum two integer numbers
func Sum(number1, number2 int) int {
    return number1 + number2
}

Laten we eens kijken naar enkele dingen in die code:

• De logMessage variabele kan alleen vanuit het pakket worden aangeroepen.
• De Version variabele kan vanaf elke locatie worden bereikt. U wordt aangeraden een opmerking op te nemen om het doel van deze variabele te beschrijven. (Deze beschrijving is handig voor iedereen die het pakket gebruikt.)
• De internalSum functie kan alleen vanuit het pakket worden aangeroepen.
• De Sum functie kan vanaf elke locatie worden bereikt. U wordt aangeraden een opmerking op te nemen om het doel van de functie te beschrijven.

Als u wilt controleren of alles werkt, kunt u de go build opdracht uitvoeren in de calculator map. Als u dat wel doet, ziet u dat er geen uitvoerbaar binair bestand wordt gegenereerd.

Een module maken

U hebt de rekenmachinefunctionaliteit in een pakket geplaatst. Nu is het tijd om dat pakket in een module te plaatsen. Go-modules bevatten doorgaans pakketten die gerelateerde functionaliteit bieden. De module van een pakket geeft ook de context op die Go nodig heeft om de code uit te voeren die u hebt gegroepeerd. Deze contextuele informatie bevat de Go-versie waarvoor uw code is geschreven.

Modules helpen andere ontwikkelaars ook specifieke versies van uw code te raadplegen en maken het werken met afhankelijkheden eenvoudiger. Een ander voordeel is dat de broncode van ons programma niet strikt hoeft te bestaan in de $GOPATH/src map. Door deze beperking vrij te maken, is het handiger om tegelijkertijd met verschillende pakketversies in andere projecten te werken.

Als u dus een module voor het calculator pakket wilt maken, voert u deze opdracht uit in de hoofdmap ($GOPATH/src/calculator):

go mod init github.com/myuser/calculator

Nadat u deze opdracht hebt uitgevoerd, github.com/myuser/calculator wordt de naam van de module. U gebruikt die naam om ernaar te verwijzen in andere programma's. Met de opdracht wordt ook een nieuw bestand gemaakt met de naam go.mod. Ten slotte ziet de structuurmap er nu als volgt uit:

src/
  calculator/
    go.mod
    sum.go

De inhoud van het go.mod bestand moet eruitzien als de volgende code. (De Go-versie kan afwijken.)

module github.com/myuser/calculator

go 1.14

Als u wilt verwijzen naar uw calculator pakket in andere programma's, moet u het importeren met behulp van de modulenaam. In dit geval is github.com/myuser/calculatorde naam . Laten we nu eens kijken naar een voorbeeld van het gebruik van dit pakket.

Notitie

In het verleden is het beheren van afhankelijkheden in Go niet eenvoudig geweest. Het systeem voor afhankelijkhedenbeheer is nog steeds bezig. Als u meer wilt weten over modules, raadpleegt u deze reeks berichten die zijn gepubliceerd in de Go-blog.

Verwijzen naar een lokaal pakket (een module)

Nu gaan we het pakket gebruiken. We gaan verder met de voorbeeldtoepassing die we hebben gebruikt. Deze keer gebruiken we, in plaats van de sum functie in het main pakket, de functie die we eerder in het calculator pakket hebben gemaakt.

De structuur van het structuurbestand moet er nu als volgt uitzien:

src/
  calculator/
    go.mod
    sum.go
  helloworld/
    main.go

We gebruiken deze code voor het $GOPATH/src/helloworld/main.go bestand:

package main

import (
  "fmt"
  "github.com/myuser/calculator"
)

func main() {
    total := calculator.Sum(3, 5)
    fmt.Println(total)
    fmt.Println("Version: ", calculator.Version)
}

U ziet dat de importinstructie gebruikmaakt van de naam van het pakket dat u hebt gemaakt: calculator. Als u de Sum functie vanuit dat pakket wilt aanroepen, moet u de pakketnaam opnemen, zoals in calculator.Sum. Ten slotte hebt u nu ook toegang tot de Version variabele. Je noemt het als volgt: calculator.Version.

Als u het programma nu probeert uit te voeren, werkt het niet. U moet Go laten weten dat u modules gebruikt om te verwijzen naar andere pakketten. Voer hiervoor deze opdracht uit in de $GOPATH/src/helloworld map:

go mod init helloworld

In de vorige opdracht helloworld is dit de naam van het project. Met deze opdracht maakt u een nieuw go.mod bestand, dus nu ziet de structuurmap er als volgt uit:

src/
  calculator/
    go.mod
    sum.go
  helloworld/
    go.mod
    main.go

Wanneer u het go.mod bestand opent, ziet u ongeveer de volgende code. (De Go-versie kan afwijken.)

module helloworld

go 1.14

Omdat u verwijst naar een lokale kopie van de module, moet u Go informeren dat u geen externe locatie wilt gebruiken. U moet het go.mod bestand dus handmatig wijzigen om de verwijzing op te nemen, zoals deze:

module helloworld

go 1.14

require github.com/myuser/calculator v0.0.0

replace github.com/myuser/calculator => ../calculator

Het replace trefwoord geeft aan dat een lokale map moet worden gebruikt in plaats van een externe locatie voor de module. In dit geval, omdat de helloworld en calculator programma's zich bevinden $GOPATH/src, is de locatie gewoon ../calculator. Als de bron van de module zich op een andere locatie bevindt, definieert u hier het lokale pad.

Voer het programma uit met behulp van deze opdracht:

go run main.go

De uitvoer moet als volgt zijn:

8
Version:  1.0

Uitdaging 1

Wat gebeurt er als u de logMessage variabele of de internalSum functie probeert aan te roepen vanuit het calculator pakket in de hoofdtoepassing? Wordt het uitgevoerd? Probeer het eens!

Oplossing voor uitdaging:

package main

import (
 "fmt"
 "github.com/myuser/calculator"
)

func main() {
    total := calculator.internalSum(5)
    fmt.Println(total)
    fmt.Println("Version: ", calculator.logMessage)
}

Een pakket publiceren

Het publiceren van een Go-pakket is vrij eenvoudig. U hoeft alleen de broncode van het pakket openbaar beschikbaar te maken. De meeste ontwikkelaars gebruiken GitHub om pakketten beschikbaar te maken voor het publiek. Daarom vindt u soms verwijzingen naar github.com in importinstructies.

Als u uw pakket bijvoorbeeld wilt publiceren calculator naar uw GitHub-account, moet u een opslagplaats met de naam calculatormaken. De URL moet er ongeveer als volgt uitzien:

https://github.com/myuser/calculator

U gaat uw pakketten versien door uw opslagplaats te taggen, zoals hieronder:

git tag v0.1.0
git push origin v0.1.0

Ontwikkelaars die uw pakket (inclusief u) willen gebruiken, verwijzen er als volgt naar:

import "github.com/myuser/calculator"

Laten we eens nader ingaan op het verwijzen naar pakketten van derden.

Externe (externe) pakketten verwijzen

Soms moeten uw programma's verwijzen naar pakketten die zijn geschreven door andere ontwikkelaars. Deze pakketten zijn doorgaans beschikbaar op GitHub. De volgende instructies voor het verwijzen naar pakketten van derden werken of u een pakket ontwikkelt (een ander pakket dan main) of een zelfstandig programma (het main pakket).

Laten we een verwijzing naar het rsc.io/quote pakket toevoegen:

package main

import (
    "fmt"
    "github.com/myuser/calculator"
    "rsc.io/quote"
)

func main() {
    total := calculator.Sum(3, 5)
    fmt.Println(total)
    fmt.Println("Version: ", calculator.Version)
    fmt.Println(quote.Hello())
}

Als u Visual Studio Code gebruikt, wordt het go.mod bestand bijgewerkt wanneer u het bestand opslaat. Het ziet er nu als volgt uit:

module helloworld

go 1.14

require (
    github.com/myuser/calculator v0.0.0
    rsc.io/quote v1.5.2
)

replace github.com/myuser/calculator => ../calculator

U ziet hoe rsc.io/quote verwijst naar een specifieke versie van het pakket. Wanneer u de afhankelijkheden van uw programma moet upgraden, moet u hier de versie wijzigen.

Voer het programma opnieuw uit met behulp van deze opdracht:

go run main.go

De uitvoer moet er ongeveer als volgt uitzien:

8
Version:  1.0
Hello, world.

Alle toekomstige verwijzingen naar pakketten van derden moeten in het go.mod bestand staan. Wanneer u de toepassing uitvoert of compileert, downloadt Go alle bijbehorende afhankelijkheden.