Googles Go-Programmiersprache gibt es seit 2009 und im Jahr 2012 erreichte die Sprache ihren offiziellen v1.0-Status. In diesen Jahren hat sich viel geändert, auch was die Installation der Sprache betrifft. Zurück in den Kinderschuhen gab es keine offiziellen Binärdistributionen und Sie mussten entweder Go aus dem Quellcode erstellen, was die empfohlene Methode war, da sich die Sprache häufig änderte, oder ein vorgefertigtes Paket für Ihre Linux-Distribution verwenden. Damals war die Windows-Unterstützung begrenzt, ebenso wie die Unterstützung anderer CPU-Architekturen als Intel.

Die Dinge haben sich seitdem stark verbessert. Für Linux gibt es zwei einfache Möglichkeiten, Go zu installieren. Laden Sie den offiziellen Linux-Binary-Build von der Go-Download-Seite herunter oder entscheiden Sie sich für ein vorgefertigtes Paket für Ihre Linux-Distribution. Der einfachste Weg, Go on Ubuntu zu installieren, ist apt-get :

 sudo apt-get installieren Sie golang

Sobald Go installiert ist, können Sie damit beginnen, Programme zu entwickeln. Eines der einfachsten Go-Programme ist das klassische Programm "Hello World!". Erstellen Sie mit einem Texteditor eine Datei namens " hellomte.go " mit dem folgenden kurzen Go-Code:

 package main import "fmt" func main () {fmt.Println ("Hallo Mach Tech Easier!")}

Seit v1.0 von Go wurde die Notwendigkeit für einzelne Kompilier- und Verknüpfungsbefehle entfernt und die alten 8g und 8l Befehle wurden durch den go Befehl ersetzt.

Um hellomte.go zu hellomte.go, öffne ein Terminal und wechsle das Verzeichnis in den Ordner, der die Quellcodedatei enthält, und hellomte.go dann:

 gehen Sie laufen hellomte.go

Dadurch wird das Go-Programm kompiliert und ausgeführt, aber es wird keine ausführbare Binärdatei erzeugt. Um eine Binärdatei zu erstellen und sie dann auszuführen, verwenden Sie den Befehl go build :

 gehe bauen hellomte.go ./hellomte

Die Macht der Parallelität

Eines der definierenden Merkmale der Go-Programmiersprache ist ihre Unterstützung für Parallelität, die es einem Programm ermöglicht, mit mehreren Aufgaben gleichzeitig zu arbeiten. Parallelität, die der Parallelität ähnelt, ermöglicht es einem Programm, viele Aufgaben gleichzeitig auszuführen, aber die Parallelität geht noch einen Schritt weiter, indem es diesen separaten Aufgaben ermöglicht, zu kommunizieren und zu interagieren. Als Ergebnis ermöglicht Go Programmierern die Verwendung einer ganzen Reihe unterschiedlicher Concurrent-Designs, einschließlich Worker-Pools, Pipelines (bei denen eine Task nach der anderen auftritt) und synchroner oder asynchroner Hintergrund-Tasks. Die Grundlage dieser Parallelität ist die goroutine die mit channels und der select Anweisung von Go gekoppelt ist.

Hier ist ein einfaches Go-Programm, das eine Zeichenfolge mehrmals mit einer gleichzeitigen Routine ausgibt:

 Paket Hauptimport ("fmt" "time") func say (s string) {für i: = 0; i <5; i ++ {fmt.Println (s)}} func main () {go say ("Hallo Make Tech Easier!") fmt.Println ("Schlaf ein wenig ...") time.Sleep (100 * time.Millisecond)}

Die Funktion say() führt einfach eine einfache Schleife aus, um die Zeichenkette (Parameter s ) fünfmal auszudrucken. Das interessante ist, wie diese Funktion aufgerufen wird. Anstatt einfach nur zu say("Hello Make Tech Easier!") das Schlüsselwort go vor den Funktionsaufruf gestellt. Dies bedeutet, dass die Funktion als separate Aufgabe ausgeführt wird. Der Rest der main() Funktion schläft dann nur ein wenig, um der goroutine Zeit zum goroutine zu geben.

Die Ausgabe kann Sie überraschen:

Wie Sie sehen können, wird die Funktion say() als goroutine und während der Einrichtung wird der Rest der main() -Funktion fortgesetzt, Sleep a little... goroutine Sleep a little... und dann in den Ruhezustand versetzt. Bis dahin ist die goroutine aktiv und beginnt, die Zeichenfolge fünfmal auszudrucken. Schließlich endet das Programm, sobald das Zeitlimit erreicht ist.

Kanäle

goroutines können über Kanäle kommunizieren. Ein Kanal öffnet eine Kommunikationslinie zwischen zwei verschiedenen Teilen eines Go-Programms. Normalerweise wird eine Funktion als goroutine und wenn sie Daten goroutine muss (etwa von einer Netzwerkoperation), kann sie einen Kanal verwenden, um diese Daten weiterzuleiten. Wenn ein anderer Teil des Go-Programms auf diese Daten wartet, wird er in den Ruhezustand versetzt, bis die Daten bereit sind. Channels werden mit der make() -Funktion erstellt und können als Parameter an goroutines .

Betrachten Sie diesen Code:

 Paket Hauptimport ("fmt") func say (s Zeichenfolge, c chan int) {var i int für i = 0; i <5; i ++ {fmt.Println (s)} c <- i} func main () {c: = make (chan int) geh sagen ("Hallo Mach Tech Easier!", c) sts: = <- c fmt.Println ( M)}

Die Funktion say() ist dem ersten Beispiel sehr ähnlich, mit der Ausnahme, dass der zweite Parameter ein Kanal ist und dass nach dem Ausdruck der Zeichenkette die Anzahl der Iterationen über die c <- i Codezeile den Kanal heruntergesendet wird.

Die Hauptfunktion erstellt einen Kanal, startet die Funktion say() als goroutine und wartet dann darauf, dass die Daten den Kanal, sts := <- c vor dem Ausdruck des Ergebnisses goroutine .

Fazit

Die Go-Sprache hat sich in den letzten Jahren deutlich weiterentwickelt, wenn Sie es in letzter Zeit nicht angeschaut haben, ist vielleicht jetzt eine gute Zeit!