Funktionen und Fehlerbehandlung

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

7
3 2
1 9
0 6 9

package main

import "fmt"

func wende(f func(int) int, x int) int { return f(x) }

func zaehlerErstellen() func() int { // Closure
    n := 0
    return func() int {
        n++
        return n
    }
}

func main() {
    quadrat := func(x int) int { return x * x }
    fmt.Println(wende(quadrat, 7), wende(func(x int) int { return x + 1 }, 7))
    z := zaehlerErstellen()
    fmt.Println(z(), z(), z())
    func() { fmt.Println("sofort aufgerufen") }()
}

49 8
1 2 3
sofort aufgerufen

package main

import (
    "errors"
    "fmt"
    "strconv"
)

var ErrNegativ = errors.New("negative Zahl") // Sentinel-Fehler

func wurzelInt(s string) (int, error) {
    n, err := strconv.Atoi(s)
    if err != nil {
        return 0, fmt.Errorf("wurzelInt: ungültige Eingabe %q: %w", s, err) // %w: Ursache einpacken
    }
    if n < 0 {
        return 0, ErrNegativ
    }
    r := 0
    for (r+1)*(r+1) <= n {
        r++
    }
    return r, nil
}

func main() {
    for _, eingabe := range []string{"49", "-4", "abc"} {
        r, err := wurzelInt(eingabe)
        if err != nil {
            fmt.Println("Fehler:", err)
            if errors.Is(err, ErrNegativ) {
                fmt.Println("  -> war negativ")
            }
            var numErr *strconv.NumError
            if errors.As(err, &numErr) {
                fmt.Println("  -> Zahlenfehler bei", numErr.Num)
            }
            continue
        }
        fmt.Println("Wurzel:", r)
    }
}

Wurzel: 7
Fehler: negative Zahl
  -> war negativ
Fehler: wurzelInt: ungültige Eingabe "abc": strconv.Atoi: parsing "abc": invalid syntax
  -> Zahlenfehler bei abc

package main

import (
    "errors"
    "fmt"
)

type GuthabenFehler struct {
    Fehlbetrag float64
}

func (e *GuthabenFehler) Error() string {
    return fmt.Sprintf("zu wenig Guthaben, es fehlen %.2f", e.Fehlbetrag)
}

func abheben(stand, betrag float64) (float64, error) {
    if betrag > stand {
        return stand, &GuthabenFehler{betrag - stand}
    }
    return stand - betrag, nil
}

func main() {
    if _, err := abheben(100, 130); err != nil {
        var gf *GuthabenFehler
        if errors.As(err, &gf) {
            fmt.Println(err, "|", gf.Fehlbetrag)
        }
    }
}

zu wenig Guthaben, es fehlen 30.00 | 30

package main

import "fmt"

func sicher(f func()) (err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("abgefangen: %v", r)
        }
    }()
    f()
    return nil
}

func main() {
    fmt.Println(sicher(func() { fmt.Println("alles gut") }))
    fmt.Println(sicher(func() {
        var feld []int
        _ = feld[5] // index out of range -> panic
    }))
    fmt.Println(sicher(func() { panic("selbst ausgelöst") }))
}

alles gut
<nil>
abgefangen: runtime error: index out of range [5] with length 0
abgefangen: selbst ausgelöst