Golang, oft einfach als Go bezeichnet, ist eine Open-Source-Programmiersprache, die von Google entwickelt und 2009 veröffentlicht wurde. Die von Robert Griesemer, Rob Pike und Ken Thompson entworfene Sprache zielt darauf ab, eine schnelle, effiziente und leicht wartbare Lösung für die moderne Softwareentwicklung zu bieten, insbesondere in verteilten Systemen, der Cloud und Backend-Infrastrukturen.
Für welche Anwendungsbereiche?
Die Go-Sprache erregt besonderes Interesse in verschiedenen Bereichen, insbesondere:
- Cloud- und verteilte Systeme: Go wird häufig in Cloud-Computing-Umgebungen eingesetzt und ist besonders für Cloud-native Anwendungen und Microservices geschätzt.
- Backend-Infrastrukturen: Als eine sehr leistungsfähige, kompilierte Sprache ist Go eine hervorragende Option für Backends großer Plattformen wie Datenverwaltungssysteme und APIs.
- Webdienste: Viele Unternehmen nutzen es zur Entwicklung zuverlässiger und skalierbarer Go-Programme, wie Docker oder Kubernetes.
Vorteile und Nachteile
Golang bietet viele Vorteile, hat aber auch Nachteile, die berücksichtigt werden sollten.
Vorteile
Nachteile
Einfachheit: Die Syntax ist einfach, klar und leicht zu lesen.
Keine Generika: Bis vor Kurzem bot Go keine Generika an, was die Handhabung einiger Datenstrukturen erschweren konnte.
Hohe Leistung: Go ist eine kompilierte Sprache, was schnelle Ausführungszeiten ermöglicht, vergleichbar mit der Leistung von C oder C++.
Einfachheit der Syntax: Die Einfachheit kann ihren Preis haben. Beispielsweise fehlt der Sprache manche fortgeschrittene Abstraktion, die in anderen Sprachen zu finden ist.
Konkurrenzverwaltung: Die Goroutinen sind ein leistungsstarker Mechanismus, um Konkurrenz effektiv und einfach zu verwalten.
Fehlerbehandlung: Die Behandlung von Fehlern ist bewusst ausführlich, was den Go-Code länger und schwieriger lesbar machen kann.
Cross-Kompilierung: Go ermöglicht es, den Quellcode mit sehr wenig Aufwand für mehrere Plattformen zu kompilieren.
Reiches Ökosystem von Bibliotheken: Es bietet ein reichhaltiges Ökosystem an Bibliotheken und Werkzeugen.
Spracheigenschaften
Go ist eine Sprache, die der C-Syntax relativ ähnlich ist.
Die Pakete
Ein Paket (package) ist eine Einheit der Modularität und Verteilung. Jede Go-Datei gehört zu einem Paket, und Pakete ermöglichen die Wiederverwendung von Code in strukturierter Weise.
- package main: Dieses spezielle Paket gibt den Einstiegspunkt eines ausführbaren Programms an. Wenn Du eine Anwendung entwickelst, muss sie das Paket main enthalten.
- Andere Pakete können importiert werden, um zusätzliche Funktionen bereitzustellen, wie z.B. fmt für die Ein-/Ausgabesteuerung.
Die Importe
Die Importe in Go ermöglichen die Verwendung externer Pakete oder Pakete aus der Standardbibliothek, um die Funktionalität deines Programms zu erweitern.
Zum Beispiel importiert der folgende Code ein Paket (fmt) aus der Standardbibliothek:
import "fmt"
Mehrfachimporte sind folgendermaßen möglich:
import (
"fmt"
"time"
)
Die Funktionen
Funktionen in Go sind Codeblöcke, die eine spezifische Aufgabe ausführen. Die Funktion main ist obligatorisch, da sie den Startpunkt jedes Go-Programms darstellt.
Die folgende Funktion, genannt Hello, nimmt einen Namen als Parameter und gibt eine Begrüßung zurück:
func hello(name string) string {
return "Hello, " + name
}
Die Variablen
Variablen werden mit dem Schlüsselwort var deklariert, können aber auch kürzer mit dem Operator := für eine implizite Deklaration definiert werden.
Das folgende Beispiel zeigt eine erste Variable, die explizit als Zeichenkette und eine zweite implizit als Ganzzahl deklariert wird.
var message string = "Hello World!"
nombre := 42
Der Typ
Go ist eine statisch typisierte Sprache: Jeder Variable wird beim Kompilieren ein Typ zugeordnet.
Der Kontrollfluss
In Go umfasst der Kontrollfluss die klassischen Anweisungen wie if…else, for und switch. Allerdings besitzt sie keine while-Schleife, obwohl for in ähnlicher Weise verwendet werden kann.
Hier druckt die Schleife die Zahlen von 0 bis 9 aus:
for i := 0; i < 10; i++ {
fmt.Println(i)
}
Die folgende if-Schleife zeigt an, ob die Zahl gerade oder ungerade ist:
number := 7
if number%2 == 0 {
fmt.Println("The number is even")
} else {
fmt.Println("The number is odd")
}
Die folgende switch-Anweisung bewertet den Wert in der Variablen day und führt den entsprechenden Block aus:
day := "tuesday"
switch day {
case "monday":
fmt.Println("Start of the week")
case "tuesday":
fmt.Println("Second day of the week")
case "wednesday":
fmt.Println("Middle of the week")
default:
fmt.Println("Day not specified")
}
Datenstrukturen
Es gibt mehrere mögliche Datenstrukturen, wie Arrays, Slices, Maps und Structs.
- Die slices bieten eine flexible Möglichkeit, Datenfolgen zu handhaben:
numbers := []int{1, 2, 3, 4, 5}
fmt.Println(numbers)
- Die maps sind eine Sammlung von Schlüssel-Wert-Paaren, ähnlich den Wörterbüchern in anderen Sprachen:
capitals := map[string]string{"France": "Paris", "Italy": "Roma"}
fmt.Println(capitals["France"])
Grundlegende Befehle
Golang verfügt über mehrere grundlegende Befehle, um die Verwaltung und Ausführung von Code zu erleichtern:
- go fmt: Formatiert den Go-Code automatisch, um ihn leichter lesbar zu machen.
- go run: Kompiliert und führt den Go-Code direkt aus.
- go test: Bietet ein integriertes Framework zum Schreiben und Ausführen von Unit-Tests.
- go build: Kompiliert den Quellcode, um eine ausführbare Datei zu erstellen.
capitals := map[string]string{"France": "Paris", "Italy": "Roma"}
fmt.Println(capitals["France"])
Goroutine und Konkurrenz
Eines der stärksten Merkmale von Go ist die Fähigkeit, mit Goroutinen Konkurrenz zu verwalten. Das sind Funktionen, die zeitgleich mit dem Rest des Programms ausgeführt werden. Um eine Goroutine zu starten, reicht es aus, einen Funktionsaufruf mit dem Schlüsselwort go zu präfixen.
Hier ein Beispiel:
package main
import (
"fmt"
"time"
)
func worker(mytask string) {
for i := 0; i < 3; i++ {
fmt.Printf("%s : iteration %d\n", mytask, i)
time.Sleep(500 * time.Millisecond)
}
}
func main() {
go worker("Task1")
go worker("Task2")
worker("Main task")
// Waiting for goroutine to end
time.Sleep(2 * time.Second)
}
Die Goroutinen Task1 und Task2 laufen parallel mit der Main task.
Fazit
Golang ist eine leistungsstarke Sprache. Ihre Einfachheit, die effektive Verwaltung von Konkurrenz durch Goroutinen und die Qualität ihrer Tools und Bibliotheken machen sie zu einer attraktiven Wahl für viele moderne Projekte.
