Was ist Golang? Die Go Programmiersprache mit Beispielen erklärt

Go ist eine statisch typisierte, kompilierte Programmiersprache, die bei Google entstanden ist. Sie erzeugt ein einzelnes natives Binary, kompiliert in Sekunden, hat Garbage Collection und bringt Nebenläufigkeit über Goroutinen und Channels direkt in der Sprache mit. Ihr Hauptrevier ist serverseitige Software: APIs, Netzwerkdienste und die Kommandozeilen- und Cloud-Tools, die sie betreiben.

Hier ist ein vollständiges Go-Programm. Klick auf Run.

package main

import (
	"fmt"
	"strings"
)

func main() {
	languages := []string{"Go", "Python", "Rust"}

	for i, name := range languages {
		fmt.Printf("%d: %s has %d letters\n", i, name, len(name))
	}

	fmt.Println(strings.ToUpper("compiled, typed, garbage collected"))
}

Jedes Go-Programm startet in package main bei func main(). := deklariert eine Variable und leitet ihren Typ ab (hier []string, ein Slice von Strings). range durchläuft den Slice und liefert dir einen Index und einen Wert. fmt und strings kommen aus der Standardbibliothek, die so groß ist, dass viele Programme nichts anderes importieren.

Go vs Golang: der Name

Die Sprache heißt Go. „Golang“ ist ein Spitzname von der ersten Website des Projekts, golang.org (die Seite liegt heute unter go.dev). Er blieb im Gebrauch, weil eine Websuche nach „go“ alles liefert außer der Sprache. Die offizielle Dokumentation sagt „Go“, aber „golang“ ist das Wort, das fast jeder ins Suchfeld tippt, und beide meinen dasselbe. Ein eigenes Produkt oder einen Dialekt namens „Golang“ gibt es nicht.

Wer Go entwickelt hat und warum

Robert Griesemer, Rob Pike und Ken Thompson haben 2007 bei Google begonnen, Go zu entwerfen. Im November 2009 wurde es als Open Source veröffentlicht, und Go 1.0 erschien im März 2012.

Die Motivation war praktisch. Die großen C++- und Java-Codebasen bei Google brauchten lange zum Bauen, Abhängigkeitsgraphen waren schwer zu verwalten, und Mehrkernrechner und vernetzte Dienste waren die Regel, aber nebenläufiger Code war fehleranfällig. Das Design von Go beantwortet diese Probleme direkt:

• Schnelle Builds. Imports sind explizit, ungenutzte Imports sind ein Compilerfehler, und der Compiler parst keine Header erneut, also bauen große Programme in Sekunden.
• Einfache Sprache. Wenige Schlüsselwörter, eine Schleife (for), keine Vererbung, keine Exceptions. Code verschiedener Leute sieht tendenziell gleich aus, und das hilft bei Reviews in einem großen Team.
• Nebenläufigkeit als Sprachfeature. Eine nebenläufige Aufgabe zu starten ist ein Schlüsselwort, go, und über Channels kommunizieren Aufgaben miteinander.
• Einfaches Deployment. Das Ergebnis ist ein Binary, das du auf einen Server kopierst. Es ist meist statisch gelinkt; mit aktiviertem cgo können Pakete wie net gegen die C-Bibliothek des Systems linken, und CGO_ENABLED=0 schaltet das ab.

Mit Go 1.0 kam außerdem das Kompatibilitätsversprechen von Go 1: Programme, die für Go 1.0 geschrieben wurden, kompilieren und laufen auch mit späteren 1.x-Releases. In der Praxis bricht ein Update der Toolchain deinen Code also selten, und das ist ein wichtiger Grund, warum Teams Go für langlebige Dienste vertrauen.

Wofür Golang verwendet wird

Go ist am stärksten dort, wo ein Programm übers Netzwerk kommuniziert, lange läuft und leicht auszuliefern sein muss:

Weniger gut passt es zu Desktop-Apps mit GUI, mobilen Apps, Frontends im Browser und numerischer Arbeit oder Machine Learning, wo andere Ökosysteme viel bessere Bibliotheken haben.

Die wichtigsten Features, mit Code

Statische Typen mit Inferenz

Jede Variable hat einen Typ, der zur Compilezeit feststeht, aber du schreibst ihn selten aus. := leitet ihn ab:

package main

import "fmt"

func main() {
	count := 3         // int
	price := 9.99      // float64
	name := "keyboard" // string
	inStock := true    // bool

	fmt.Printf("%T %T %T %T\n", count, price, name, inStock)

	total := float64(count) * price
	fmt.Printf("%d x %s = %.2f\n", count, name, total)
}

Go konvertiert nie still zwischen Zahlentypen. count * price kompiliert nicht, weil der eine Wert ein int und der andere ein float64 ist; du schreibst float64(count) selbst. Das schließt stille Abschneide- und Genauigkeitsfehler aus.

Fehler sind Werte

Go hat keine Exceptions. Eine Funktion, die fehlschlagen kann, gibt als letztes Ergebnis einen error zurück, und der Aufrufer prüft ihn:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	inputs := []string{"42", "forty-two"}

	for _, s := range inputs {
		n, err := strconv.Atoi(s)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("parsed:", n*2)
	}
}

Das Muster if err != nil ist die bekannteste Zeile in Go-Code. Es ist wortreich, und genau das ist der Sinn: Jede Stelle, an der ein Programm fehlschlagen kann, ist dort sichtbar, wo es passiert. Wrapping und Untersuchung von Fehlern stehen auf der Seite zur Fehlerbehandlung.

Goroutinen und Channels

Eine Goroutine ist eine Funktion, die nebenläufig zum Rest des Programms läuft. Sie kostet ein paar Kilobyte Stack, also sind Tausende davon normal. Channels übergeben Werte sicher zwischen Goroutinen:

package main

import "fmt"

func square(n int, results chan<- string) {
	results <- fmt.Sprintf("%d squared is %d", n, n*n)
}

func main() {
	results := make(chan string)

	for n := 1; n <= 3; n++ {
		go square(n, results)
	}

	for range 3 {
		fmt.Println(<-results)
	}
}

Die drei Goroutinen laufen nebenläufig, also können die drei Zeilen in beliebiger Reihenfolge erscheinen. Führ es ein paarmal aus, und du siehst womöglich verschiedene Reihenfolgen. main empfängt genau drei Werte und wartet daher auf alle, bevor es sich beendet.

Interfaces ohne „implements“

Ein Typ erfüllt ein Interface einfach dadurch, dass er die passenden Methoden hat. Ein Schlüsselwort implements gibt es nicht:

package main

import (
	"fmt"
	"math"
)

type Shape interface {
	Area() float64
}

type Rect struct{ W, H float64 }
type Circle struct{ R float64 }

func (r Rect) Area() float64   { return r.W * r.H }
func (c Circle) Area() float64 { return math.Pi * c.R * c.R }

func main() {
	shapes := []Shape{Rect{W: 3, H: 4}, Circle{R: 1}}
	for _, s := range shapes {
		fmt.Printf("%T area: %.2f\n", s, s.Area())
	}
}

Rect und Circle erwähnen Shape nie, und trotzdem lassen sich beide in einem []Shape speichern. So kannst du ein Interface in dem Paket definieren, das es benutzt, lange nachdem die konkreten Typen geschrieben wurden.

Eine Toolchain

Der Befehl go erledigt alles: go run kompiliert und führt aus, go build erzeugt ein Binary, go test führt Tests aus, go fmt formatiert Code, go vet findet verdächtige Konstrukte, und go mod verwaltet Abhängigkeiten. Es gibt einen offiziellen Formatierungsstil, den gofmt durchsetzt, also streiten Go-Projekte nicht über Klammern oder Einrückung.

Was Go absichtlich weglässt

Manche Features, die in anderen Sprachen üblich sind, fehlen mit Absicht:

• Keine Klassen und keine Vererbung. Du nutzt Structs, Methoden, Interfaces und Embedding.
• Keine Exceptions. Fehler sind Rückgabewerte. panic gibt es, aber für Bugs, nicht für gewöhnliche Fehlschläge.
• Kein ternärer Operator. Du schreibst ein if/else.
• Kein Schlüsselwort while. for deckt jede Schleife ab.
• Keine Funktionsüberladung und keine Standardargumente.
• Generics erst seit Go 1.18, und bewusst eingeschränkt im Vergleich zu C++-Templates oder Java-Generics.

Ehrliche Kompromisse

Wortreichtum. Explizite Fehlerprüfungen und fehlende Abkürzungen wie der ternäre Operator machen Go-Code länger als vergleichbaren Code in Python oder Kotlin. Lesen ist leicht; Schreiben braucht mehr Zeilen.

Garbage Collection. Der Collector von Go hat kurze Pausen, bleibt aber ein Garbage Collector. Für harte Echtzeitsysteme oder Code, bei dem jede Allokation zählt, geben dir C, C++ oder Rust mehr Kontrolle.

nil-Werte. Go hat nil-Pointer, -Maps, -Slices und -Interfaces. Eine Nil-Pointer-Dereferenzierung ist eine Panic zur Laufzeit, und der Compiler verhindert sie nicht so, wie es das Typsystem von Rust tut.

Ein kleines Typsystem. Keine Summentypen, keine Enums (du baust sie mit Konstanten und iota), und Generics, die die üblichen Fälle abdecken, aber keine fortgeschrittene Programmierung auf Typebene.

Lücken im Ökosystem. Bibliotheken für Webdienste, Datenbanken und Cloud-APIs sind hervorragend. Für GUIs, wissenschaftliches Rechnen und Machine Learning haben Python, C++ oder Julia weit mehr zu bieten.

Go im Vergleich mit anderen Sprachen

Nimm Go, wenn du kompilierte Performance und einfaches Deployment willst, ohne die Lernkurve von Rust oder die Zeremonie von Java.

Lohnt es sich, Go zu lernen?

Wenn du Backend-Dienste, Kommandozeilentools oder irgendetwas im Bereich Cloud-Infrastruktur schreibst, ja. Ein großer Teil dieses Ökosystems ist in Go geschrieben, und seinen Quellcode zu lesen gehört zum Job. Die Sprache ist klein, also hält sich der Aufwand in Grenzen: Die Kernsyntax dauert Tage, idiomatische Nebenläufigkeit und Fehlerbehandlung ein paar Wochen Übung.

Um lokal Go zu schreiben, installier Go und arbeite dann die Seite zu Hello World durch, die jede Zeile eines ersten Programms erklärt.