TOC

Pakete in Go importieren

Einführung

Es wird Zeiten geben, in denen Ihr Code zusätzliche Funktionen außerhalb Ihres aktuellen Programms benötigt. In diesen Fällen können Sie Pakete verwenden, um Ihr Programm komplexer zu gestalten. Ein Paket repräsentiert alle Dateien in einem einzigen Verzeichnis auf der Festplatte. Pakete können Funktionen, Typen und Schnittstellen definieren, auf die Sie in anderen Go-Dateien oder Paketen verweisen können.

In diesem Tutorial werden Sie durch das Installieren, Importieren und Aliasing von Paketen geführt.

Standard-Bibliothekspakete

Die mit Go gelieferte Standardbibliothek besteht aus einer Reihe von Paketen. Diese Pakete enthalten viele grundlegende Bausteine ​​zum Schreiben moderner Software. Beispielsweise enthält das Paketfmtgrundlegende Funktionen zum Formatieren und Drucken von Zeichenfolgen. Das Paketnet/httpenthält Funktionen, mit denen Entwickler Webdienste erstellen, Daten über das Protokollhttpenden und abrufen können und vieles mehr.

Um die Funktionen in einem Paket nutzen zu können, müssen Sie mit einerimport-Anweisung auf das Paket zugreifen. Eineimport-Anweisung besteht aus dem Schlüsselwortimport zusammen mit dem Namen des Pakets.

In der Go-Programmdateirandom.go können Sie beispielsweise das Paketmath/rand importieren, um auf folgende Weise Zufallszahlen zu generieren:

random.go

import "math/rand"

Wenn wir ein Paket importieren, stellen wir es in unserem aktuellen Programm als separaten Namespace zur Verfügung. Dies bedeutet, dass wir uns auf die Funktion indot notation wie inpackage.function beziehen müssen.

In der Praxis könnte eine Funktion aus dem Paketmath/randwie folgt aussehen:

  • rand.Int(), das die Funktion aufruft, um eine zufällige Ganzzahl zurückzugeben.

  • rand.Intn(), das die Funktion aufruft, um ein zufälliges Element von0 bis zur angegebenen angegebenen Zahl zurückzugeben.

Erstellen wir einefor-Schleife, um zu zeigen, wie wir eine Funktion desmath/rand-Pakets in unseremrandom.go-Programm aufrufen:

random.go

package main

import "math/rand"

func main() {
  for i := 0; i < 10; i++ {
    println(rand.Intn(25))
  }
}

Dieses Programm importiert zuerst das Paketmath/randin der dritten Zeile und wechselt dann in eine Schleifefor, die zehnmal ausgeführt wird. Innerhalb der Schleife gibt das Programm eine zufällige Ganzzahl im Bereich von0 bis25 aus. Die Ganzzahl25 wird als Parameter anrand.Intn() übergeben.

Wenn wir das Programm mitgo run random.go ausführen, erhalten wir 10 zufällige Ganzzahlen als Ausgabe. Da diese zufällig sind, erhalten Sie bei jeder Ausführung des Programms wahrscheinlich unterschiedliche Ganzzahlen. Die Ausgabe sieht ungefähr so ​​aus: 

Output6
12
22
9
6
18
0
15
6
0

Die Ganzzahlen werden niemals unter 0 oder über 24 gehen.

Wenn Sie mehr als ein Paket importieren, können Sie mit()einen Block erstellen. Durch die Verwendung eines Blocks können Sie vermeiden, das Schlüsselwortimportin jeder Zeile zu wiederholen. Dadurch sieht Ihr Code sauberer aus:

random.go

import (
  "fmt"
  "math/rand"
)

Um das zusätzliche Paket zu nutzen, können wir jetzt die Ausgabe formatieren und die Iteration ausdrucken, auf der jede Zufallszahl während der Schleife generiert wurde:

random.go

package main

import (
  "fmt"
  "math/rand"
)

func main() {
  for i := 0; i < 10; i++ {
    fmt.Printf("%d) %d\n", i, rand.Intn(25))
  }
}

Wenn wir jetzt unser Programm ausführen, erhalten wir eine Ausgabe, die so aussieht: 

Output0) 6
1) 12
2) 22
3) 9
4) 6
5) 18
6) 0
7) 15
8) 6
9) 0

In diesem Abschnitt haben wir gelernt, wie Pakete importiert und zum Schreiben eines komplexeren Programms verwendet werden. Bisher haben wir nur Pakete aus der Standardbibliothek verwendet. Als Nächstes sehen wir uns an, wie Sie Pakete installieren und verwenden, die von anderen Entwicklern geschrieben wurden.

Pakete installieren

Während die Standardbibliothek mit vielen großartigen und nützlichen Paketen geliefert wird, sind sie absichtlich so konzipiert, dass siegeneral purpose und nicht spezifisch sind. Auf diese Weise können Entwickler ihre eigenen Pakete auf der Basis der Standardbibliothek für ihre eigenen spezifischen Anforderungen erstellen.

Die Go-Werkzeugkette wird mit dem Befehlgo getgeliefert. Mit diesem Befehl können Sie Pakete von Drittanbietern in Ihrer lokalen Entwicklungsumgebung installieren und in Ihrem Programm verwenden.

Wenn Siego get zum Installieren von Paketen von Drittanbietern verwenden, wird ein Paket häufig über seinen kanonischen Pfad referenziert. Dieser Pfad kann auch ein Pfad zu einem öffentlichen Projekt sein, das in einem Code-Repository wie GitHub gehostet wird. Wenn Sie das Paketflectimportieren möchten, verwenden Sie den vollständigen kanonischen Pfad: 

go get github.com/gobuffalo/flect

Das Toolgo get findet das Paket, in diesem Fall auf GitHub, und installiert es in$GOPATH.

In diesem Beispiel würde der Code in diesem Verzeichnis installiert: 

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

Pakete werden häufig von den ursprünglichen Autoren aktualisiert, um Fehler zu beheben oder neue Funktionen hinzuzufügen. In diesem Fall möchten Sie möglicherweise die neueste Version dieses Pakets verwenden, um die neuen Funktionen oder den behobenen Fehler zu nutzen. Um ein Paket zu aktualisieren, können Sie das Flag-u mit dem Befehlgo get verwenden: 

go get -u github.com/gobuffalo/flect

Mit diesem Befehl kann Go das Paket auch installieren, wenn es nicht lokal gefunden wird. Wenn es bereits installiert ist, versucht Go, das Paket auf die neueste Version zu aktualisieren.

Der Befehlgo get ruft immer die neueste verfügbare Version des Pakets ab. Möglicherweise gibt es jedoch Aktualisierungen für frühere Versionen des Pakets, die noch neuer als die von Ihnen verwendeten sind und für Aktualisierungen in Ihrem Programm hilfreich sind. Um diese bestimmte Version des Pakets abzurufen, müssten Sie einPackage Management-Tool verwenden, z. B.Go Modules.

Ab Go 1.11 verwalten Sie mit Go-Modulen, welche Version des Pakets Sie importieren möchten. Das Thema Paketverwaltung geht über den Rahmen dieses Artikels hinaus, Sie können jedoch mehr darüber lesenon the Go Modules GitHub page.

Aliasing importierter Pakete

Möglicherweise möchten Sie einen Paketnamen ändern, wenn Sie bereits ein lokales Paket mit dem Namen eines von Ihnen verwendeten Drittanbieter-Pakets haben. In diesem Fall ist das Aliasing Ihres Imports die beste Möglichkeit, die Kollision zu behandeln. Sie können die Namen von Paketen und ihre Funktionen in Go ändern, indem Sie einenalias-Namen vor das importierte Paket setzen.

Der Aufbau dieser Aussage sieht folgendermaßen aus: 

import another_name "package"

Ändern Sie in diesem Beispiel den Namen des Paketsfmtin der Programmdateirandom.go. Wir werden den Paketnamen vonfmt inf ändern, um ihn abzukürzen. Unser modifiziertes Programm sieht dann so aus:

random.go

package main

import (
 f "fmt"
  "math/rand"
)

func main() {
  for i := 0; i < 10; i++ {
    f.Printf("%d) %d\n", i, rand.Intn(25))
  }
}

Innerhalb des Programms bezeichnen wir die FunktionPrintf nun alsf.Printf und nicht alsfmt.Printf.

Andere Sprachen bevorzugen das Aliasing eines Pakets, um die spätere Verwendung im Programm zu vereinfachen, Go hingegen nicht. Zum Beispiel würde ein Aliasing des Paketsfmt auff nicht mit dem Paketstyle guide übereinstimmen.

Wenn Sie Importe umbenennen, um eine Namenskollision zu vermeiden, sollten Sie versuchen, den lokalsten oder projektspezifischsten Import umzubenennen. Wenn Sie beispielsweise einlocal-Paket namensstrings hätten und auch dassystem-Paket namensstrings importieren müssten, würden Sie es vorziehen, Ihr lokales Paket gegenüber dem System umzubenennen Paket. Vermeiden Sie nach Möglichkeit Namenskollisionen.

In diesem Abschnitt haben wir erfahren, wie wir einen Import aliasisieren können, um zu vermeiden, dass er mit einem anderen Import in unserem Programm kollidiert. Beachten Sie, dass die Lesbarkeit und Klarheit Ihres Programms wichtig ist. Verwenden Sie daher nur Aliasing, um den Code besser lesbar zu machen, oder wenn Sie eine Namenskollision vermeiden müssen.

Importe formatieren

Durch Formatieren von Importen können Sie die Pakete in einer bestimmten Reihenfolge sortieren, die Ihren Code konsistenter macht. Außerdem wird so verhindert, dass zufällige Festschreibungen erfolgen, wenn sich nur die Sortierreihenfolge der Importe ändert. Da das Formatieren von Importen zufällige Festschreibungen verhindert, werden unnötige Codeabwanderung und verwirrende Codeüberprüfungen vermieden.

Die meisten Editoren formatieren Importe automatisch für Sie oder lassen Sie Ihren Editor für die Verwendung vongoimports konfigurieren. Es wird als Standardpraxis angesehen,goimports in Ihrem Editor zu verwenden, da der Versuch, die Sortierreihenfolge Ihrer Importe manuell zu verwalten, mühsam und fehleranfällig sein kann. Wenn außerdem Stiländerungen vorgenommen werden, werdengoimports aktualisiert, um diese Stiländerungen widerzuspiegeln. Dies stellt sicher, dass Sie und alle, die an Ihrem Code arbeiten, in Ihren Importblöcken ein einheitliches Design haben.

So kann ein Beispiel-Importblock vor dem Formatieren aussehen: 

import (
  "fmt"
  "os"
  "github.com/digital/ocean/godo"
  "github.com/sammy/foo"
  "math/rand"
  "github.com/sammy/bar"
)

Wenn Sie das Toolgoimportausführen (oder wenn die meisten Editoren es installiert haben und die Datei speichern, wird es für Sie ausgeführt), haben Sie jetzt das folgende Format: 

import (
  "fmt"
  "math/rand"
  "os"

  "github.com/sammy/foo"
  "github.com/sammy/bar"

  "github.com/digital/ocean/godo"
)

Beachten Sie, dass zuerst alle Standardbibliothekspakete und dann Pakete von Drittanbietern mit Leerzeilen gruppiert werden. Dadurch ist es einfacher zu lesen und zu verstehen, welche Pakete verwendet werden.

In diesem Abschnitt haben wir erfahren, dass durch die Verwendung vongoimports alle unsere Importblöcke ordnungsgemäß formatiert bleiben und unnötige Code-Abwanderung zwischen Entwicklern verhindert wird, die an denselben Dateien arbeiten.

Fazit

Wenn wir Pakete importieren, können wir Funktionen aufrufen, die nicht in Go integriert sind. Einige Pakete sind Teil der Standardbibliothek, die mit Go installiert wird, andere werden übergo get installiert.

Durch die Verwendung von Paketen können wir unsere Programme robuster und leistungsfähiger machen, indem wir vorhandenen Code nutzen. Wir können auchcreate our own packages für uns und andere Programmierer in zukünftigen Programmen verwenden.

Related