Go ist eine statisch typisierte Programmiersprache mit starker Unterstützung für Nebenläufigkeit. Es wird von Google unterstützt und ist für allgemeine Projekte wie die Entwicklung von Systemanwendungen oder Web-Apps gedacht. Golang wird aufgrund seines robusten Funktionsumfangs und der Unterstützung der neuesten Programmierpraktiken immer beliebter. Eine große Anzahl von Unternehmen suchen aktive Go-Entwickler aufgrund der zunehmenden Verwendung in modernen Anwendungen. Entwickler können eine Reihe von go-Befehlen verwenden, um ihre Programmierproduktivität oder ihr Workflow-Management zu steigern. In diesem Leitfaden werden wir einige dieser Befehle für angehende Go-Entwickler besprechen.
Nützliche Go-Befehlsbeispiele in Linux
Go bietet eine Reihe nützlicher Tools zum Verwalten des Build-Prozesses und des Workflows für Programmierer. Sie werden über eine Reihe einfacher Befehle aufgerufen, die direkt in go integriert sind. Im folgenden Abschnitt stellen wir 40 solcher nützlichen Befehle vor.
1. Erstellen Sie ein Programm
Mit dem Befehl go build können Entwickler die ausführbare Binärdatei für ein bestimmtes Programm erstellen. Wir haben ein einfaches Serverprogramm namens server.go erstellt, um dies zu demonstrieren. Jetzt werden wir dieses Programm mit go build erstellen.
$ go build server.go
Dieser Befehl erstellt eine binäre ausführbare Datei namens server in unserem go-Arbeitsverzeichnis. Den Code für das Serverprogramm finden Sie in diesem Abschnitt der Golang-Website. Jetzt können wir das Programm wie jedes andere Linux-Befehlszeilentool ausführen.
$ ./server
2. Führen Sie ein Programm aus, ohne es zu erstellen
Entwickler nehmen normalerweise schrittweise Änderungen an ihren Programmen vor, die auf Tests basieren. Es ist unbequem, das Programm jedes Mal zu erstellen, wenn Sie eine geringfügige Änderung vornehmen. Glücklicherweise erlaubt uns go, ein Programm auszuführen, auch ohne es überhaupt zu bauen.
$ go run server.go- -
Dieser Befehl führt das Programm direkt aus, ohne dass Sie den Quellcode erstellen müssen. Es ist äußerst nützlich, wenn Sie mit kleineren Unterprogrammen herumspielen.
3. Aktuellen GOPATH anzeigen
Go verwaltet die Quellcodes, Objekte und Binärdateien eines Programms mithilfe des Go-Arbeitsbereichs. Das Stammverzeichnis dieses Arbeitsbereichs wird mithilfe von GOPATH angegeben Variable. Sie können den aktuellen Pfad zu Ihrem Go-Arbeitsbereich finden, indem Sie den folgenden Befehl verwenden.
$ go env GOPATH
Hier müssen Sie Ihre Quelldateien ablegen und kompilieren. Obwohl Sie mehrere Go-Arbeitsbereiche einrichten können, wird empfohlen, einen einzelnen Arbeitsbereich zu verwenden. Der Unterbefehl env bietet auch viele andere Informationen, wie wir später sehen werden.
4. Neuen GOPATH festlegen
Ab Go-Version 1.8 spezifizieren Unix-Systeme das $HOME/go Verzeichnis als Standard-GOPATH. Sie können dies jedoch mit dem folgenden einfachen Befehl leicht an einen anderen Ort ändern.
$ go env -w GOPATH=$HOME/projects/go
Dadurch wird Ihr GOPATH zu $HOME/projects/go geändert . Sie können den GOPATH auch festlegen, indem Sie die folgende Zeile zu Ihrem ~/.bash_profile hinzufügen . Öffnen Sie einfach die Datei mit Ihrem bevorzugten Linux-Texteditor und hängen Sie die nächste Zeile am Ende an.
export GOPATH=$HOME/projects/go
Nachdem Sie die Datei gespeichert haben, beenden Sie sie und führen Sie den folgenden Befehl aus, um die Änderungen widerzuspiegeln.
$ source ~/.bash_profile
5. Go-Pakete installieren
Jedes go-Programm, das Sie schreiben oder verwenden, ist Teil eines go-Pakets. Go-Pakete sind nichts anderes als ein Verzeichnis, das einige go-Dateien innerhalb von /src enthält Verzeichnis. Wir können go-Pakete sehr einfach installieren, indem wir den Befehl go install verwenden.
$ go install test-app
Wenn Sie diesen Befehl ausführen, sucht go zuerst nach dem Verzeichnis test-app in $GOROOT/src und dann in $GOPATH/src . Sobald es gefunden wurde, ermittelt go den Einstiegspunkt des Pakets, indem es in den Quelldateien nach dem Paket main sucht. Go wird dann mit der Installation dieses Pakets fortfahren und die Test-App-Binärdatei in /bin ablegen Verzeichnis Ihres Arbeitsbereichs.
6. Pakete herunterladen und installieren
Golang erfreut sich bei einer großen Anzahl von FOSS-Entwicklern wachsender Beliebtheit. Infolgedessen werden viele nützliche Programme mit go geschrieben. Sie können ganz einfach ein Go-Paket eines Drittanbieters herunterladen und mit dem folgenden einfachen Befehl installieren.
$ go get host/example-project $ go get github.com/fatih/color
Dieser Befehl lädt das beliebte Farbpaket zusammen mit all seinen Abhängigkeiten herunter und installiert es. Sie können das Paket auch in Zukunft aktualisieren, indem Sie -u verwenden Flagge, wie unten gezeigt.
$ go get -u github.com/fatih/color
7. Pakete neben Abhängigkeiten auflisten
Ihr Go-Arbeitsbereich wird mit der Zeit größer und kann Pakete enthalten, die nicht mehr benötigt werden. Sie können alle installierten go-Pakete sowie deren Abhängigkeiten auflisten. Dies hilft Ihnen bei der Bestimmung, welche Pakete aus Ihrem Arbeitsbereich entfernt werden sollen.
$ go list
Dieser go-Befehl erfordert einen Importpfad und liefert Informationen zu einem bestimmten Paket. Um Informationen zu allen installierten Paketen zu erhalten, müssen Sie einen speziellen Platzhalter verwenden.
$ go list ./...
Führen Sie diesen Befehl von Ihrem GOPATH aus und go zeigt alle Pakete an, die in Ihrem Arbeitsbereich installiert sind.
8. Go-Pakete reparieren
Wenn Sie Ihre Go-Version aktualisieren, können Programme, die ältere Funktionen verwenden, beschädigt werden. Go bietet ein praktisches Tool, um diese Programme zu reparieren und sie neu zu schreiben, um neuere Funktionen der Sprache zu verwenden. Dazu müssen Sie den Befehl go fix verwenden.
$ go fix app/app.go
Dieser Befehl schreibt die Datei app.go neu, um neuere Go-APIs und -Funktionen aufzunehmen. Verwenden Sie den folgenden Befehl, um ganze Anwendungen zu reparieren.
$ go tool fix app/
9. Go-Objekte entfernen
Go erstellt während der Programmerstellung Objektdateien und speichert sie in einem temporären Verzeichnis. Außerdem erstellen viele Go-Tools auch verschiedene Objekte, die Speicherplatz beanspruchen. Sie werden die ungenutzten Objekte im Laufe der Zeit loswerden wollen.
$ go clean
Es entfernt alle Go-Objekte, die vor der Ausführung dieses Befehls erstellt wurden. Verwenden Sie den folgenden Befehl, um alle Objekte für ein bestimmtes Paket zu entfernen.
$ go clean -i app/
Das -i Die Option clean löscht auch alle entsprechenden Binärdateien oder Archive.
10. Umgebungsinformationen anzeigen
Programmierer können leicht Informationen zu verschiedenen Go-Umgebungsvariablen finden. Der Befehl go env kann verwendet werden, um alle go-Umgebungsvariablen in Ihrem Linux-Terminalemulator anzuzeigen.
$ go env
Es werden alle Go-Variablen ausgegeben, egal ob ihre Werte gesetzt sind oder nicht. Um den Wert einer bestimmten go-Variablen zu drucken, verwenden Sie das folgende Format.
$ go env VARIABLE $ go env GOCACHE
Wir haben den GOPATH früher mit der obigen Syntax gedruckt. Es ist nützlich, um bestimmte Umgebungsvariablen abzurufen.
11. Fehlerberichte erstellen
Go ist eine relativ neue Sprache und führt ziemlich oft neue Funktionen ein. Obwohl es sehr sorgfältig entwickelt wurde, können Sie manchmal auf unerwünschte Fehler oder Probleme stoßen. Glücklicherweise ist es sehr bequem, Fehlerberichte für die Go-Laufzeit zu erstellen.
$ go bug
Wenn Sie den obigen Befehl ausführen, wird Ihr Standardbrowser geöffnet und ein Fehlerbericht im offiziellen GitHub-Repository von Go erstellt. Es fügt alle wesentlichen Informationen wie Systeminformationen sowie Go-Konfigurationen hinzu.
12. Paketquellen neu formatieren
Die Go-Laufzeit macht die Formatierung für Entwickler äußerst bequem. Sie können einfach Ihren Linux-Code-Editor starten und mit dem Schreiben von Code beginnen, ohne über Einrückungen oder Ausrichtungen nachdenken zu müssen. Wenn Sie fertig sind, verwenden Sie den folgenden go-Befehl, um Ihren Code gemäß Gos Empfehlung zu formatieren.
$ go fmt [packages] $ go fmt server.go
Der zweite Befehl formatiert die Datei server.go. Sie können auch ein Verzeichnis übergeben, das eine Reihe von go-Dateien enthält, um sie alle zu formatieren. Go verwendet Tabulatoren für Einrückungen und Leerzeichen für Codeausrichtungen.
13. Module verwalten
Alle Go-Befehle haben vorgefertigte Unterstützung für Module. Module in Go sind nichts anderes als eine Sammlung mehrerer go-Pakete. Das go.mod enthält alle Pakete von Drittanbietern für eine Go-Anwendung. Sie können diese Datei einfach mit dem folgenden Befehl erstellen.
$ go mod <command> [arguments] $ go mod init app
Dieser Befehl erstellt eine go.mod Datei für unser benutzerdefiniertes App-Paket. Es enthält den Modulnamen sowie die Go-Versionsinformationen. Das Mod-Dienstprogramm nimmt neben init verschiedene andere Befehle entgegen . Geben Sie Folgendes ein, um die verfügbaren Optionen anzuzeigen.
$ go help mod
14. Generieren Sie Go-Dateien
Golang ermöglicht es Entwicklern, Go-Quelldateien zu erstellen oder zu aktualisieren, indem sie Anweisungen innerhalb vorhandener Quellen verwenden. Dazu wird der Generate-Befehl verwendet. Obwohl generate zum Erstellen oder Aktualisieren von Go-Dateien gedacht ist, kann es auch für andere Aufgaben verwendet werden.
$ go generate [-run regexp] [-n] [-v] [-x] [build flags] [file.go... | packages]
Wenn Sie go generate ausführen, wird es in Ihren go-Quelldateien nach Anweisungen im folgenden Format suchen.
//go:generate command argument...
Generate führt den Befehl aus, sobald es die Direktive in Ihrer Go-Quelle findet. Beachten Sie, dass vor oder innerhalb von „//go keine Leerzeichen stehen dürfen “.
15. Paketabhängigkeiten aktualisieren
Zuvor haben wir gezeigt, wie Pakete mit dem Dienstprogramm go get installiert oder aktualisiert werden. Wenn Sie jedoch an größeren Projekten arbeiten, müssen Sie häufig Ihre Paketabhängigkeiten aktualisieren. Der folgende Befehl aktualisiert alle Go-Pakete, die sich in Ihrem GOPATH befinden.
$ go get -u all
Sie sollten jedoch unterschiedliche GOPATH für unterschiedliche Projekte verwenden. Dadurch wird sichergestellt, dass das Aktualisieren von Paketen in Projekt A Projekt B nicht beschädigt. Sie können ein Paket auch auf eine bestimmte Version aktualisieren, indem Sie das Suffix „@ verwenden ‘.
$ go get [email protected]
16. Testpaket-Upgrades
Stellen Sie nach Abschluss des Upgrades sicher, dass alle Ihre alten Projekte einwandfrei funktionieren. Sie können dazu den folgenden einfachen Befehl von Ihrem Terminal aus verwenden.
$ go test all
Dieser Befehl prüft, ob die Anwendungen nach den Paketaktualisierungen wie erwartet funktionieren. Sie können auch ein einzelnes Projekt testen, indem Sie den Importpfad des Projekts angeben.
$ go test app/
Dadurch werden zusammengefasste Informationen zu den Testergebnissen angezeigt.
17. Finden Sie Fehler in Paketen
Go bietet ein flexibles Tool zum Auffinden unerwarteter Fehler oder Fehler in Ihrer Quelldatei. Der Befehl go vet verwendet Heuristiken, um verdächtige Verwendungen von Konstrukten zu finden, die häufig zu tatsächlichen Fehlern führen. Der folgende Befehl überprüft das Paket, das sich im aktuellen Verzeichnis befindet, auf solche Fehler.
$ go vet
Sie können die Pakete auch mithilfe des Importpfads angeben, wie im folgenden Beispiel gezeigt.
$ go vet app/
Verwenden Sie den folgenden Befehl, um weitere Informationen zu vet und den verfügbaren Optionen zu erhalten.
$ go doc cmd/vet
18. Laden Sie Module in den Cache herunter
Sie können Go-Module in Ihren lokalen Cache herunterladen. Dies ist sehr nützlich, wenn Sie an größeren Projekten arbeiten, und erleichtert mit der Zeit App-Updates. Der Befehl dafür sieht wie folgt aus.
$ go mod download [-x] [-json] [modules]
Übergeben Sie einfach den Modulnamen, wie unten gezeigt.
$ go mod download example-project/app
Seit Go Version 1.11 werden die heruntergeladenen Module in $GOPATH/pkg/mod gespeichert . Das -x Optionen zeigen an, welche Befehle beim Mod-Download ausgeführt werden. Die -json Flag gibt eine Reihe von JSON-Objekten aus, die das heruntergeladene Modul in der Terminalausgabe beschreiben.
19. Modulabhängigkeiten pflegen
Mit dem Befehl go mod tidy können wir fehlende Abhängigkeiten hinzufügen oder nicht verwendete Module löschen. Dieser go-Befehl hilft dabei, Modulabhängigkeiten aufrechtzuerhalten und Ihre Anwendungen so schlank wie möglich zu halten. Führen Sie dazu einfach den folgenden einfachen Befehl aus.
$ go mod tidy [-v]
Stellen Sie sicher, dass Sie dies aus dem Stammverzeichnis Ihres Projekts ausführen. Sie können in der Datei go.mod nachsehen, welche Abhängigkeiten hinzugefügt oder gelöscht wurden. Das -v Wenn verwendet, bewirkt das Flag, dass Tidy anzeigt, welche Module zum Standardfehler entfernt wurden.
20. Vom Anbieter bereitgestellte Kopie von Abhängigkeiten erstellen
Go ermöglicht es Entwicklern, eine vom Anbieter bereitgestellte Kopie der Modulabhängigkeiten zu erstellen. Dadurch wird einfach das Herstellerverzeichnis des Hauptmoduls zurückgesetzt und alle Pakete eingeschlossen, die zum Erstellen oder Testen von Paketen im Hauptmodul erforderlich sind.
$ go mod vendor [-v]
Der obige Befehl erstellt eine vom Hersteller bereitgestellte Kopie der Abhängigkeiten des Hauptmoduls. Wenn Sie die Option -v verwenden, werden die Namen der angebotenen Module und Pakete für die Standardfehlermeldung des Systems angezeigt.
21. Modulabhängigkeiten überprüfen
Programmierer können leicht überprüfen, ob alle Abhängigkeiten der aktuellen Module den erwarteten Inhalt haben oder nicht. Der Befehl „go mod“ verify überprüft, ob Abhängigkeiten im lokalen Cache seit dem Download geändert wurden. Der Befehl hat das folgende Format.
$ go mod verify
Der obige Befehl druckt „alle verifizierten Module“. ‘ wenn die Modulabhängigkeiten unverändert sind. Andernfalls wird es melden, welche Module geändert wurden, und einen Nicht-Null-Ausgang verursachen. Dieses einfache Tool kann Entwicklern dabei helfen, die Integrität ihrer Abhängigkeiten zu bestimmen.
22. Zeigen Sie an, warum Pakete/Module benötigt werden
Sie können in Ihrer Anwendung sehen, warum bestimmte Module oder Pakete erforderlich sind. Dies ist nützlich, wenn Sie mit dem Code einer anderen Person arbeiten oder herausfinden möchten, was bestimmte Dinge in einem bestimmten Projekt tun. Der „Why“-Befehl des Mod-Tools ermöglicht uns dies.
$ go mod why [-m] [-vendor] packages... $ go mod why golang.org/x/text/language golang.org/x/text/encoding
Die erste ist die allgemeine Syntax und die zweite ist ein Beispiel. Es gibt aus, warum die Sprache und Codierung Pakete sind in Ihrer Anwendung erforderlich.
23. Go-Binärdateien zerlegen
Wenn Sie Go für die Systemprogrammierung oder intensive Anwendungen wie Spiele verwenden, müssen Sie Ihre ausführbaren Dateien von Zeit zu Zeit analysieren. Go bietet eine Reihe von Tools zum Analysieren von Binärdateien. In diesem Beispiel sehen wir uns den objdump-Befehl an. Es disassembliert ausführbare go-Dateien und funktioniert wie der objdump-Befehl von Linux.
$ go tool objdump [-s symregexp] binary
Dies ist die unterstützte Syntax für objdump. Sie müssen das Dienstprogramm go tool verwenden, um objdump zu verwenden. Der folgende Befehl zerlegt eine Go-Binärdatei namens server.go.
$ go tool objdump ./server
Sie können die Disassemblierung auf bestimmte Symbole beschränken, indem Sie die Option -s verwenden. Es werden nur die Symbole zerlegt, deren Name mit symregexp übereinstimmt . Normalerweise möchten Sie die Ausgabe für eine detaillierte Überprüfung speichern.
$ go tool objdump ./server > disassembled-data
24. Exportierte API für Pakete anzeigen
Sie können die von einer Reihe von Go-Paketen exportierten APIs einfach anzeigen. Dazu müssen Sie das API-Tool des go-Befehls verwenden. Sehen Sie sich den folgenden Befehl genau an, um zu sehen, wie das funktioniert.
$ go tool api
Dadurch werden die APIs für Ihre go-Pakete in der Standardausgabe ausgegeben. Leiten Sie die Ausgabe in eine Datei um, wenn Sie die Ausgabe dieses Befehls speichern möchten.
25. Verwenden Sie Go Assembler
Go verfügt über einen integrierten Assembler, mit dem Entwickler Objektdateien aus Assembler-Quellcode erstellen können. Obwohl Sie die Assemblierung selten mit go verwenden werden, schadet es nicht, dies tun zu können. Schreiben Sie einfach den Assembler-Code in Ihr go-Paket. Sie können dann den Go-Assembler aufrufen, wie unten gezeigt.
$ go tool asm test.s $ go tool asm new-test.asm
Normalerweise verwenden Systemprogrammierer Assembler, um die Leistung eines kritischen Codeabschnitts zu steigern. Sogar go implementiert einen Teil des mathematischen Pakets mithilfe von Assembler, wie z. B. die Pi-Berechnung.
26. Build-ID der Binärdateien drucken
Die Build-ID einer ELF-Binärdatei ist eine eindeutige Darstellung der Build-Informationen. Go bietet ein einfaches Dienstprogramm zum Anzeigen dieser Informationen direkt von Ihrem Terminal aus. Sehen Sie sich das folgende Beispiel an, um zu sehen, wie das funktioniert.
$ go tool buildid server
Dadurch wird die Build-ID der ausführbaren Binärdatei namens Server ausgegeben. Dies wird erstellt, wenn Sie die Binärdatei über go build oder andere Build-Tools generieren. Sie können es mit der Ausgabe des Dateibefehls abgleichen. Führen Sie den folgenden Befehl aus und suchen Sie nach dem Abschnitt Go BuildID.
$ file server
27. Verwenden Sie das CGO-Tool
Ein Hauptmerkmal von Go ist seine Interoperabilität mit C-Codebasen. Sie können C-Codes in Go-Quellen verwenden und umgekehrt. Sie können dann die Binärdatei generieren, indem Sie den üblichen Go-Build verwenden oder aus dem Stammverzeichnis Ihres Pakets installieren. Alternativ können Sie cgo verwenden Werkzeug der Go-Laufzeit.
$ go tool cgo [cgo options] [-- compiler options] gofiles...
$ go tool cgo app/ccode.go
Konsultieren Sie die folgende Dokumentation, um zu sehen, welche Optionen für cgo verfügbar sind.
$ go doc cmd/cgo
28. Verwenden Sie Go Compile
Standardmäßig erstellt der Befehl go build oder run keine Objektdateien. Sie können das Kompilierdienstprogramm des go-Befehls verwenden, um eine Objektdatei zu generieren. Es funktioniert nur, wenn Sie das Go-Tool verwenden, wie im folgenden Beispiel dargestellt.
$ go tool compile server.go
Dieser Befehl erstellt eine ausführbare Binärdatei namens server sowie eine Objektdatei namens server.o. Das Kompilierprogramm bietet auch eine Fülle nützlicher Funktionen. Sie können einen detaillierten Überblick über die Kompilierung erhalten, indem Sie den folgenden Befehl ausführen.
$ go doc cmd/compile
29. Verwenden Sie Go Dist
Das Dienstprogramm dist ermöglicht es Entwicklern, die Go-Laufzeit von ihrem Terminal aus zu booten, zu erstellen und zu testen. Es hat die folgende Syntax.
$ go tool dist [command]
Einige der verfügbaren Befehle sind banner, bootstrap, clean, list, env und version. Sie können eine Liste aller unterstützten Befehle finden, indem Sie Folgendes ausführen.
$ go doc cmd/dist
Beispielsweise druckt das folgende Snippet das Go-Installationsbanner mit dem dist-Tool.
$ go tool dist banner
Verwenden Sie den folgenden Befehl, um alle unterstützten Plattformen für Go aufzulisten. Es wird eine JSON-Ausgabe angezeigt, die das Betriebssystem, die Architektur und die CGO-Unterstützung angibt.
$ go tool dist list -json
30. Verwenden Sie das Gofmt-Tool
Gofmt ist ein weiteres Dienstprogramm zur Quellformatierung von Go. Es funktioniert ganz ähnlich wie fmt . Wenn Sie go fmt verwenden, wird dies tatsächlich unter der Haube aufgerufen. Gofmt hat die folgende Syntax.
$ gofmt [flags] [path ...]
Beispielsweise formatiert der folgende Befehl die Quelldatei test.go neu und gibt sie auf der Standardausgabe aus. Wenn Sie anstelle eines Dateinamens einen Pfadnamen angeben, versucht gofmt, alle .go-Dateien in diesem Verzeichnis neu zu formatieren.
$ gofmt test.go
Im Gegensatz zu fmt schreibt gofmt die Änderungen nicht in die Originaldatei zurück. Sie müssen das -w verwenden Flagge dafür. Verwenden Sie den folgenden Befehl, um eine Liste aller verfügbaren Flags zu erhalten.
$ go doc cmd/gofmt
31. Verwenden Sie das Link-Tool
Das Link-Dienstprogramm liest das go-Archiv oder -Objekt für ein Paket main und erstellt eine binäre ausführbare Datei, die alle seine Abhängigkeiten enthält. Es wird mit dem Go-Tool aufgerufen und hat die folgende Syntax.
$ go tool link [flags] main.a
Der folgende Befehl kombiniert beispielsweise die Datei server.o mit ihren Abhängigkeiten und spuckt eine Binärdatei aus.
$ go tool link server.o
Link unterstützt eine große Anzahl von Flags, mit denen Entwickler den Build-Prozess verwalten oder steuern können. Sie können eine detaillierte Liste davon finden, indem Sie den folgenden Befehl ausführen.
$ go doc cmd/link
32. Symbolliste drucken
Sie können die Liste der Symbole drucken, die in einer Objektdatei, einem Archiv oder einer ausführbaren Datei enthalten sind, indem Sie das Werkzeug go nm verwenden. Symbole sind einfach Namen von globalen Objekten, wie z. B. Methoden, die von einer Objektdatei verwendet werden. Die Syntax dieses Befehls ist unten dargestellt.
$ go tool nm [options] file...
$ go tool nm server.o
Die Ausgabe gibt jedes Symbol in einer neuen Zeile aus. Sie sind durch drei durch Leerzeichen getrennte Felder getrennt, die die Adresse, den Typ und den Symbolnamen darstellen. Sie können die Liste der Symboltypen auf dieser Seite der Go-Dokumentation anzeigen. Zu den Optionen gehören Größe, Typ, Sortierung und Anzahl.
33. Go-Archive verwalten
Mit Go können Entwickler Archive erstellen, ändern oder extrahieren. Das go-Tool nm ermöglicht uns solche binären Operationen. Es ist eine grundlegende Simulation des traditionellen ar-Tools in Unix. Die Syntax für diesen Befehl ist unten dargestellt.
$ go tool pack op file.a [name...]
Das op steht für Operationen. Pack erlaubt mehrere Operationen, darunter das Erstellen eines Archivs, das Hinzufügen zum Archiv und das Extrahieren.
$ go tool pack r server.a server.o
Dieser Befehl hängt die Datei server.o an das Archiv server.a an. Sie können die Liste aller verfügbaren OP-Codes anzeigen, indem Sie den folgenden Befehl ausführen.
$ go doc cmd/pack
34. Profildaten anzeigen
Go verfügt über eine hervorragende Profilerstellungsunterstützung. Wenn Sie ressourcenintensive Anwendungen entwickeln oder für Maschinen mit niedrigen Spezifikationen programmieren, hilft Ihnen die Profilerstellung dabei, die Leistung erheblich zu steigern. Das Dienstprogramm pprof des go-Befehls ermöglicht es uns, Profiling-Daten anzuzeigen und zu interpretieren.
$ go tool pprof binary profile $ go tool pprof ./app cpu.prof
Sie können sowohl mit CPU- als auch mit Speicherprofilen arbeiten. Darüber hinaus ermöglicht pprof Entwicklern auch die Remote-Analyse von Profildaten über das Internet. Obwohl Go-Programmieranfänger die API vielleicht etwas kompliziert finden, fanden wir, dass der Leistungsgewinn die Lernkurve wert ist.
35. Trace-Dateien anzeigen
Go bietet eine hervorragende Parallelitätsunterstützung über Goroutinen. Wir sehen jedoch oft Entwickler, die nebenläufigen Code schreiben, der ihren Programmen kaum zugute kommt. Dies geschieht aufgrund einer ineffektiven Parallelisierung, die Latenz, Konflikte und andere Leistungsprobleme verursacht. Glücklicherweise können Sie das Go-Trace-Dienstprogramm verwenden, um zu visualisieren, wie Ihre Goroutinen funktionieren.
$ go tool trace trace.out
Dieser Befehl zeigt die Ablaufverfolgungsdatei trace.out für ein bestimmtes Programm an, die auf mehrere Arten generiert werden kann. Sie können den Go-Test verwenden Befehl, runtime/trace.Start , oder net/http/pprof Paket zum Erstellen einer Ablaufverfolgungsdatei für Ihre Anwendung. Sehen Sie sich diesen Link an, um mehr darüber zu erfahren.
36. Konvertieren Sie die Testausgabe in JSON
Das go-Befehlszeilendienstprogramm bietet eine effektive Möglichkeit, die Testausgabe in JSON zu konvertieren. Sie können diese JSON-Ausgabe zur späteren Überprüfung speichern oder zur weiteren Verarbeitung verwenden. Der folgende Befehl zeigt uns, wie dies mit dem test2json-Dienstprogramm von Golang gemacht wird.
$ go tool test2json [-p pkg] [-t] [./pkg.test -test.v]
$ go tool test2json -p example.go -t example_test.go
Die erste Zeile enthält die Syntax für test2json Befehl, während der zweite ein funktionierendes Beispiel ist. Die JSON-Ausgabe wird direkt in der Konsole angezeigt. Sie können diese Daten einfach speichern, indem Sie eine einfache Weiterleitung verwenden.
37. Verwenden Sie das Addr2line-Tool
Go bietet eine minimale Simulation des GNU-Tools addr2line mittels des go-Befehls addr2line. Es übersetzt Adressen in Zeilennummern in Ihrem Programm. Es kann für Systemprogrammierer und Debugger wirklich von Vorteil sein.
$ go tool addr2line binary
Wenn dieser Befehl auf diese Weise aufgerufen wird, liest er Hex-Adressen. Für jede Adresse werden der Funktionsname und die dieser Adresse entsprechende Zeilennummer angezeigt. Weitere Informationen zu diesem Tool finden Sie mit dem folgenden Befehl.
$ go doc cmd/addr2line
38. Hilfeseite anzeigen
Die Hilfeseite von go enthält zusammengefasste Informationen zu Standard-go-Befehlen. Es ist nützlich, um schnell die Verwendung und Syntax alltäglicher Befehle nachzuschlagen. Sie können die Hilfeseite aufrufen, indem Sie einen der folgenden einfachen Befehle ausführen.
$ go help $ go --help
Darüber hinaus können Sie auch Informationen für einen bestimmten Befehl drucken, indem Sie die folgende Syntax verwenden.
$ go help <topic> $ go help install
39. Go-Dokumentation anzeigen
Go bietet eine ausführliche Dokumentation für die Laufzeitdienstprogramme sowie Standardbefehle. Diese sind äußerst nützlich, wenn Sie die Grundlagen von Golang beherrschen und die besten Praktiken erlernen möchten. Sie können die Dokumentation auf eine der folgenden Arten aufrufen.
$ man go
Dadurch wird ein grundlegendes Handbuch für Go gedruckt. go stellt jedoch für jeden Befehl eigene Handbücher zur Verfügung. Sie können detaillierte Informationen für einen bestimmten Befehl finden, indem Sie Folgendes ausführen.
$ man go-<topic> $ man go-install
Um auf die Dokumentation für verschiedene Go-Tools zuzugreifen, verwenden Sie den Befehl go doc. Der folgende Befehl zeigt die Dokumentation für das Dienstprogramm go link an.
$ go doc cmd/link
40. Versionsinformationen anzeigen
Golang ist eine relativ neue Sprache, und daher kommt es sehr häufig vor, dass es Unterschiede zwischen verschiedenen Versionen gibt. Viele Funktionen stehen älteren go-Versionen gar nicht zur Verfügung. Sie müssen also sicherstellen, dass Ihre Go-Installation die Anforderungen für bestimmte Funktionen erfüllt.
$ go version
Der obige Befehl zeigt Ihnen, welche Version der Go-Laufzeit auf Ihrem Computer installiert ist. Sie können dies verwenden, um sicherzustellen, dass Ihr Code in der Produktionsumgebung genauso funktioniert wie auf Ihrem Entwicklungscomputer.
Abschlussgedanken
Golang erfreut sich aufgrund seines robusten Funktionsumfangs und seiner Leistung großer Beliebtheit. Tech-Giganten wie Google und Netflix verwenden Go, um ihre Flaggschiff-Anwendungen zu erstellen. Einer der Hauptgründe für die anhaltende Popularität von Go ist seine Standard-Toolchain. Die Standard-Utilities sind selbst für die größten Projekte oft mehr als ausreichend. Und sie sind mit einfachen Go-Befehlen leicht zugänglich. In diesem Handbuch haben wir alle wichtigen Befehle beschrieben, die Sie benötigen, um Ihr Go-Know-how und Ihren Arbeitsablauf zu verbessern. Hoffentlich helfen sie dir dabei, im Handumdrehen ein Go-Meister zu werden.