Kapitel 1. Einrichten deiner Go-Umgebung
Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: translation-feedback@oreilly.com
Jede Programmiersprache braucht eine Entwicklungsumgebung, und Go ist da keine Ausnahme. Wenn du bereits ein oder zwei Go-Programme entwickelt hast, dann hast du bereits eine funktionierende Umgebung, aber du hast vielleicht einige der neueren Techniken und Werkzeuge verpasst. Wenn du Go zum ersten Mal auf deinem Computer einrichtest, mach dir keine Sorgen: Es ist ganz einfach, Go und die dazugehörigen Werkzeuge zu installieren. Nachdem du die Umgebung eingerichtet und überprüft hast, erstellst du ein einfaches Programm, lernst die verschiedenen Möglichkeiten kennen, Go-Code zu erstellen und auszuführen, und lernst dann einige Werkzeuge und Techniken kennen, die die Go-Entwicklung erleichtern.
Installieren der Go Tools
Um Go-Code zu erstellen, musst du herunterladen und die Go-Entwicklungswerkzeuge installieren. Die neueste Version der Tools findest du auf der Download-Seite der Go-Website. Wähle den Download für deine Plattform und installiere ihn. Das .pkg-Installationsprogramm für Mac und das .msi-Installationsprogramm für Windows installieren Go automatisch am richtigen Ort, entfernen alle alten Installationen und legen die Go-Binärdatei im Standardausführungspfad ab.
Tipp
Wenn du ein Mac-Entwickler bist, kannst du Go mit Homebrew mit dem Befehl brew install go installieren. Windows-Entwickler, die Chocolatey verwenden, können Go mit dem Befehl choco install golang installieren.
Die verschiedenen Linux- und BSD-Installationsprogramme sind gzipped TAR-Dateien und expandieren in ein Verzeichnis namens go. Kopiere dieses Verzeichnis nach /usr/local und füge /usr/local/go/bin zu deinem $PATH hinzu, damit der Befehl go zugänglich ist:
$ tar -C /usr/local -xzf go1.20.5.linux-amd64.tar.gz $ echo 'export PATH=$PATH:/usr/local/go/bin' >> $HOME/.bash_profile $ source $HOME/.bash_profile
Möglicherweise brauchst du root-Rechte, um in /usr/local zu schreiben. Wenn der Befehl tar fehlschlägt, führe ihn mit sudo tar -C /usr/local -xzf go1.20.5.linux-amd64.tar.gz erneut aus.
Hinweis
Go-Programme werden zu einer einzigen nativen Binärdatei kompiliert und müssen nicht mit zusätzlicher Software installiert werden, um sie auszuführen. Dies steht im Gegensatz zu Sprachen wie Java, Python und JavaScript, bei denen du eine virtuelle Maschine installieren musst, um dein Programm auszuführen. Die Verwendung einer einzigen nativen Binärdatei macht es viel einfacher, in Go geschriebene Programme zu verbreiten. Dieses Buch befasst sich nicht mit Containern, aber Entwickler/innen, die Docker oder Kubernetes verwenden, können eine Go-App oft in ein Scratch- oder Distroless-Image packen. Details dazu findest du in Geert Baekes Blogbeitrag "Distroless or Scratch for Go Apps".
Du kannst überprüfen, ob deine Umgebung richtig eingerichtet ist, indem du ein Terminal oder eine Eingabeaufforderung öffnest und eingibst:
$ go version
Wenn alles richtig eingestellt ist, solltest du etwas wie dieses Bild sehen:
go version go1.20.5 darwin/arm64
Das sagt dir, dass es sich um die Go-Version 1.20.5 auf macOS handelt. (Darwin ist das Betriebssystem, das macOS zugrunde liegt, und arm64 ist der Name für die 64-Bit-Chips, die auf ARM-Designs basieren). Unter x64 Linux würdest du das sehen:
go version go1.20.5 linux/amd64
Fehlersuche bei deiner Go-Installation
Wenn du statt der Versionsmeldung eine Fehlermeldung erhältst, hast du wahrscheinlich go nicht in deinem Ausführungspfad oder du hast ein anderes Programm namens go in deinem Pfad. Unter macOS und anderen Unix-ähnlichen Systemen kannst du mit which go sehen, ob der Befehl go gerade ausgeführt wird oder nicht. Wenn nichts zurückgegeben wird, musst du deinen Ausführungspfad korrigieren.
Wenn du mit Linux oder BSD arbeitest, ist es möglich, dass du die 64-Bit-Go-Entwicklungstools auf einem 32-Bit-System oder die Entwicklungstools für die falsche Chip-Architektur installiert hast.
Go Tooling
Alle Go-Entwicklungstools werden über den Befehl go aufgerufen. Zusätzlich zu go version gibt es einen Compiler (go build), einen Code-Formatierer (go fmt), einen Abhängigkeitsmanager (go mod), einen Test-Runner (go test), ein Tool, das nach häufigen Programmierfehlern sucht (go vet), und vieles mehr. Sie werden in den Kapiteln 10, 11 und 15 ausführlich behandelt. Werfen wir zunächst einen kurzen Blick auf die am häufigsten verwendeten Tools, indem wir jedermanns erste Lieblingsanwendung schreiben: "Hello, World!""
Hinweis
Seit der Einführung von Go im Jahr 2009 hat sich die Art und Weise, wie Go-Entwickler ihren Code und ihre Abhängigkeiten organisieren, mehrfach geändert. Aufgrund dieser Veränderungen gibt es viele widersprüchliche Ratschläge, von denen die meisten veraltet sind (zum Beispiel kannst du die Diskussionen über GOROOT und GOPATH getrost ignorieren).
Für die moderne Go-Entwicklung gilt eine einfache Regel: Du kannst deine Projekte so organisieren, wie du es für richtig hältst, und sie speichern, wo du willst.
Dein erstes Go-Programm
Lass uns die Grundlagen des Schreibens eines Go-Programms durchgehen. Auf dem Weg dorthin wirst du sehen, aus welchen Teilen ein einfaches Go-Programm besteht. Es kann sein, dass du noch nicht alles verstehst, aber das ist in Ordnung; dafür ist der Rest des Buches da!
Ein Go-Modul herstellen
Als erstes musst du ein Verzeichnis erstellen, in dem dein Programm gespeichert wird. Nenne es ch1. Gib in der Befehlszeile das neue Verzeichnis ein. Wenn das Terminal deines Computers bash oder zsh verwendet, sieht das wie folgt aus:
$ mkdir ch1 $ cd ch1
Führe innerhalb des Verzeichnisses den Befehl go mod init aus, um dieses Verzeichnis als Go-Modul zu markieren:
$ go mod init hello_world go: creating new go.mod: module hello_world
In Kapitel 10 erfährst du mehr darüber, was ein Modul ist, aber im Moment musst du nur wissen, dass ein Go-Projekt ein Modul genannt wird. Ein Modul ist nicht nur Quellcode. Es ist auch eine genaue Spezifikation der Abhängigkeiten des Codes innerhalb des Moduls. Jedes Modul hat eine go.mod-Datei in seinem Stammverzeichnis. Wenn du go mod init ausführst, wird diese Datei für dich erstellt. Der Inhalt einer einfachen go.mod-Datei sieht wie folgt aus:
module hello_world go 1.20
In der Datei go.mod werden der Name des Moduls, die minimal unterstützte Version von Go für das Modul und alle anderen Module, von denen dein Modul abhängt, angegeben. Sie ist vergleichbar mit der Datei requirements.txt, die in Python verwendet wird, oder dem Gemfile, das in Ruby verwendet wird.
Du solltest die Datei go.mod nicht direkt bearbeiten. Verwende stattdessen die Befehle go get und go mod tidy, um Änderungen an der Datei zu verwalten. Alles, was mit Modulen zu tun hat, wird in Kapitel 10 behandelt.
bauen gehen
Jetzt lass uns etwas Code schreiben! Öffne einen Texteditor, gib den folgenden Text ein und speichere ihn in ch1 unter dem Dateinamen hello.go:
packagemainimport"fmt"funcmain(){fmt.Println("Hello, world!")}
(Ja, die Einrückung in diesem Codebeispiel sieht schlampig aus: Das wollte ich machen! Du wirst gleich sehen, warum.)
Schauen wir uns kurz die Teile der Go-Datei an, die du erstellt hast. Die erste Zeile ist eine Paketdeklaration. Innerhalb eines Go-Moduls ist der Code in einem oder mehreren Paketen organisiert. Das Paket main in einem Go-Modul enthält den Code, der ein Go-Programm startet.
Als nächstes folgt eine Import-Deklaration. Die Anweisung listet die Pakete auf, auf die in dieser Datei verwiesen wird. Du verwendest eine Funktion aus dem Paket (normalerweise "fumpt" ausgesprochen) aus der Standardbibliothek, also führst du das Paket hier auf. Im Gegensatz zu anderen Sprachen importiert Go nur ganze Pakete. Du kannst den Import nicht auf bestimmte Typen, Funktionen, Konstanten oder Variablen innerhalb eines Pakets beschränken. import fmt
Alle Go-Programme beginnen mit der Funktion main im Paket main. Du deklarierst diese Funktion mit func main() und einer linken Klammer. Wie Java, JavaScript und C verwendet auch Go geschweifte Klammern, um den Anfang und das Ende von Codeblöcken zu markieren.
Der Körper der Funktion besteht aus einer einzigen Zeile. Sie besagt, dass du die Funktion Println im Paket fmt mit dem Argument "Hello, world!" aufrufst. Als erfahrener Entwickler kannst du wahrscheinlich erraten, was dieser Funktionsaufruf bewirkt.
Nachdem die Datei gespeichert wurde, gehst du zurück zu deinem Terminal oder deiner Eingabeaufforderung und gibst ein:
$ go build
Dadurch wird eine ausführbare Datei namens hello_world (oder hello_world.exe unter Windows) im aktuellen Verzeichnis erstellt. Wenn du sie ausführst, wird auf dem Bildschirm Hello, world! angezeigt:
$ ./hello_world Hello, world!
Der Name der Binärdatei entspricht dem Namen in der Moduldeklaration. Wenn du einen anderen Namen für deine Anwendung möchtest oder wenn du sie an einem anderen Ort speichern möchtest, verwende das -o Flag. Wenn du zum Beispiel den Code in eine Binärdatei mit dem Namen "Hallo" kompilieren möchtest, würdest du Folgendes verwenden:
$ go build -o hello
In "Mit go run kleine Programme ausprobieren" beschreibe ich eine weitere Möglichkeit, ein Go-Programm auszuführen.
fmt gehen
Eines der Hauptziele bei der Entwicklung von Go war es, eine Sprache zu entwickeln, mit der du effizient Code schreiben kannst. Das bedeutete eine einfache Syntax und einen schnellen Compiler. Das veranlasste die Go-Autoren auch dazu, die Code-Formatierung zu überdenken. Die meisten Sprachen erlauben eine große Flexibilität bei der Formatierung des Codes. Bei Go ist das nicht der Fall. Die Durchsetzung eines Standardformats macht es sehr viel einfacher, Werkzeuge zu schreiben, die den Quellcode manipulieren. Das vereinfacht den Compiler und ermöglicht die Entwicklung einiger cleverer Tools zur Codegenerierung.
Es gibt auch noch einen zweiten Vorteil. In der Vergangenheit haben Entwicklerinnen und Entwickler viel Zeit mit Formatierungsstreitigkeiten verschwendet. Da Go eine Standardmethode für die Formatierung von Code definiert, vermeiden Go-Entwickler/innen Streitigkeiten über Klammern und Tabulatoren gegenüber Leerzeichen. Go-Programme verwenden zum Beispiel Tabulatoren zum Einrücken, und ist ein Syntaxfehler, wenn die öffnende Klammer nicht in derselben Zeile steht wie die Deklaration oder der Befehl, mit dem der Block beginnt.
Hinweis
Viele Go-Entwickler glauben, dass das Go-Team ein Standardformat festgelegt hat, um Streit unter den Entwicklern zu vermeiden, und erst später die Vorteile der Werkzeuge entdeckt hat. Russ Cox, der Leiter der Go-Entwicklung, hat jedoch öffentlich erklärt, dass eine bessere Werkzeugausstattung seine ursprüngliche Motivation war.
Die Go-Entwicklungswerkzeuge enthalten einen Befehl, go fmt, der die Leerzeichen in deinem Code automatisch so korrigiert, dass sie dem Standardformat entsprechen. Er kann jedoch keine Klammern in der falschen Zeile korrigieren. Führe ihn mit folgendem Befehl aus:
$ go fmt ./... hello.go
Mit ./... wird ein Go-Werkzeug angewiesen, den Befehl auf alle Dateien im aktuellen Verzeichnis und allen Unterverzeichnissen anzuwenden. Du wirst es wieder sehen, wenn du weitere Go-Tools kennenlernst.
Wenn du hello.go öffnest, siehst du, dass die Zeile mit fmt.Println jetzt richtig mit einem einzelnen Tab eingerückt ist.
Tipp
Erinnere dich daran, go fmt auszuführen, bevor du deinen Code kompilierst, und zumindest, bevor du Änderungen am Quellcode in dein Repository überträgst! Wenn du das vergisst, mache einen separaten Commit, der nur go fmt ./... damit du die logischen Änderungen nicht in einer Lawine von Formatierungsänderungen untergehst.
zum Tierarzt gehen
Bei einer Klasse von Fehlern ist der Code zwar syntaktisch gültig, aber sehr wahrscheinlich falsch. Das Tool go enthält einen Befehl namens go vet, um diese Art von Fehlern zu erkennen. Füge einen solchen Befehl in dein Programm ein und beobachte, wie er erkannt wird. Ändere die Zeile fmt.Println in hello.go wie folgt:
fmt.Printf("Hello, %s!\n")
Hinweis
fmt.Printf ist ähnlich wie printf in C, Java, Ruby und vielen anderen Sprachen. Wenn du fmt.Printf noch nicht kennst, handelt es sich um eine Funktion, deren erster Parameter eine Vorlage ist und deren übrigeParameter Werte für die Platzhalter in der Vorlage sind.
In diesem Beispiel hast du eine Vorlage ("Hello, %s!\n") mit einem %s Platzhalter, aber es wurde kein Wert für den Platzhalter angegeben. Der Code wird kompiliert und ausgeführt, aber er ist nicht korrekt. go vet prüft unter anderem, ob für jeden Platzhalter in einer Templating-Vorlage ein Wert vorhanden ist. Wenn du go vet mit dem geänderten Code ausführst, wird ein Fehler gefunden:
$ go vet ./... # hello_world ./hello.go:6:2: fmt.Printf format %s reads arg #1, but call has 0 args
Jetzt, wo go vet den Fehler gefunden hat, kannst du ihn leicht beheben. Ändere Zeile 6 in hello.go zu:
fmt.Printf("Hello, %s!\n","world")
Auch wenn go vet einige gängige Programmierfehler erkennt, gibt es Dinge, die es nicht entdecken kann. Glücklicherweise können Go-Codequalitäts-Tools von Drittanbietern die Lücke schließen. Einige der beliebtesten Code-Qualitäts-Tools werden in "Code-Qualitäts-Scanner verwenden" vorgestellt .
Tipp
So wie du go fmt ausführen solltest, um sicherzustellen, dass dein Code richtig formatiert ist, führt go vet aus, um nach möglichen Fehlern in gültigem Code zu suchen. Diese Befehle sind nur der erste Schritt, um sicherzustellen, dass dein Code von hoher Qualität ist. Zusätzlich zu den Ratschlägen in diesem Buch sollten alle Go-Entwickler/innen Effective Go und die Seite Code Review Comments im Go-Wiki lesen, um zu verstehen, wie idiomatischer Go-Code aussieht.
Wähle deine Werkzeuge
Während du ein kleines Go-Programm mit nichts weiter als einem Texteditor und dem Befehl go geschrieben hast, wirst du bei der Arbeit angrößeren Projekten wahrscheinlich fortschrittlichere Werkzeuge benötigen. Go-IDEs bieten viele Vorteile gegenüber Texteditoren, z. B. automatische Formatierung beim Speichern, Code-Vervollständigung, Typüberprüfung, Fehlerberichte und integriertes Debugging. Für die meisten Texteditoren und IDEs gibt es hervorragende Go-Entwicklungstools. Wenn du noch kein Lieblingstool hast, sind zwei der beliebtesten Go-Entwicklungsumgebungen Visual Studio Code und GoLand.
Visual Studio Code
Wenn du auf der Suche nach einer kostenlosen Entwicklungsumgebung bist, ist Visual Studio Code von Microsoft deine beste Wahl. Seit seiner Veröffentlichung im Jahr 2015 hat sich VS Code zum beliebtesten Quellcode-Editor für Entwickler/innen entwickelt. Er wird nicht mit Go-Unterstützung ausgeliefert, aber du kannst ihn zu einer Go-Entwicklungsumgebung machen, indem du die Go-Erweiterung aus der Erweiterungsgalerie herunterlädst.
Die Go-Unterstützung von VS Code basiert auf Erweiterungen von Drittanbietern, die über den integrierten Marketplace zugänglich sind. Dazu gehören die Go-Entwicklungswerkzeuge, der Delve-Debugger und gopls, ein Go-Sprachserver, der vom Go-Team entwickelt wurde. Während du den Go-Compiler selbst installieren musst, übernimmt die Go-Erweiterung die Installation von Delve und gopls für dich.
Hinweis
Was ist ein Sprachserver? Es handelt sich um eine Standardspezifikation für eine API, die es Editoren ermöglicht, intelligentes Editierverhalten zu implementieren, z. B. Codevervollständigung, Qualitätsprüfungen oder das Auffinden aller Stellen, an denen eine Variable oder Funktion in deinem Code verwendet wird. Mehr über Sprachserver und ihre Möglichkeiten erfährst du auf der Website des Language Server Protocol.
Sobald deine Werkzeuge eingerichtet sind, kannst du dein Projekt öffnen und damit arbeiten. Abbildung 1-1 zeigt dir, wie dein Projektfenster aussehen sollte. "Erste Schritte mit VS Code Go" ist eine Anleitung, die die VS Code Go-Erweiterung demonstriert.
Abbildung 1-1. Visual Studio Code
GoLand
GoLand ist die Go-spezifische IDE von JetBrains. Während JetBrains vor allem für Java-zentrierte Tools bekannt ist, ist GoLand eine hervorragende Go-Entwicklungsumgebung. Wie du in Abbildung 1-2 sehen kannst, sieht die Benutzeroberfläche von GoLand ähnlich aus wie die von IntelliJ, PyCharm, RubyMine, WebStorm, Android Studio oder einer der anderen JetBrains-IDEs. Die Go-Unterstützung umfasst Refactoring, Syntax-Highlighting, Code-Vervollständigung und Navigation, Dokumentations-Pop-ups, einen Debugger, Code Coverage und mehr. Neben der Go-Unterstützung bietet GoLand auch JavaScript/HTML/CSS und SQL-Datenbank-Tools. Im Gegensatz zu VS Code musst du für GoLand kein Plug-in installieren, damit es funktioniert.
Abbildung 1-2. GoLand
Wenn du IntelliJ Ultimate bereits abonniert hast, kannst du die Go-Unterstützung über ein Plug-in hinzufügen. Während GoLand eine kommerzielle Software ist, bietet JetBrains ein kostenloses Lizenzprogramm für Studierende und Open-Source-Mitwirkende an. Wenn du dich nicht für eine kostenlose Lizenz qualifizierst, kannst du die Software 30 Tage lang kostenlos testen. Danach musst du für GoLand bezahlen.
Der Go-Spielplatz
Es gibt noch ein weiteres wichtiges Tool für die Go-Entwicklung: , das du aber nicht installierst. Wenn du The Go Playground besuchst, siehst du ein Fenster, das Abbildung 1-3 ähnelt. Wenn du eine Kommandozeilenumgebung wie irb, node oder python benutzt hast, wirst du feststellen, dass The Go Playground sich ähnlich anfühlt. Er bietet dir einen Ort, an dem du kleine Programme ausprobieren und mit anderen teilen kannst. Gib dein Programm in das Fenster ein und klicke auf die Schaltfläche Ausführen, um den Code auszuführen. Die Schaltfläche Formatieren führt dein Programm auf go fmt aus und aktualisiert deine Importe. Die Schaltfläche Freigeben erstellt eine eindeutige URL, die du anderen schicken kannst, damit sie sich dein Programm ansehen oder zu einem späteren Zeitpunkt zu deinem Code zurückkehren können (die URLs haben sich als langlebig erwiesen, aber ich würde mich nicht darauf verlassen, dass der Playground dein Quellcode-Repository ist).
Abbildung 1-3. Der Go-Spielplatz
Wie du in Abbildung 1-4 sehen kannst, kannst du mehrere Dateien simulieren, indem du jede Datei mit einer Zeile trennst, die wie -- filename.go -- aussieht. Du kannst sogar simulierte Unterverzeichnisse erstellen, indem du ein / in den Dateinamen einfügst, z. B. -- subdir/my_code.go --.
Sei dir bewusst, dass sich der Go Playground auf einem fremden Computer befindet (insbesondere auf dem von Google), du hast also nicht völlig freie Hand. Du hast die Wahl zwischen einigen Go-Versionen (normalerweise die aktuelle Version, die vorherige Version und die letzte Entwicklungsversion). Netzwerkverbindungen kannst du nur zu localhost herstellen, und Prozesse, die zu lange laufen oder zu viel Speicher verbrauchen, werden angehalten. Wenn dein Programm von der Zeit abhängt, musst du berücksichtigen, dass die Uhr auf den 10. November 2009, 23:00:00 UTC (das Datum der ersten Ankündigung von Go) gestellt ist. Trotz dieser Einschränkungen ist der Go Playground eine nützliche Methode, um neue Ideen auszuprobieren, ohne ein neues Projekt lokal zu erstellen. In diesem Buch findest du überall Links zum Go Playground, damit du die Codebeispiele ausführen kannst, ohne sie auf deinen Computer zu kopieren.
Warnung
Gib keine sensiblen Informationen (wie z. B. persönliche Daten, Passwörter oder private Schlüssel) auf deinem Spielplatz an! Wenn du auf die Schaltfläche "Teilen"klickst, werden die Informationen auf den Servern von Google gespeichert und sind für jeden zugänglich, der die zugehörigeShare-URL hat. Wenn du dies aus Versehen tust, kontaktiere Google untersecurity@golang.org mit der URL und dem Grund, warum der Inhalt entfernt werden muss.
Abbildung 1-4. Der Go Playground unterstützt mehrere Dateien
Makefiles
Eine IDE ist schön zu benutzen, aber schwer zu automatisieren. Moderne Softwareentwicklung ist auf wiederholbare, automatisierbare Builds angewiesen, die von jedem, überall und zu jeder Zeit ausgeführt werden können. Diese Art von Werkzeugen ist eine gute Praxis in der Softwareentwicklung. So wird die uralte Situation vermieden, in der sich ein Entwickler mit einem Achselzucken und der Aussage "Auf meinem Rechner funktioniert es!" von allen Build-Problemen freisprechen kann. Der Weg dorthin führt über eine Art Skript, in dem die Build-Schritte festgelegt werden. Go-Entwickler haben als ihre Lösung gewählt. Mit diesem Skript können Entwickler eine Reihe von Vorgängen festlegen, die für die Erstellung eines Programms notwendig sind, sowie die Reihenfolge, in der die Schritte ausgeführt werden müssen. Vielleicht kennst du noch nicht, aber es wird seit 1976 zur Erstellung von Programmen auf Unix-Systemen verwendet. make make
Erstelle im Verzeichnis ch1 eine Datei namens Makefile mit folgendem Inhalt:
.DEFAULT_GOAL:=build.PHONY:fmtvetbuildfmt:go fmt ./...vet:fmtgo vet ./...build:vetgo build
Auch wenn du noch nie ein Makefile gesehen hast, ist es nicht allzu schwierig, herauszufinden, was da vor sich geht. Jede mögliche Operation wird als Target bezeichnet. Das .DEFAULT_GOAL legt fest, welches Ziel ausgeführt wird, wenn kein Ziel angegeben wird. In diesem Fall ist die Vorgabe das Ziel build. Als Nächstes folgen die Zieldefinitionen. Das Wort vor dem Doppelpunkt (:) ist der Name des Ziels. Alle Wörter nach dem Ziel (wie vet in der Zeile build: vet) sind die anderen Ziele, die ausgeführt werden müssen, bevor das angegebene Ziel ausgeführt wird. Die Aufgaben, die von dem Ziel ausgeführt werden, stehen in den eingerückten Zeilen nach dem Ziel. Die Zeile .PHONY verhindert, dass make verwirrt wird, wenn ein Verzeichnis oder eine Datei in deinem Projekt denselben Namen hat wie eines der aufgeführten Ziele.
Führe make aus und du solltest die folgende Ausgabe sehen:
$ make go fmt ./... go vet ./... go build
Die Eingabe eines einzigen Befehls formatiert den Code korrekt, überprüft ihn auf nicht offensichtliche Fehler und kompiliert ihn. Du kannst den Code auch mit make vet überprüfen oder einfach den Formatierer mit make fmt ausführen. Das mag nicht nach einer großen Verbesserung klingen, aber wenn du sicherstellst, dass die Formatierung und die Überprüfung immer stattfinden, bevor ein Entwickler (oder ein Skript, das auf einem Continuous-Integration-Build-Server läuft) einen Build auslöst, verpasst du keinen Schritt.
Ein Nachteil von Makefiles ist, dass sie sehr wählerisch sind. Du musst die Schritte in einem Ziel mit einem Tabulator einrücken. Außerdem werden sie unter Windows nicht standardmäßig unterstützt. Wenn du Go auf einem Windows-Computer entwickelst, musst du zuerst make installieren. Am einfachsten ist es, wenn du zuerst einen Paketmanager wie Chocolatey installierst und dann damit make installierst (für Chocolatey lautet der Befehl choco install make).
Wenn du mehr über das Schreiben von Makefiles erfahren willst, findest du unter ein gutes Tutorial von Chase Lambert, das allerdings ein wenig C verwendet, um die Konzepte zu erklären.
Du findest den Code aus diesem Kapitel im Kapitel 1 Repository für dieses Buch.
Das Go-Kompatibilitätsversprechen
Wie bei allen Programmiersprachen, werden die Go-Entwicklungswerkzeuge regelmäßig aktualisiert. Seit Go 1.2 gibt es etwa alle sechs Monate eine neue Version. Bei Bedarf werden auch Patch-Versionen mit Fehler- und Sicherheitsbehebungen veröffentlicht. Angesichts der schnellen Entwicklungszyklen und des Engagements des Go-Teams für Abwärtskompatibilität werden Go-Versionen eher inkrementell als expansiv veröffentlicht. Das Go-Kompatibilitätsversprechen ist eine detaillierte Beschreibung, wie das Go-Team es vermeiden will, Go-Code zu verändern. Es besagt, dass es für alle Go-Versionen, die mit 1 beginnen, keine abwärtskompatiblen Änderungen an der Sprache oder der Standardbibliothek geben wird, es sei denn, die Änderung ist für eine Fehler- oder Sicherheitsbehebung erforderlich. In seiner Keynote auf der GopherCon 2022 mit dem Titel "Compatibility: How Go Programs Keep Working" (Kompatibilität: Wie Go-Programme weiter funktionieren) geht Russ Cox auf alle Möglichkeiten ein, mit denen das Go-Team dafür sorgt, dass Go-Code nicht kaputt geht. Er sagt: "Ich glaube, dass die Priorität der Kompatibilität die wichtigste Designentscheidung war, die wir in Go 1 getroffen haben."
Diese Garantie gilt nicht für die Befehle und go. Es gab rückwärtskompatible Änderungen an den Flags und der Funktionalität der go Befehle, und es ist durchaus möglich, dass dies wieder passiert.
Immer auf dem Laufenden bleiben
Go-Programme werden zu einer eigenständigen nativen Binärdatei kompiliert, sodass du dir keine Sorgen machen musst, dass eine Aktualisierung deiner Entwicklungsumgebung dazu führen könnte, dass deine aktuell eingesetzten Programme fehlschlagen. Du kannst Programme, die mit verschiedenen Go-Versionen kompiliert wurden, gleichzeitig auf demselben Computer oder einer virtuellen Maschine laufen lassen.
Wenn du bereit bist, die auf deinem Computer installierten Go-Entwicklungswerkzeuge zu aktualisieren, haben Mac- und Windows-Benutzer den einfachsten Weg. Diejenigen, die mit brew oderchocolatey installiert haben, können diese Tools zum Aktualisieren verwenden. Diejenigen, die die Installationsprogramme auf https://golang.org/dl verwendet haben, können das neueste Installationsprogramm herunterladen, das die alte Version entfernt, wenn es die neue Version installiert.
Linux- und BSD-Benutzer müssen unter die neueste Version herunterladen, die alte Version in ein Backup-Verzeichnis verschieben, die neue Version entpacken und dann die alte Version löschen:
$ mv /usr/local/go /usr/local/old-go $ tar -C /usr/local -xzf go1.20.6.linux-amd64.tar.gz $ rm -rf /usr/local/old-go
Hinweis
Technisch gesehen musst du die bestehende Installation nicht an einen neuen Ort verschieben; du könntest sie einfach löschen und die neue Version installieren. Das fällt allerdings unter die Kategorie "Vorsicht ist besser als Nachsicht". Wenn bei der Installation der neuen Version etwas schief geht, ist es gut, wenn du die alte Version noch hast.
Übungen
Am Ende jedes Kapitels gibt es Übungen, mit denen du die Ideen, die ich behandle, ausprobieren kannst. Die Antworten auf diese Übungen findest du im Repository zu Kapitel 1.
-
Nimm das Programm "Hallo, Welt!" und führe es auf dem Go Playground aus. Teile einen Link zu dem Code im Playground mit einem Kollegen, der gerne etwas über Go lernen würde.
-
Füge dem Makefile ein Ziel namens
cleanhinzu, das die Binärdateihello_worldund alle anderen temporären Dateien, die vongo builderstellt wurden, entfernt. In der Go-Befehlsdokumentation findest du einengoBefehl, der dir bei der Umsetzung hilft. -
Experimentiere damit, die Formatierung im Programm "Hallo, Welt!" zu ändern. Füge Leerzeilen oder Leerzeichen ein, ändere die Einrückung oder füge Zeilenumbrüche ein. Nachdem du eine Änderung vorgenommen hast, führe
go fmtaus, um zu sehen, ob die Formatierungsänderung rückgängig gemacht wird. Führe auchgo buildaus, um zu sehen, ob der Code noch kompilierbar ist. Du kannst auch zusätzlichefmt.PrintlnAufrufe hinzufügen, damit du sehen kannst, was passiert, wenn du Leerzeilen in der Mitte einer Funktion einfügst.
Einpacken
In diesem Kapitel hast du gelernt, wie du deine Go-Entwicklungsumgebung installierst und konfigurierst. Außerdem hast du gelernt, mit welchen Werkzeugen du Go-Programme erstellen und die Qualität deines Codes sicherstellen kannst. Jetzt, wo deine Umgebung bereit ist, geht es weiter mit dem nächsten Kapitel, in dem du die eingebauten Typen in Go kennenlernst und erfährst, wie man Variablen deklariert.
Get Go lernen, 2. Auflage now with the O’Reilly learning platform.
O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.
