Go (auch bekannt als Golang) ist eine quelloffene, statisch typisierte Programmiersprache. Sie wurde ursprünglich von Google entwickelt. Zu den bemerkenswerten Eigenschaften von Go gehören Einfachheit, hohe Leistung, Lesbarkeit und Effizienz.
Wie jede andere bekannte Programmiersprache bietet auch die Standardbibliothek von Go eine reichhaltige Auswahl an Paketen. Wir können die Funktionalitäten jedoch auch durch die Einbindung von Drittanbieter-Paketen erweitern. Diese Anleitung wird zeigen, wie Sie Pakete importieren und in Ihre Go-Projekte einbinden.
Voraussetzungen
Um dieser Anleitung zu folgen, müssen Ihnen die folgenden Komponenten zur Verfügung stehen:
- Ein ordnungsgemäß konfigurierter Ubuntu-Server. Erfahren Sie mehr über die Konfiguration Ihres eigenen Ubuntu-Servers auf CloudSigma.
- Die Go-Programmierumgebung. Sie können diese Anleitung verwenden für die Installation von Go auf Ubuntu.
- Ein moderner Texteditor, zum Beispiel Vim, Sublime Text, Atom, Visual Studio Code, Brackets, etc. In dieser Anleitung wird Visual Studio Code .
Schritt 1 – Installation von Go
Wir haben bereits über die Installation der Kernkomponente Go-Programmiersprache auf Ubuntu 20.04 gesprochen. Es gibt jedoch eine einfachere alternative Methode: g (ein leichtgewichtiger Go-Versionsmanager).
Der Grund, warum wir g verwenden werden, ist, dass weder die in den Ubuntu-Paketquellen noch die über Snap verfügbaren Go-Versionen die neueste verfügbare Go-Version enthalten (v1.18 zum Zeitpunkt der Erstellung dieser Anleitung). Es wird immer empfohlen, die neueste verfügbare Version eines Programmiersprachenpakets zu verwenden.
Der folgende Befehl führt das Installationsskript für g aus:
|
1 |
wget -qO- https://git.io/g-install | sh -s |
Damit die Änderungen wirksam werden, müssen Sie die Shell-Sitzung neu starten. Überprüfen Sie nach dem Neustart die Installation:
|
1 |
go version |
|
1 |
which go |
Nach der Installation von Go wird außerdem empfohlen, gopls zu installieren. Dies ist der offizielle Go-Language-Server. Er ist mit vielen Texteditoren wie VS Code, Vim, Emacs, Sublime Text, Atom und vielen anderen kompatibel. Führen Sie den folgenden Befehl aus:
|
1 |
go install golang.org/x/tools/gopls@latest |
Unsere Go-Programmierumgebung ist jetzt bereit.
Schritt 2 – Erstellen eines Go-Beispielskripts
Der gesamte in dieser Anleitung gezeigte Code passt in ein einziges Go-Skript. Erstellen Sie ein Go-Beispielskript:
|
1 |
touch practice.go |
Nachdem Sie Änderungen am Skript vorgenommen haben, können Sie es mit dem folgenden Go-Befehl ausführen:
|
1 |
go run practice.go |
Hier führt der Go-Compiler den Code im Interpreter-Modus aus.
Schritt 3 – Verwendung von Standardbibliotheks-Paketen
Go bringt eine riesige Sammlung in seiner Standardbibliothek mit. Sie besteht aus zahlreichen Paketen, zum Beispiel:
- fmt: Implementiert formatierte E/A mit Funktionen analog zu C ( printf und scanf ).
- http: Dieses Paket bietet Funktionen zum Erstellen von Webdiensten, zum Senden und Empfangen von Daten über das http -Protokoll usw.
Um ein Paket in ein Go-Projekt einzubinden, muss es mit der import-Anweisung implementiert werden. Die Anweisung wird durch das Schlüsselwort import zusammen mit den Namen der Pakete deklariert. Um beispielsweise math/rand zu importieren, würde die Import-Anweisung so aussehen:
|
1 |
import "math/rand" |
Der folgende Code implementiert verschiedene Funktionen aus dem Paket math/rand:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main import "math/rand" func main() { for i := 0; i < 10; i++ { println(rand.Intn(25)) } } |
Dieser Code zeigt eine einfache for-Schleife, die 10 Zufallszahlen (0 bis 24) auf dem Bildschirm ausgibt. Hierbei gilt:
- rand.Int() : Dieser Funktionsaufruf gibt eine zufällige Ganzzahl zurück.
- rand.Intn() : Verhält sich ähnlich wie rand.Int() , akzeptiert jedoch einen Parameter, der den Bereich für die Zufallszahlen definiert (von 0 bis zur angegebenen Zahl).
Führen Sie als Nächstes den Code aus:
|
1 |
go run practice.go |
Die Ausgabe wird wie folgt aussehen:
Beachten Sie, dass die Ausgabe genau dieselbe sein wird, da der Startwert (Seed) für den Zufallszahlengenerator standardmäßig ein fester Wert ist. Dies liegt in der Natur eines Pseudorandom-Nummern-Generators. Sie können hier mehr über Random Seeds erfahren.
Step 4 – Importieren mehrerer Pakete
Größere und komplexere Projekte müssen mehrere Pakete einbinden. Wie importiert man diese in den Go-Code? Eine gültige Option ist die Verwendung einzelner Import-Anweisungen für jedes importierte Paket. Dieser Ansatz ist jedoch im Vergleich zur folgenden Importstruktur ineffizient:
|
1 2 3 4 5 6 7 8 9 |
import ( "<package_1>" "<package_2>" "<package_3>" ) |
Hier bindet eine einzige Import-Anweisung mehrere Pakete gleichzeitig ein. Dies reduziert die Menge des zu schreibenden Codes und verbessert gleichzeitig die Lesbarkeit.
Der folgende Code setzt diese Funktion in die Praxis um:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main import ( "fmt" "math/rand" ) func main() { for i := 0; i < 10; i++ { fmt.Printf("%d) %d\n", i, rand.Intn(25)) } } |
Führen Sie den Code aus:
|
1 |
go run practice.go |
Die Ausgabe wird in etwa so aussehen:
Step 5 – Installieren zusätzlicher Go-Bibliotheken
Die Standardbibliothek von Go wird mit zahlreichen nützlichen Paketen ausgeliefert. Diese sind vom Konzept her universell einsetzbar. Sie ermöglicht es Entwicklern, eigene Pakete auf der Standardbibliothek aufzubauen, um ihre spezifischen Anforderungen zu erfüllen. Schauen Sie sich die offizielle Go-Paketdatenbank an.
Was ist, wenn Sie ein Go-Paket eines Drittanbieters implementieren müssen? Go wird mit dem Befehl go install ausgeliefert ( go get ist veraltet). Er kann jedes Go-Paket eines Drittanbieters aus dem Internet abrufen.
Zur Demonstration werden wir das Paket cobra-cli installieren. Der folgende Go-Befehl lädt die erforderlichen Dateien herunter, installiert sie und integriert das Paket in das Go-Bibliothekssystem:
|
1 |
go install github.com/spf13/cobra-cli@latest |
Die Binärdatei von cobra-cli sollte sich an folgendem Ort befinden:
|
1 |
ls -l $GOPATH/bin |
Die anderen Paketdateien sollten sich an folgendem Ort befinden:
|
1 |
ls -l $GOPATH/pkg/mod/github.com/spf13 |
Ab Go v1.11 definieren Go-Module die Version des Pakets, das Sie importieren möchten. Dies wird hier im Detail erklärt: Go-Module GitHub.
Step 6 – Paket-Aliase
In verschiedenen Situationen kann es zu Namenskonflikten zwischen lokalen und importierten Paketen kommen. Hier kann die Verwendung von Aliasen den Konflikt lösen. Die Alias-Struktur sieht in etwa so aus:
|
1 |
import <alias> "import_package_name" |
Lassen Sie uns unser einfaches Go-Programm so ändern, dass es fmt_alias als Alias für das Paket fmt :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main import ( fmt_alias "fmt" "math/rand" ) func main() { for i := 0; i < 10; i++ { fmt_alias.Printf("%d) %d\n", i, rand.Intn(25)) } } |
Beachten Sie, dass wir anstelle von fmt.Printf() , den Paket-Alias fmt_alias.Printf() .
Go ist jedoch nicht besonders aufgeschlossen gegenüber Aliasen. Wenn Sie Aliase verwenden, um Namenskollisionen beim Import zu vermeiden, wird empfohlen, dem lokalsten oder projektspezifischsten Import einen Alias zuzuweisen. Wenn Sie beispielsweise sowohl ein lokales Paket strings als auch ein Systempaket strings haben möchten, sollten Sie dem lokalen Paket einen Alias zuweisen, nicht dem Systempaket.
Die beste Praxis ist es, Namenskollisionen von vornherein zu vermeiden.
Step 7 – Formatierung von Importen
Wir haben gelernt, alle Importe mit einer einzigen import -Anweisung zu deklarieren. Was wäre, wenn Sie mehrere Importe hätten? Zum Beispiel:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import ( "fmt" "os" "github.com/example/foo" "github.com/example/bar" "math/rand" "github.com/abc/pqr/xyz" ) |
Die Formatierung von Imports sortiert die Pakete in eine bestimmte Reihenfolge, was die Konsistenz des Codes verbessert. Da sie nur die Reihenfolge der Imports sortiert, verhindert sie auch zufällige Commits. Zudem beugt sie unnötigen Code-Änderungen (Code Churn) und unübersichtlichen Code-Reviews vor.
Die meisten modernen Editoren formatieren die Imports automatisch für Sie. Alternativ unterstützen sie goimports. Es ist in der Branche eine gängige Praxis, goimports zu verwenden, anstatt die Imports manuell zu sortieren. Darüber hinaus goimports spiegelt auch Stiländerungen im Code wider.
So sieht der import -Block nach dem Anwenden von goimports aus :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import ( fmt_alias "fmt" "math/rand" "os" "github.com/example/foo" "github.com/example/bar" "github.com/abc/pqr/xyz" ) |
Fällt Ihnen ein Muster auf?
- Alle Standardbibliotheken werden zuerst gruppiert.
- Die Gruppen sind durch Leerzeilen getrennt, was die Lesbarkeit des Codes verbessert.
Fazit
Imports in Go sind eine leistungsstarke Funktion, die es ermöglicht, Funktionen aufzurufen, die nicht in Go integriert sind. Während die Standardbibliothek viele Allzweck-Pakete bietet, unterstützt Go auch Pakete von Drittanbietern. Diese Anleitung zeigt das Importieren von integrierten Go-Paketen und Paketen von Drittanbietern.
In dieser Anleitung haben wir unsere Go-Programme mit dem Interpreter ausgeführt. Sie können den Code jedoch für eine bessere Leistung in eigenständige Binärdateien kompilieren. Mehr über das Kompilieren von Go-Programmen erfahren Sie hier. Wenn Sie lernen möchten, wie Sie eine Go-Webanwendung mit Nginx bereitstellen, finden Sie in diesem Tutorial. Darüber hinaus können Sie einen Blick auf unseren Leitfaden werfen, der zeigt, wie Sie Ihre eigenen Go-Pakete schreiben.
Sind Sie Go-Entwickler? CloudSigma bietet Go-API-Unterstützung für eine nahtlose Integration in Ihre Projekte.
Frohes Schaffen!
Kommentare
Noch keine Kommentare. Schreiben Sie den ersten.