Go: Nachschlagen: Spickzettel

Kurz: import (“fmt”; “os”)

Teil des Kurses Go

Kapitel 11 von 11 im Kurs Go (Abschnitt „Nachschlagen“). Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Syntax auf einen Blick

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()

Typen und Zero-Werte

Typ	Nullwert
int, float64	0
string	""
bool	false
Zeiger, Slice, Map, Channel, Funktion, Interface	nil
Struct	alle Felder Nullwert

Eingebaute Funktionen

Funktion	Zweck
len, cap	Länge, Kapazität
append, copy	Slices erweitern, kopieren
make, new	Slices/Maps/Channels anlegen; Zeiger auf Nullwert
delete	Eintrag aus Map löschen
close	Channel schließen
panic, recover	Ausnahmesituationen
min, max, clear	Hilfen (Go 1.21)

Häufige Muster

package main
 
import (
    "errors"
    "fmt"
    "os"
    "strings"
)
 
func lese(pfad string) (n int, err error) {
    defer func() {
        if err != nil {
            err = fmt.Errorf("lese %s: %w", pfad, err)
        }
    }()
    daten, err := os.ReadFile(pfad)
    if err != nil {
        return 0, err
    }
    return len(strings.Fields(string(daten))), nil
}
 
func main() {
    _, err := lese("gibt-es-nicht.txt")
    fmt.Println(err != nil, errors.Is(err, os.ErrNotExist))
 
    // Slice filtern ohne neue Speicherallokation
    z := []int{1, 2, 3, 4, 5, 6}
    gerade := z[:0]
    for _, x := range z {
        if x%2 == 0 {
            gerade = append(gerade, x)
        }
    }
    fmt.Println(gerade, min(3, 1, 2), max(3, 1, 2))
}

Ausgabe:

true true
[2 4 6] 1 3

Konventionen

• gofmt ist Pflicht: Tabs, kein Streit um Stil
• Namen: camelCase (privat), PascalCase (exportiert), kurze Namen für kleine Gültigkeitsbereiche (i, err, ctx)
• Pakete: kurz, klein, ohne Unterstriche (strings, http)
• Fehler: kleingeschriebene Meldungen ohne Punkt ("datei nicht gefunden")
• Interfaces klein halten, im verbrauchenden Paket definieren
• context.Context als erster Parameter
• Ressourcen sofort mit defer schließen

Fehlermeldungen des Compilers

Meldung	Bedeutung
declared and not used	ungenutzte Variable
imported and not used	ungenutzter Import
undefined: x	Name unbekannt (Tippfehler? Import fehlt? klein geschrieben?)
cannot use x (variable of type A) as B value	Typen passen nicht
missing return	Funktion liefert nicht auf allen Wegen etwas
invalid operation: mismatched types int and float64	Typen mischen
panic: runtime error: index out of range	Zugriff außerhalb
panic: assignment to entry in nil map	Map nicht mit make angelegt
fatal error: all goroutines are asleep - deadlock!	alle warten aufeinander

Weiterlernen

• go.dev/tour: interaktive Tour durch die Sprache
• go.dev/doc/effective_go und Go by Example (gobyexample.com)
• pkg.go.dev: Dokumentation aller Pakete
• Buch: “The Go Programming Language” (Donovan, Kernighan)
• Üben: Exercism, Advent of Code, ein kleines CLI-Werkzeug oder eine REST-API schreiben

Quiz zur Selbstkontrolle

Welches Werkzeug formatiert Go-Code einheitlich?

• gofmt (go fmt) (richtig)
• prettier
• golint
• gopretty

Was bewirkt defer?

• Führt den Aufruf am Ende der Funktion aus (richtig)
• Verzögert die Funktion um eine Sekunde
• Startet eine Goroutine
• Überspringt den Aufruf

Wozu dient make?

• Slices, Maps und Channels anlegen (richtig)
• Programme bauen
• Dateien erstellen
• Objekte kopieren

Weiter im Kurs

Zurück: Tests, Benchmarks und Werkzeuge

Alle Kapitel: Go im Überblick