Golang Time: Now, Sleep, Format, Parse und Durations

Die Grundlagen in einem Programm

package main

import (
	"fmt"
	"time"
)

func main() {
	start := time.Now()

	time.Sleep(50 * time.Millisecond)

	elapsed := time.Since(start)
	fmt.Println("slept at least 50ms:", elapsed >= 50*time.Millisecond)

	t := time.Date(2026, time.September, 23, 14, 30, 0, 0, time.UTC)
	fmt.Println(t)
	fmt.Println(t.Format("2006-01-02 15:04"))
	fmt.Println(t.Format("Monday, January 2, 2006"))
	fmt.Println("in 90 minutes:", t.Add(90*time.Minute).Format(time.Kitchen))
}

time.Now() gibt die aktuelle lokale Zeit zurück, time.Sleep pausiert die aktuelle Goroutine, time.Since misst die vergangene Zeit, und time.Date baut einen bestimmten Zeitpunkt. Der Rest dieser Seite nimmt sich jedes Stück einzeln vor. Die Beispiele nutzen feste Daten und UTC, damit ihre Ausgabe überall gleich ist, wo du sie ausführst.

Sleep und Duration

Eine time.Duration ist eine int64-Anzahl von Nanosekunden. Das Paket definiert Konstanten, mit denen du lesbare Werte baust:

Ein time.Day gibt es nicht, weil ein Tag nicht immer 24 Stunden hat, wenn eine Zeitzone auf Sommerzeit umstellt. Für Kalendertage nimm AddDate (siehe unten).

package main

import (
	"fmt"
	"time"
)

func main() {
	d := 90 * time.Minute
	fmt.Println(d)                      // 1h30m0s
	fmt.Println(d.Hours(), d.Minutes()) // float64 values
	fmt.Println(2*time.Hour + 15*time.Second)

	// Multiplying by a variable needs a conversion: int * Duration does not compile.
	retries := 3
	backoff := time.Duration(retries) * 200 * time.Millisecond
	fmt.Println("backoff:", backoff)

	// Parse a duration from a string (for flags and config files).
	timeout, err := time.ParseDuration("1m30s")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("timeout:", timeout, "=", timeout.Seconds(), "seconds")

	// Round and truncate a measured duration for display.
	measured := 1234567891 * time.Nanosecond
	fmt.Println(measured, measured.Round(time.Millisecond), measured.Truncate(time.Second))
}

Zwei häufige Bugs kommen daher, dass Duration eine Ganzzahl ist:

• time.Sleep(5) schläft 5 Nanosekunden. Multipliziere immer mit einer Einheit: time.Sleep(5 * time.Second).
• time.Sleep(n * time.Second) kompiliert nicht, wenn n eine int-Variable ist. Konvertiere sie: time.Duration(n) * time.Second. Eine Konstante wie 5 funktioniert ohne Konvertierung, weil sich untypisierte Konstanten an den Typ Duration anpassen.

ParseDuration akzeptiert ns, us (oder µs), ms, s, m und h, kombiniert wie "2h45m" oder "1.5s". Eine Einheit für Tage hat es nicht.

Formatieren: das Referenzlayout 2006-01-02

Go verwendet weder %Y-%m-%d noch yyyy-MM-dd. Ein Layout ist die Referenzzeit

Mon Jan 2 15:04:05 MST 2006

geschrieben so, wie deine Ausgabe aussehen soll. Die Werte sind so gewählt, dass jeder eindeutig ist: Monat 1, Tag 2, Stunde 3 (oder 15), Minute 4, Sekunde 5, Jahr 6 (2006), Zonen-Offset -7 (-0700). Lies es als 01/02 03:04:05PM '06 -0700.

package main

import (
	"fmt"
	"time"
)

func main() {
	t := time.Date(2026, time.March, 5, 9, 7, 3, 250_000_000, time.UTC)

	layouts := []string{
		"2006-01-02",
		"02/01/2006",
		"01/02/06",
		"Jan 2, 2006",
		"Monday 2 January 2006",
		"15:04:05",
		"3:04 PM",
		"2006-01-02T15:04:05.000Z07:00",
		time.RFC3339,
		time.DateTime,
		time.RFC1123,
	}
	for _, l := range layouts {
		fmt.Printf("%-32q %s\n", l, t.Format(l))
	}
}

Die Layout-Tokens, die du am häufigsten brauchst:

Vordefinierte Layouts:

Der klassische Fehler ist ein Layout mit den falschen Zahlen, zum Beispiel "2023-01-01". Go lehnt es nicht ab. Es kopiert Zeichen, die es nicht erkennt, und ersetzt die, die es erkennt: Jede 2 ist der Tag, 3 die Stunde im 12-Stunden-Format, und beide 01 sind der Monat, also wird der 5. März um 9:07 als 5059-03-03 formatiert. Ein Layout wie "YYYY-MM-DD" enthält gar keine Tokens und gibt sich selbst unverändert aus. Sehen formatierte Datumsangaben seltsam aus, prüf, ob das Layout genau die Referenzwerte verwendet.

Strings in Zeiten parsen

time.Parse(layout, value) nutzt dieselben Layouts und gibt einen Fehler zurück, den du prüfen musst:

package main

import (
	"fmt"
	"time"
)

func main() {
	t, err := time.Parse("2006-01-02 15:04", "2026-09-23 18:45")
	if err != nil {
		fmt.Println("parse error:", err)
		return
	}
	fmt.Println(t, "| location:", t.Location())

	// A string with an offset keeps that offset.
	t2, err := time.Parse(time.RFC3339, "2026-09-23T18:45:00+02:00")
	if err != nil {
		fmt.Println("parse error:", err)
		return
	}
	fmt.Println(t2, "| in UTC:", t2.UTC())

	// Interpret a zone-less string in a specific zone.
	tokyo := time.FixedZone("JST", 9*60*60)
	t3, err := time.ParseInLocation(time.DateTime, "2026-09-23 18:45:00", tokyo)
	if err != nil {
		fmt.Println("parse error:", err)
		return
	}
	fmt.Println(t3, "| in UTC:", t3.UTC())

	// A wrong input produces a descriptive error.
	_, err = time.Parse(time.DateOnly, "23/09/2026")
	fmt.Println("error:", err)
}

Ohne Zone in der Eingabe gibt Parse UTC zurück. Derselbe Uhrzeit-String kann je nach Zone verschiedene Zeitpunkte meinen, und deshalb gibt es ParseInLocation. Die Fehlermeldung nennt den Teil, der nicht gepasst hat, und das hilft beim Debuggen eines Layouts.

Zeitzonen

Eine time.Time ist ein Zeitpunkt plus eine Location für die Anzeige. Die Location mit In zu ändern ändert, wie sie ausgegeben wird, nicht, welcher Moment es ist.

package main

import (
	"fmt"
	"time"
	_ "time/tzdata" // embed the zone database so LoadLocation works anywhere
)

func main() {
	meeting := time.Date(2026, time.September, 23, 15, 0, 0, 0, time.UTC)

	ny, err := time.LoadLocation("America/New_York")
	if err != nil {
		fmt.Println("load location:", err)
		return
	}
	india := time.FixedZone("IST", 5*60*60+30*60) // +05:30, no DST rules

	fmt.Println("UTC:     ", meeting.Format(time.RFC1123))
	fmt.Println("New York:", meeting.In(ny).Format(time.RFC1123))
	fmt.Println("India:   ", meeting.In(india).Format(time.RFC1123))
	fmt.Println("same instant:", meeting.Equal(meeting.In(ny)))
}

• time.UTC ist immer verfügbar. Speichere und übertrage Zeiten in UTC (oder RFC 3339 mit Offset) und konvertiere nur für die Anzeige.
• time.Local ist die Zone des Rechners. Auf Servern und in Containern ist das oft UTC, auf einem Laptop nicht, also verhält sich Code, der davon abhängt, an jedem Ort anders.
• time.LoadLocation("Europe/Berlin") liest die IANA-Datenbank aus dem Betriebssystem. Minimalen Container-Images fehlt sie oft, und der Aufruf gibt dann einen Fehler zurück. Der Blank Import _ "time/tzdata" bettet die Datenbank in dein Binary ein (etwa 450 KB), damit es immer funktioniert. Behandle den Fehler immer.
• time.FixedZone(name, offsetSeconds) erzeugt eine Zone mit festem Offset. Sie hat keine Sommerzeitregeln, also nimm sie für Offsets, die du bekommen hast, nicht für benannte Regionen.

Rechnen und Vergleichen

package main

import (
	"fmt"
	"time"
)

func main() {
	start := time.Date(2026, time.January, 31, 10, 0, 0, 0, time.UTC)
	end := time.Date(2026, time.March, 1, 12, 30, 0, 0, time.UTC)

	fmt.Println("difference:", end.Sub(start))
	fmt.Println("in days:   ", int(end.Sub(start).Hours()/24))

	fmt.Println("+36h:      ", start.Add(36*time.Hour).Format(time.DateTime))
	fmt.Println("-1 week:   ", start.AddDate(0, 0, -7).Format(time.DateOnly))
	fmt.Println("+1 month:  ", start.AddDate(0, 1, 0).Format(time.DateOnly)) // Jan 31 + 1 month

	fmt.Println("before:", start.Before(end), "after:", start.After(end), "equal:", start.Equal(end))

	// Start of the day, and parts of a date.
	y, m, d := end.Date()
	midnight := time.Date(y, m, d, 0, 0, 0, 0, end.Location())
	fmt.Println("midnight:", midnight.Format(time.DateTime))
	fmt.Println("weekday:", end.Weekday(), "day of year:", end.YearDay())

	// Unix timestamps.
	fmt.Println("unix:", start.Unix(), "ms:", start.UnixMilli())
	fmt.Println("from unix:", time.Unix(1_790_000_000, 0).UTC())
}

Was dir in der Ausgabe auffallen sollte:

• AddDate(0, 1, 0) auf den 31. Januar ergibt den 3. März, nicht den 28. Februar. Go addiert einen Monat, bekommt den „31. Februar“ und normalisiert dann den Überlauf. Brauchst du „derselbe Tag im nächsten Monat, begrenzt“, schreib diese Logik selbst.
• Sub gibt eine Duration zurück, die bei etwa 292 Jahren endet. Für Differenzen in Kalendertagen vergleichst du Daten um Mitternacht UTC und teilst durch 24 Stunden.
• Den Tagesanfang bekommst du, indem du die Zeit aus Date() neu baust. t.Truncate(24 * time.Hour) rundet relativ zur Null-Zeit in UTC und liefert daher für jede Zone außer UTC die falsche Antwort.

Vergleiche mit Equal, Before, After, nie mit ==. time.Now() enthält eine Ablesung der monotonen Uhr, damit time.Since auch dann korrekt bleibt, wenn die Systemuhr verstellt wird. == vergleicht diese Ablesung und außerdem die Location, also können zwei Time-Werte für denselben Zeitpunkt ungleich sein. Aus demselben Grund solltest du time.Time nicht ohne vorherige Normalisierung als Map-Schlüssel verwenden (t.UTC().Round(0) entfernt die monotone Ablesung).

Die Null-time.Time ist der 1. Januar im Jahr 1, 00:00 UTC. Prüf darauf mit t.IsZero().

Vergangene Zeit messen

start := time.Now()
doWork()
log.Printf("doWork took %v", time.Since(start))

time.Since(start) ist time.Now().Sub(start), und time.Until(deadline) ist deadline.Sub(time.Now()). Beide verwenden die monotone Uhr, wenn sie verfügbar ist, und sind daher sicher gegen Änderungen der Systemuhr. Um Code zu benchmarken, nimm die Benchmark-Unterstützung von Go im Paket testing, statt von Hand zu messen.

Timer und Ticker

time.After(d) gibt einen Channel zurück, der nach d einmal einen Wert empfängt. Ein time.Timer ist dasselbe mit einer Methode Stop. Ein time.Ticker liefert in jeder Periode einen Wert, bis du ihn stoppst.

package main

import (
	"fmt"
	"time"
)

func main() {
	ticker := time.NewTicker(20 * time.Millisecond)
	defer ticker.Stop()

	done := time.NewTimer(110 * time.Millisecond)
	defer done.Stop()

	ticks := 0
	for {
		select {
		case <-ticker.C:
			ticks++
			fmt.Println("tick", ticks)
			if ticks == 3 {
				fmt.Println("got three ticks, stopping early")
				return
			}
		case <-done.C:
			fmt.Println("timer fired first")
			return
		}
	}
}

Die drei Ticks bei 20, 40 und 60 ms kommen lange vor dem Timer bei 110 ms, also stoppt das Programm nach dem dritten Tick. time.AfterFunc(d, f) führt f nach d in einer eigenen Goroutine aus, praktisch für einmalige verzögerte Arbeit.

Seit Go 1.23 werden Timer und Ticker, auf die nichts mehr verweist, vom Garbage Collector eingesammelt, auch wenn du nie Stop aufrufst, und der Channel eines gestoppten oder zurückgesetzten Timers liefert keinen veralteten Wert mehr. Stop mit defer aufzurufen bleibt der klare Weg zu sagen, dass die Lebenszeit des Tickers vorbei ist. Gilt ein Zeitlimit für eine ganze Operation statt für ein einzelnes Warten, liest sich ein context.WithTimeout meist besser als ein Timer.

Zeit in JSON

time.Time wird in JSON automatisch in RFC-3339-Strings mit Nanosekunden-Genauigkeit umgewandelt und daraus gelesen:

type Event struct {
	Name string    `json:"name"`
	At   time.Time `json:"at"`
}
// {"name":"deploy","at":"2026-09-23T14:30:00Z"}

Ein JSON-String in einem anderen Format lässt sich nicht unmarshallen. Für Unix-Zeitstempel oder eigene Formate speicherst du ein int64 oder einen String und konvertierst, oder du definierst einen Typ mit eigenem UnmarshalJSON.

Häufige Fehler

• time.Sleep(1) oder time.Sleep(n) mit einer nackten Zahl. Das sind Nanosekunden.
• Layouts mit den falschen Ziffern. "2023-01-01" oder "YYYY-MM-DD" sind keine Layouts. Nimm "2006-01-02".
• Minuten und Monate verwechseln. Minuten sind 04, Monate 01. "15:01" gibt die Stunde und dann den Monat aus, nicht die Minute.
• Mit == vergleichen. Nimm Equal.
• Sich auf time.Local verlassen. Es unterscheidet sich zwischen Rechnern. Sei explizit mit time.UTC oder einer geladenen Location.
• Den Fehler von LoadLocation oder Parse ignorieren. Beide scheitern an echten Eingaben. Ein gescheitertes Parse gibt die Null-Zeit zurück, die als Jahr 1 erscheint, und ein gescheitertes LoadLocation gibt eine nil-Location zurück, bei der t.In(loc) eine Panic auslöst.