Das `time`-Package

Das time-Paket modelliert drei unterschiedliche Konzepte: Momente (time.Time), Dauer (time.Duration) und periodische Tools (Timer, Ticker). Ihre Unterscheidung ist entscheidend: Ein Augenblick ist ein Punkt auf der Zeitachse, eine Dauer ist ein Intervall.

time.Time – Augenblicke

now := time.Now()                // current instant in the local timezone
utc := now.UTC()                 // same instant in UTC
later := now.Add(2 * time.Hour)  // add a duration
diff := later.Sub(now)           // 2h0m0s (it's a Duration)

fmt.Println(now.Year(), now.Month(), now.Day())
fmt.Println(now.Weekday())

time.Time ist unveränderlich: Alle Methoden Add, Truncate, Round geben einen neuen Time zurück.

Um Zeitpunkte zu vergleichen, verwenden Sie Before, After, Equal. Verwenden Sie == nicht, wenn die Zeitpunkte unterschiedliche Zeitzonen/monotone Uhren haben können.

time.Duration – Intervalle

d := 250 * time.Millisecond
fmt.Println(d)         // 250ms
fmt.Println(d.Seconds()) // 0.25 (float64)

const timeout = 5 * time.Second

time.Duration ist ein Alias ​​von int64, der Nanosekunden zählt. Die Konstanten time.Nanosecond, time.Microsecond, time.Millisecond, time.Second, time.Minute, time.Hour sind vom Typ Duration.

Parsen und Formatieren: das Referenzlayout

Go verwendet keine Zeichenfolgen wie YYYY-MM-DD. Es verwendet einen kanonischen Referenzzeitpunkt:

Mon Jan 2 15:04:05 MST 2006

d.h. 01/02 03:04:05PM '06 -0700. Durch Auswendiglernen dieses Layouts (Mnemonik: 1-2-3-4-5-6-7) können Sie jedes Datum formatieren:

const layout = "2006-01-02 15:04:05"
s := time.Now().Format(layout)            // "2026-05-16 14:30:00"
t, err := time.Parse(layout, "2026-05-16 14:30:00")

Die stdlib bietet vorgefertigte Layouts: time.RFC3339 ("2006-01-02T15:04:05Z07:00"), time.RFC1123, time.Kitchen ("3:04PM").

fmt.Println(time.Now().Format(time.RFC3339))

Zeit messen

start := time.Now()
work()
elapsed := time.Since(start)  // = time.Now().Sub(start)
fmt.Println("ci ha messo", elapsed)

time.Since verwendet die monotone Uhr: Sie wird nicht durch Systemuhreinstellungen (NTP, Sommerzeit) gestört. Für Leistungsmessungen ist das genau das, was Sie wollen.

Timer und Ticker

– time.After(d) gibt einen chan time.Time zurück, der nur einmal nach d empfängt. Nützlich in select:

select {
case res := <-ch:
    fmt.Println("ok", res)
case <-time.After(2 * time.Second):
    return errors.New("timeout")
}

• time.NewTimer(d) ist eine stoppbare Variante (t.Stop()).
• time.NewTicker(d) sendet wiederholt jeden d. Denken Sie an defer ticker.Stop(), um Goroutine-Lecks zu vermeiden.

ticker := time.NewTicker(time.Second)
defer ticker.Stop()
for range ticker.C {
    fmt.Println("tick")
}

Übungen

d := time.Second
// d ha tipo ???