Go: Spickzettel

1. Was ist Go?

• Go ist kompiliert, schnell, einfach und für Server und Cloud gebaut
• go run, go build, go test, go fmt sind die Alltagswerkzeuge
• Ein Programm beginnt in package main mit func main()
• Ungenutzte Variablen und Importe sind Fehler
• Stärken: Goroutinen, Standardbibliothek, ein einziges Binärprogramm

package main

import "fmt"

func main() {
    fmt.Println("Hallo, Welt!")
}

2. Variablen, Typen und Konstanten

• Deklaration mit var oder Kurzform := (nur in Funktionen); jede Variable hat einen Nullwert
• Keine automatischen Typumwandlungen: float64(i), strconv.Atoi
• const mit iota für Aufzählungen
• Strings sind UTF-8-Bytes; rune und range für Zeichen
• fmt.Printf mit Verben %v %d %s %f %T

package main

import "fmt"

func main() {
    var alter int = 17           // ausführlich
    var preis = 19.99            // Typ wird erkannt (float64)
    name := "Mia"                // Kurzform: nur in Funktionen
    var a, b int = 1, 2
    x, y := 3.5, "text"
    var leer int                 // Nullwert: 0
    var text string              // Nullwert: ""
    var ok bool                  // Nullwert: false

    const Pi = 3.14159
    const (
        Montag = iota            // 0
        Dienstag                 // 1
        Mittwoch                 // 2
    )

    fmt.Println(alter, preis, name, a, b, x, y)
    fmt.Printf("%d %q %t | %.2f | %d %d %d\n", leer, text, ok, Pi, Montag, Dienstag, Mittwoch)
    fmt.Printf("Typen: %T %T %T %T\n", alter, preis, name, ok)
}

3. Bedingungen, Schleifen und switch

• if ohne Klammern, mit optionaler Kurzdeklaration (if n, err := ...; err != nil)
• for ist die einzige Schleife: klassisch, als while, range, endlos
• switch ohne break; Typ-Switch mit x.(type)
• defer führt Aufräumcode am Funktionsende aus (rückwärts)
• break/continue mit Marken für verschachtelte Schleifen

package main

import (
    "fmt"
    "strconv"
)

func main() {
    punkte := 73
    if punkte >= 90 {
        fmt.Println("sehr gut")
    } else if punkte >= 50 {
        fmt.Println("bestanden")
    } else {
        fmt.Println("nicht bestanden")
    }

    // if mit Kurzdeklaration: n gilt nur im if/else
    if n, err := strconv.Atoi("42"); err != nil {
        fmt.Println("Fehler:", err)
    } else if n > 40 {
        fmt.Println("groß:", n)
    }
}

4. Funktionen und Fehlerbehandlung

• Mehrere Rückgabewerte; der letzte ist bei fehlbaren Funktionen ein error
• Fehler sind normale Werte: if err != nil { return ..., err }
• fmt.Errorf("... %w", err) packt Kontext ein; errors.Is/errors.As werten aus
• Funktionen sind Werte und können Closures sein
• panic und recover nur für Ausnahmesituationen

package main

import "fmt"

func addiere(a, b int) int { return a + b }

// Mehrere Rückgabewerte
func teile(a, b int) (int, int) { return a / b, a % b }

// Benannte Rückgabewerte
func minMax(zahlen []int) (min, max int) {
    min, max = zahlen[0], zahlen[0]
    for _, z := range zahlen[1:] {
        if z < min {
            min = z
        }
        if z > max {
            max = z
        }
    }
    return // gibt min und max zurück
}

// Variable Anzahl Argumente
func summe(zahlen ...int) int {
    s := 0
    for _, z := range zahlen {
        s += z
    }
    return s
}

func main() {
    fmt.Println(addiere(3, 4))
    q, r := teile(17, 5)
    fmt.Println(q, r)
    lo, hi := minMax([]int{5, 3, 9, 1})
    fmt.Println(lo, hi)
    fmt.Println(summe(), summe(1, 2, 3), summe([]int{4, 5}...))
}

5. Arrays, Slices und Maps

• Arrays haben feste Länge; Slices ([]T) wachsen mit append und sind Sichten auf Arrays
• len, cap, copy, make; Teil-Slices teilen sich den Speicher
• Maps: m[k], v, ok := m[k], delete; Reihenfolge ist zufällig
• Pakete slices und maps (Go 1.21) bieten Sortieren, Suchen, Einfügen
• Eine nil-Map nimmt keine Schreibzugriffe an: vorher make

package main

import "fmt"

func main() {
    var a [3]int // Array: feste Länge, Nullwerte
    a[0] = 10
    fmt.Println(a, len(a))

    s := []int{5, 3, 9} // Slice: wachsend
    s = append(s, 1, 7)
    fmt.Println(s, len(s), cap(s))
    fmt.Println(s[1:3], s[:2], s[2:], s[len(s)-1])

    leer := make([]int, 3, 10) // Länge 3, Kapazität 10
    fmt.Println(leer, len(leer), cap(leer))

    var nichts []int // nil-Slice: len 0, funktioniert mit append
    fmt.Println(nichts == nil, len(nichts))
    nichts = append(nichts, 1)
    fmt.Println(nichts)

    kopie := make([]int, len(s))
    n := copy(kopie, s)
    kopie[0] = 99
    fmt.Println(n, s[0], kopie[0])
}

6. Structs, Methoden und Zeiger

• type Name struct { ... } bündelt Daten; Methoden stehen außerhalb: func (p Person) Methode()
• Zeiger-Empfänger (p *Person) ändern das Original, Wert-Empfänger arbeiten auf einer Kopie
• &x Adresse, *p Wert; keine Zeigerarithmetik; automatisches Dereferenzieren bei Feldzugriff
• Konstruktoren sind NewXyz-Funktionen; Einbettung ersetzt Vererbung
• Großbuchstabe = exportiert; Struct-Tags steuern z. B. JSON

package main

import "fmt"

type Person struct {
    Name  string
    Alter int
}

// Methode mit Wert-Empfänger: arbeitet auf einer Kopie
func (p Person) Vorstellen() string {
    return fmt.Sprintf("%s (%d)", p.Name, p.Alter)
}

// Methode mit Zeiger-Empfänger: kann das Original ändern
func (p *Person) Geburtstag() {
    p.Alter++
}

func main() {
    mia := Person{Name: "Mia", Alter: 17}
    tom := Person{"Tom", 19}
    var leer Person // Nullwerte: "" und 0
    mia.Geburtstag()
    fmt.Println(mia.Vorstellen(), tom, leer)
    fmt.Printf("%+v\n", mia)

    p := &tom // Zeiger auf Person
    p.Alter = 30 // Go dereferenziert automatisch
    fmt.Println(tom.Alter, (*p).Alter)

    n := new(Person) // Zeiger auf Nullwert
    n.Name = "Neu"
    fmt.Println(*n)
}

7. Interfaces und Generics

• Interfaces sind Methodenmengen; Typen erfüllen sie implizit
• Kleine Interfaces (io.Reader, error, fmt.Stringer) sind am besten
• Typzusicherung x.(T) und Typ-Switch prüfen den konkreten Typ
• Ein Interface mit typisiertem nil-Zeiger ist nicht nil
• Generics: func F[T any](x T), mit Einschränkungen (cmp.Ordered, eigene Interfaces)

package main

import (
    "fmt"
    "math"
)

type Form interface {
    Flaeche() float64
    Umfang() float64
}

type Kreis struct{ R float64 }
type Rechteck struct{ B, H float64 }

func (k Kreis) Flaeche() float64    { return math.Pi * k.R * k.R }
func (k Kreis) Umfang() float64     { return 2 * math.Pi * k.R }
func (r Rechteck) Flaeche() float64 { return r.B * r.H }
func (r Rechteck) Umfang() float64  { return 2 * (r.B + r.H) }

func beschreibe(f Form) {
    fmt.Printf("%T: Fläche %.2f, Umfang %.2f\n", f, f.Flaeche(), f.Umfang())
}

func main() {
    formen := []Form{Kreis{1}, Rechteck{3, 4}}
    for _, f := range formen {
        beschreibe(f)
    }
}

8. Goroutinen, Channels und Synchronisation

• go f() startet eine Goroutine; sync.WaitGroup wartet
• Channels (chan T) übertragen Werte; close, range, select
• Datenwettläufe vermeiden mit Mutex, atomic oder Channels; Test mit -race
• context für Abbruch und Zeitlimits
• Goroutinen sind billig, aber nicht kostenlos: begrenzen und beenden

package main

import (
    "fmt"
    "sync"
    "time"
)

func arbeite(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    time.Sleep(time.Duration(id) * 10 * time.Millisecond)
    fmt.Println("Goroutine", id, "fertig")
}

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go arbeite(i, &wg)
    }
    wg.Wait() // wartet, bis alle fertig sind
    fmt.Println("alle fertig")
}

9. Pakete, Module und Standardbibliothek

• Module (go.mod) enthalten Pakete (Ordner); exportiert wird, was mit Großbuchstaben beginnt
• go mod init, go get, go mod tidy
• os, bufio, encoding/json, time, net/http decken viele Alltagsaufgaben ab
• Zeitformate nutzen das Beispieldatum 02.01.2006 15:04:05
• Ein Webserver braucht nur net/http

go mod init beispiel.de/rechner      # legt go.mod an

10. Tests, Benchmarks und Werkzeuge

• Tests: Datei x_test.go, Funktion TestXyz(t *testing.T), Start mit go test ./...
• Tabellengetriebene Tests mit t.Run sind der Standard
• -race und -cover bei jedem Testlauf
• Interfaces erleichtern Attrappen (Fakes)
• go fmt, go vet, golangci-lint halten den Code sauber

// mathe/mathe.go
package mathe

func Addiere(a, b int) int { return a + b }

func Teile(a, b int) (int, error) {
    if b == 0 {
        return 0, ErrDivisionDurchNull
    }
    return a / b, nil
}

// mathe/mathe_test.go
package mathe

import "testing"

func TestAddiere(t *testing.T) {
    if got := Addiere(2, 3); got != 5 {
        t.Errorf("Addiere(2, 3) = %d, erwartet 5", got)
    }
}

func TestTeileDurchNull(t *testing.T) {
    _, err := Teile(1, 0)
    if err == nil {
        t.Fatal("Fehler erwartet")
    }
}

11. Nachschlagen: Spickzettel

package main

import ("fmt"; "os")

const Pi = 3.14
var x int = 5
y := 7                                  // Kurzform

type Punkt struct{ X, Y int }
type Form interface{ Flaeche() float64 }
type ID int

func (p Punkt) Laenge() float64 { ... }     // Wert-Empfänger
func (p *Punkt) Verschiebe()    { ... }     // Zeiger-Empfänger

func f(a int, b ...string) (int, error) { return 0, nil }

if x > 0 { } else if x < 0 { } else { }
for i := 0; i < 10; i++ { }
for k, v := range m { }
for i := range 5 { }
switch x { case 1, 2: ...; default: ... }
switch v := i.(type) { case int: ... }

go f()                                  // Goroutine
ch := make(chan int, 4); ch <- 1; v := <-ch
select { case v := <-ch: ... ; default: ... }
defer f()