Go: Bedingungen, Schleifen und switch

Kurz: import ( “fmt” “strconv” )

Teil des Kurses Go

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

if

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

Ausgabe:

bestanden
groß: 42

Die Bedingung steht ohne Klammern, die { } sind Pflicht. Es gibt keinen ? :-Operator.

for: die einzige Schleife

Go kennt nur for, in mehreren Formen:

package main
 
import "fmt"
 
func main() {
    for i := 1; i <= 5; i++ { // klassisch
        fmt.Print(i, " ")
    }
    fmt.Println()
 
    n := 1
    for n < 100 { // wie while
        n *= 2
    }
    fmt.Println(n)
 
    farben := []string{"rot", "grün", "blau"}
    for i, f := range farben { // über Slices
        fmt.Print(i, "=", f, " ")
    }
    fmt.Println()
 
    for _, f := range farben { // Index ignorieren mit _
        fmt.Print(f, " ")
    }
    fmt.Println()
 
    for i := range 3 { // über Zahlen (Go 1.22)
        fmt.Print(i, " ")
    }
    fmt.Println()
 
    zaehler := 0
    for { // Endlosschleife mit break
        zaehler++
        if zaehler == 3 {
            break
        }
    }
    fmt.Println(zaehler)
 
    for i := 1; i <= 10; i++ {
        if i%2 == 0 {
            continue
        }
        if i > 7 {
            break
        }
        fmt.Print(i, " ")
    }
    fmt.Println()
}

Ausgabe:

1 2 3 4 5
128
0=rot 1=grün 2=blau
rot grün blau
0 1 2
3
1 3 5 7

switch

package main
 
import "fmt"
 
func beschreibe(x any) string {
    switch v := x.(type) { // Typ-Switch
    case int:
        return fmt.Sprintf("int %d", v)
    case string:
        return "string " + v
    case []int:
        return fmt.Sprintf("Slice mit %d Elementen", len(v))
    case nil:
        return "nil"
    default:
        return fmt.Sprintf("etwas anderes: %T", v)
    }
}
 
func main() {
    tag := 6
    switch tag { // kein break nötig, kein Durchfallen
    case 1:
        fmt.Println("Montag")
    case 6, 7:
        fmt.Println("Wochenende")
    default:
        fmt.Println("Werktag")
    }
 
    punkte := 82
    switch { // ohne Ausdruck: wie if-else-Kette
    case punkte >= 90:
        fmt.Println("1")
    case punkte >= 75:
        fmt.Println("2")
        fallthrough // ausdrücklich in den nächsten Fall
    case punkte >= 60:
        fmt.Println("(auch 3 erreicht)")
    default:
        fmt.Println("schlechter")
    }
 
    fmt.Println(beschreibe(42), "|", beschreibe("hi"), "|", beschreibe([]int{1, 2}), "|", beschreibe(nil), "|", beschreibe(3.5))
}

Ausgabe:

Wochenende
2
(auch 3 erreicht)
int 42 | string hi | Slice mit 2 Elementen | nil | etwas anderes: float64

In Go endet jeder case automatisch; ein ausdrückliches fallthrough ist selten nötig.

defer

defer verschiebt einen Aufruf bis zum Ende der Funktion. Ideal zum Aufräumen (Dateien schließen, Sperren freigeben):

package main
 
import "fmt"
 
func main() {
    defer fmt.Println("3: zuletzt (defer)")
    defer fmt.Println("2: davor (defer läuft rückwärts)")
    fmt.Println("1: normale Ausgabe")
    for i := 0; i < 3; i++ {
        defer fmt.Print("d", i, " ")
    }
}

Ausgabe:

1: normale Ausgabe
d2 d1 d0 2: davor (defer läuft rückwärts)
3: zuletzt (defer)

Marken und goto

Mit Marken verlässt man verschachtelte Schleifen:

package main
 
import "fmt"
 
func main() {
aussen:
    for a := 1; a < 10; a++ {
        for b := 1; b < 10; b++ {
            if a*b == 42 {
                fmt.Println(a, "*", b)
                break aussen
            }
        }
    }
}

Ausgabe:

6 * 7

Merke

• 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

Übungsaufgabe

Gib alle Zahlen von 1 bis 30 aus und ersetze Vielfache von 3 durch “Fizz”, von 5 durch “Buzz” und von beidem durch “FizzBuzz”.

Quiz zur Selbstkontrolle

Welche Schleifenart gibt es in Go?

• Nur for (in mehreren Formen) (richtig)
• for und while
• for, while, do-while
• Nur while

Wann läuft ein defer-Aufruf?

• Am Ende der umgebenden Funktion (richtig)
• Sofort
• Beim Programmstart
• Nie

Muss man in einem Go-switch break schreiben?

• Nein, jeder case endet automatisch (richtig)
• Ja, immer
• Nur bei Strings
• Nur beim letzten case

Weiter im Kurs

Zurück: Variablen, Typen und Konstanten

Weiter: Funktionen und Fehlerbehandlung

Alle Kapitel: Go im Überblick