Další informace o balíčcích

10 min

Balíčky v Go jsou podobné knihovnám nebo modulům v jiných programovacích jazycích. Kód můžete zabalit a znovu ho použít někam jinam. Zdrojový kód balíčku lze distribuovat ve více souborech .go . Zatím jsme balíček psali main a odkazovali jsme na další nativní balíčky.

V této části se dozvíte, co je balíček. Dozvíte se také, jak ho vytvořit a jak využívat externí balíčky.

Hlavní balíček

Jak jste si možná všimli, i nejjednodušší program v Go musí být součástí balíčku. Výchozí balíček je main obvykle balíček, který jsme zatím používali. Pokud je program součástí main balíčku, Go vygeneruje binární soubor. Když se tento soubor spustí, zavolá main() funkci.

Jinými slovy, když balíček použijete main , program vytvoří samostatný spustitelný soubor. Ale pokud je program součástí jiného balíčku než main, Go negeneruje binární soubor. Vygeneruje soubor archivu balíčku (soubor s příponou .a ).

Názvy balíčků v Go se řídí konvencí. Balíček jako název používá poslední část jeho cesty importu. Standardní knihovna Go například obsahuje balíček s názvem math/cmplx, který poskytuje užitečný kód pro práci se složitými čísly. Cesta k importu tohoto balíčku je math/cmplxa importujete ji takto:

import "math/cmplx"

Pokud chcete odkazovat na objekty v balíčku, použijte název balíčku, cmplxnapříklad takto:

cmplx.Inf()

Pojďme vytvořit balíček.

Vytvoření balíčku

Vytvořte v adresáři $GOPATH/src nový adresář s názvem calculator. Vytvořte soubor s názvem sum.go. Adresář stromové struktury by měl vypadat takto:

src/
  calculator/
    sum.go

Inicializace sum.go souboru s názvem balíčku:

package calculator

Teď můžete začít psát funkce a proměnné balíčku. Na rozdíl od jiných programovacích jazyků Go neposkytuje public klíčová slova, private která označují, jestli se proměnná nebo funkce dají volat zvenčí nebo uvnitř balíčku. Go se ale řídí dvěma jednoduchými pravidly:

Pokud chcete, aby něco bylo soukromé, začněte jeho název malým písmenem.
Pokud chcete, aby něco bylo veřejné, začněte jeho název velkým písmenem.

Pojďme tedy do balíčku kalkulačky, který vytváříme, přidat následující kód:

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
}

Pojďme se podívat na několik věcí v kódu:

Proměnnou logMessage lze volat pouze z balíčku.
Proměnná Version je přístupná odkudkoli. Doporučujeme přidat komentář k popisu účelu této proměnné. (Tento popis je užitečný pro každého, kdo balíček používá.)
Funkci internalSum lze volat pouze z balíčku.
Funkce Sum je přístupná odkudkoli. Doporučujeme, abyste přidali komentář k popisu účelu funkce.

Pokud chcete ověřit, že všechno funguje, můžete příkaz spustit go build v calculator adresáři. Pokud ano, všimněte si, že se negeneruje žádný spustitelný binární soubor.

Vytvoření modulu

Funkce kalkulačky jste umístili do balíčku. Teď je čas tento balíček umístit do modulu. Moduly Go obvykle obsahují balíčky, které nabízejí související funkce. Modul balíčku také určuje kontext, který Go potřebuje ke spuštění kódu, který jste seskupili. Tyto kontextové informace zahrnují verzi Jazyka Go, pro které je váš kód napsaný.

Moduly také pomáhají ostatním vývojářům odkazovat na konkrétní verze kódu a usnadňují práci se závislostmi. Další výhodou je, že zdrojový kód našeho programu nemusí v adresáři existovat výhradně $GOPATH/src . Když toto omezení uvolníte, bude pohodlnější pracovat s různými verzemi balíčků v jiných projektech najednou.

Pokud tedy chcete pro balíček vytvořit modul calculator , spusťte tento příkaz v kořenovém adresáři ($GOPATH/src/calculator):

go mod init github.com/myuser/calculator

Po spuštění tohoto příkazu github.com/myuser/calculator se změní na název modulu. Tento název použijete k odkaz na tento název v jiných programech. Příkaz také vytvoří nový soubor s názvem go.mod. Adresář stromové struktury teď vypadá takto:

src/
  calculator/
    go.mod
    sum.go

Obsah go.mod souboru by měl vypadat jako následující kód. (Verze Go se může lišit.)

module github.com/myuser/calculator

go 1.14

Pokud chcete na balíček odkazovat calculator v jiných programech, musíte ho importovat pomocí názvu modulu. V tomto případě je github.com/myuser/calculatornázev . Teď se podíváme na příklad použití tohoto balíčku.

Poznámka:

Správa závislostí v Go v minulosti nebyla snadná. Systém správy závislostí stále probíhá. Pokud se chcete dozvědět více o modulech, podívejte se na tuto řadu příspěvků publikovaných na blogu Go.

Odkaz na místní balíček (modul)

Teď balíček použijeme. Budeme pokračovat v ukázkové aplikaci, která používáme. Tentokrát místo sum funkce v main balíčku použijeme ten, který jsme vytvořili dříve v calculator balíčku.

Struktura souborů stromové struktury by teď měla vypadat takto:

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

Tento kód použijeme pro $GOPATH/src/helloworld/main.go soubor:

package main

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

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

Všimněte si, že příkaz importu používá název balíčku, který jste vytvořili: calculator. Chcete-li volat Sum funkci z daného balíčku, musíte zahrnout název balíčku, jako v calculator.Sum. Nakonec máte také přístup k Version proměnné. Říkáte tomu takto: calculator.Version.

Pokud se teď pokusíte program spustit, nebude fungovat. Musíte říct Go, že používáte moduly k odkazování na jiné balíčky. Uděláte to tak, že v adresáři $GOPATH/src/helloworld spustíte tento příkaz:

go mod init helloworld

V předchozím příkazu helloworld je název projektu. Tento příkaz vytvoří nový go.mod soubor, takže teď adresář stromové struktury vypadá takto:

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

Když soubor otevřete go.mod , měli byste vidět něco jako následující kód. (Verze Go se může lišit.)

module helloworld

go 1.14

Vzhledem k tomu, že odkazujete na místní kopii modulu, musíte informovat Go, že nechcete používat vzdálené umístění. Proto musíte soubor ručně upravit go.mod tak, aby zahrnoval odkaz, například takto:

module helloworld

go 1.14

require github.com/myuser/calculator v0.0.0

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

Klíčové replace slovo určuje použití místního adresáře místo vzdáleného umístění modulu. V tomto případě, protože a helloworld calculator programy jsou v $GOPATH/src, umístění je jednoduše ../calculator. Pokud je zdroj modulu v jiném umístění, definujete zde místní cestu.

Spusťte program pomocí tohoto příkazu:

go run main.go

Výstup by měl vypadat takto:

8
Version:  1.0

Výzva 1

Co se stane, když se pokusíte volat logMessage proměnnou nebo internalSum funkci z calculator balíčku v hlavní aplikaci? Běží? Vyzkoušejte to!

Řešení výzvy:

package main

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

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

Publikování balíčku

Publikování balíčku Go je poměrně snadné. Stačí, aby byl zdrojový kód balíčku veřejně dostupný. Většina vývojářů používá GitHub k zpřístupnění balíčků veřejnosti, což je důvod, proč někdy najdete odkazy na github.com příkazy importu.

Pokud například chcete balíček publikovat calculator do účtu GitHubu, musíte vytvořit úložiště s názvem calculator. Adresa URL by měla vypadat nějak takto:

https://github.com/myuser/calculator

Balíčky budete mít ve verzi označováním úložiště, například takto:

git tag v0.1.0
git push origin v0.1.0

Vývojáři, kteří chtějí použít váš balíček (včetně vás), by na něj mohli odkazovat takto:

import "github.com/myuser/calculator"

Pojďme se podrobněji seznámit s odkazem na balíčky třetích stran.

Odkaz na externí balíčky (třetích stran)

Někdy vaše programy potřebují odkazovat na balíčky napsané jinými vývojáři. Tyto balíčky jsou obvykle dostupné na GitHubu. Následující pokyny pro odkazování na balíčky třetích stran fungují bez ohledu na to, jestli vyvíjíte balíček (jiný balíček než main) nebo samostatný program ( main balíček).

Pojďme přidat odkaz na rsc.io/quote balíček:

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())
}

Pokud používáte Visual Studio Code, go.mod soubor se při uložení souboru aktualizuje. Teď vypadá takto:

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

Všimněte si, jak rsc.io/quote odkazuje na konkrétní verzi balíčku. Pokud potřebujete upgradovat závislosti programu, budete muset změnit verzi zde.

Spusťte program znovu pomocí tohoto příkazu:

go run main.go