Dowiedz się więcej o pakietach

10 min

Pakiety w języku Go są podobne do bibliotek lub modułów w innych językach programowania. Możesz spakować kod i ponownie użyć go w innym miejscu. Kod źródłowy pakietu może być dystrybuowany w więcej niż jednym .go pliku. Do tej pory pisaliśmy main pakiet i wykonaliśmy kilka odwołań do innych pakietów natywnych.

W tej sekcji dowiesz się, czym jest pakiet. Dowiesz się również, jak utworzyć pakiet i jak korzystać z pakietów zewnętrznych.

Pakiet główny

Jak można zauważyć, nawet najprostszy program w języku Go musi być częścią pakietu. Zazwyczaj domyślny pakiet to main pakiet, którego używaliśmy do tej pory. Jeśli program jest częścią main pakietu, go generuje plik binarny. Po uruchomieniu main() tego pliku wywołuje funkcję .

Innymi słowy, gdy używasz main pakietu, program utworzy autonomiczny plik wykonywalny. Ale gdy program jest częścią pakietu innego niż main, go nie generuje pliku binarnego. Generuje plik archiwum pakietu (plik z .a rozszerzeniem).

W języku Go nazwy pakietów są zgodne z konwencją. Pakiet używa ostatniej części ścieżki importu jako nazwy. Na przykład standardowa biblioteka Języka Go zawiera pakiet o nazwie math/cmplx, który udostępnia przydatny kod do pracy z liczbami złożonymi. Ścieżka importu tego pakietu to math/cmplx, a importujesz go w następujący sposób:

import "math/cmplx"

Aby odwołać się do obiektów w pakiecie, użyj nazwy pakietu , cmplxw następujący sposób:

cmplx.Inf()

Utwórzmy pakiet.

Tworzenie pakietu

Utwórz nowy katalog w $GOPATH/src katalogu o nazwie calculator. Utwórz plik o nazwie sum.go. Katalog drzewa powinien wyglądać następująco:

src/
  calculator/
    sum.go

Zainicjuj sum.go plik o nazwie pakietu:

package calculator

Teraz możesz zacząć pisać funkcje i zmienne dla pakietu. W przeciwieństwie do innych języków programowania język Go nie udostępnia public słów kluczowych lub private , aby wskazać, czy zmienna lub funkcja może być wywoływana z zewnątrz lub wewnątrz pakietu. Jednak język Go jest zgodny z dwiema prostymi regułami:

Jeśli chcesz, aby coś było prywatne, zacznij od jego nazwy małymi literami.
Jeśli chcesz, aby coś było publiczne, zacznij od jego nazwy wielkimi literami.

Dodajmy więc następujący kod do tworzonego pakietu kalkulatora:

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
}

Przyjrzyjmy się kilku elementom w tym kodzie:

Zmienna logMessage może być wywoływana tylko z poziomu pakietu.
Zmienną Version można uzyskać z dowolnego miejsca. Zalecamy dołączenie komentarza w celu opisania przeznaczenia tej zmiennej. (Ten opis jest przydatny dla każdego, kto używa pakietu).
Funkcja internalSum może być wywoływana tylko z poziomu pakietu.
Funkcja Sum może być osiągana z dowolnego miejsca. Zalecamy dołączenie komentarza w celu opisania przeznaczenia funkcji.

Aby potwierdzić, że wszystko działa, możesz uruchomić go build polecenie w calculator katalogu. Jeśli to zrobisz, zwróć uwagę, że nie jest generowany plik binarny wykonywalny.

Tworzenie modułu

Funkcje kalkulatora zostały umieszczone w pakiecie. Teraz nadszedł czas, aby umieścić ten pakiet w module. Moduły języka Go zwykle zawierają pakiety, które oferują powiązane funkcje. Moduł pakietu określa również kontekst, w którym należy uruchomić kod zgrupowany razem. Te informacje kontekstowe zawierają wersję języka Go, dla których został napisany kod.

Ponadto moduły ułatwiają innym deweloperom odwołanie do określonych wersji kodu i ułatwiają pracę z zależnościami. Kolejną korzyścią jest to, że kod źródłowy naszego programu nie musi ściśle istnieć w $GOPATH/src katalogu. Zwolnienie tego ograniczenia ułatwia pracę z różnymi wersjami pakietów w innych projektach w tym samym czasie.

Aby utworzyć moduł dla calculator pakietu, uruchom to polecenie w katalogu głównym ($GOPATH/src/calculator):

go mod init github.com/myuser/calculator

Po uruchomieniu tego polecenia github.com/myuser/calculator staje się nazwą modułu. Użyjesz tej nazwy, aby odwoływać się do niej w innych programach. Polecenie tworzy również nowy plik o nazwie go.mod. Na koniec katalog drzewa wygląda teraz następująco:

src/
  calculator/
    go.mod
    sum.go

Zawartość go.mod pliku powinna wyglądać podobnie do poniższego kodu. (Wersja języka Go może być inna).

module github.com/myuser/calculator

go 1.14

Aby odwołać się calculator do pakietu w innych programach, należy go zaimportować przy użyciu nazwy modułu. W tym przypadku nazwa to github.com/myuser/calculator. Teraz przyjrzyjmy się przykładowi użycia tego pakietu.

Uwaga

Historycznie zarządzanie zależnościami w języku Go nie było łatwe. System zarządzania zależnościami jest nadal w toku. Jeśli chcesz dowiedzieć się więcej o modułach, zobacz tę serię wpisów opublikowanych w blogu Języka Go.

Odwołanie do pakietu lokalnego (modułu)

Teraz użyjemy pakietu. Będziemy kontynuować korzystanie z przykładowej aplikacji. Tym razem zamiast funkcji sum w main pakiecie użyjemy tej, która została utworzona wcześniej w pakiecie calculator .

Struktura pliku drzewa powinna teraz wyglądać następująco:

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

Użyjemy tego kodu dla $GOPATH/src/helloworld/main.go pliku:

package main

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

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

Zwróć uwagę, że instrukcja import używa nazwy utworzonego pakietu: calculator. Aby wywołać Sum funkcję z tego pakietu, należy dołączyć nazwę pakietu, jak w pliku calculator.Sum. Na koniec masz również dostęp do zmiennej Version . Nazywasz to w następujący sposób: calculator.Version.

Jeśli spróbujesz uruchomić program teraz, nie będzie działać. Musisz poinformować go, że używasz modułów do odwołowania się do innych pakietów. W tym celu uruchom następujące polecenie w $GOPATH/src/helloworld katalogu:

go mod init helloworld

W poprzednim poleceniu helloworld jest nazwą projektu. To polecenie tworzy nowy go.mod plik, więc teraz katalog drzewa wygląda następująco:

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

Po otwarciu go.mod pliku powinien zostać wyświetlony kod podobny do poniższego. (Wersja języka Go może być inna).

module helloworld

go 1.14

Ponieważ odwołujesz się do lokalnej kopii modułu, musisz poinformować go, że nie chcesz używać lokalizacji zdalnej. Dlatego należy ręcznie zmodyfikować plik, go.mod aby uwzględnić odwołanie, w następujący sposób:

module helloworld

go 1.14

require github.com/myuser/calculator v0.0.0

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

Słowo replace kluczowe określa użycie katalogu lokalnego zamiast lokalizacji zdalnej dla modułu. W tym przypadku, ponieważ programy helloworld i calculator znajdują się w $GOPATH/srclokalizacji , lokalizacja to po prostu ../calculator. Jeśli źródło modułu znajduje się w innej lokalizacji, zdefiniuj ścieżkę lokalną tutaj.

Uruchom program przy użyciu tego polecenia:

go run main.go

Dane wyjściowe powinny być następujące:

8
Version:  1.0

Wyzwanie 1

Co się stanie, jeśli spróbujesz wywołać zmienną logMessage lub internalSum funkcję z calculator pakietu w głównej aplikacji? Czy działa? Sprawdź to!

Rozwiązanie wyzwania:

package main

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

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

Publikowanie pakietu

Publikowanie pakietu Języka Go jest dość łatwe. Wystarczy udostępnić publicznie kod źródłowy pakietu. Większość deweloperów używa usługi GitHub do udostępniania pakietów publicznie, dlatego czasami znajdziesz odwołania do github.com w instrukcjach importu.

Jeśli na przykład chcesz opublikować calculator pakiet na koncie usługi GitHub, musisz utworzyć repozytorium o nazwie calculator. Adres URL powinien wyglądać podobnie do następującego:

https://github.com/myuser/calculator

Pakiety będą wersjonowane przez tagowanie repozytorium w następujący sposób:

git tag v0.1.0
git push origin v0.1.0

Deweloperzy, którzy chcą używać pakietu (w tym Ty), odwołyliby się do niego w następujący sposób:

import "github.com/myuser/calculator"

Bardziej szczegółowo omówimy sposób odwołowania się do pakietów innych firm.

Odwołania do pakietów zewnętrznych (innych firm)

Czasami programy muszą odwoływać się do pakietów napisanych przez innych deweloperów. Zazwyczaj te pakiety są dostępne w witrynie GitHub. Poniższe instrukcje dotyczące odwoływania się do pakietów innych firm działają niezależnie od tego, czy tworzysz pakiet (pakiet inny niż main) lub autonomiczny program ( main pakiet).

Dodajmy odwołanie do rsc.io/quote pakietu:

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

Jeśli używasz programu Visual Studio Code, go.mod plik zostanie zaktualizowany podczas zapisywania pliku. Teraz wygląda następująco:

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

Zwróć uwagę, jak rsc.io/quote odwołuje się do określonej wersji pakietu. Jeśli musisz uaktualnić zależności programu, musisz zmienić wersję w tym miejscu.

Uruchom ponownie program przy użyciu tego polecenia:

go run main.go

Dane wyjściowe powinny wyglądać podobnie do poniższych:

8
Version:  1.0
Hello, world.

Wszystkie przyszłe odwołania do pakietów innych firm muszą znajdować się w go.mod pliku. Po uruchomieniu lub skompilowaniu aplikacji go pobierze wszystkie jej zależności.