Go Academy · Lektion

Zeit und Dauer

Zeitpunkte und Intervalle darstellen

Zeit und Dauer ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Das Paket time

Das Go-Paket time stellt Zeitpunkte und Zeitspannen zwischen ihnen dar.

time.Time ist ein bestimmter Zeitpunkt.
time.Duration ist eine Zeitdauer.

package main

import (
    "fmt"
    "time"
)

func main() {
    var d time.Duration = 2 * time.Second
    fmt.Println(d)
}

Die aktuelle Zeit abrufen

time.Now() gibt den aktuellen Zeitpunkt als time.Time zurück. (Der genaue Wert hängt davon ab, wann das Programm ausgeführt wird.)

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now.Year())
}

Einen bestimmten Zeitpunkt erstellen

time.Date erstellt aus seinen Bestandteilen einen exakten Zeitpunkt: Jahr, Monat, Tag, Stunde, Minute, Sekunde, Nanosekunde und Zeitzone.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, time.May, 30, 9, 0, 0, 0, time.UTC)
    fmt.Println(t)
}

Zeitbestandteile auslesen

Ein time.Time stellt Methoden wie Year, Month, Day, Hour und Weekday bereit.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, time.May, 30, 0, 0, 0, 0, time.UTC)
    fmt.Println(t.Month(), t.Day(), t.Weekday())
}

Konstanten für Zeitdauern

Erstellen Sie Zeitdauern, indem Sie die Einheitenkonstanten multiplizieren: time.Hour, time.Minute, time.Second, time.Millisecond.

package main

import (
    "fmt"
    "time"
)

func main() {
    d := 1*time.Hour + 30*time.Minute
    fmt.Println(d)
}

Zeitdauern umrechnen

Methoden wie Seconds(), Minutes() und Hours() geben die Zeitdauer als float64 in der jeweiligen Einheit zurück.

package main

import (
    "fmt"
    "time"
)

func main() {
    d := 90 * time.Minute
    fmt.Println(d.Hours())
    fmt.Println(d.Seconds())
}

Zeit hinzufügen

t.Add(d) gibt einen neuen, um eine Zeitdauer verschobenen Zeitpunkt zurück. Der ursprüngliche Wert bleibt unverändert, da time.Time ein Werttyp ist.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, time.May, 30, 9, 0, 0, 0, time.UTC)
    later := t.Add(2 * time.Hour)
    fmt.Println(later.Hour())
}

Kalendereinheiten hinzufügen

t.AddDate(years, months, days) verschiebt einen Zeitpunkt um Kalenderwerte und berücksichtigt dabei Monatslängen und Schaltjahre korrekt.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, time.January, 31, 0, 0, 0, 0, time.UTC)
    next := t.AddDate(0, 1, 0)
    fmt.Println(next.Month(), next.Day())
}

Zeitdifferenz

t2.Sub(t1) liefert die Duration zwischen zwei Zeitpunkten. Ein negatives Ergebnis bedeutet, dass t2 früher liegt.

package main

import (
    "fmt"
    "time"
)

func main() {
    a := time.Date(2026, time.May, 30, 9, 0, 0, 0, time.UTC)
    b := time.Date(2026, time.May, 30, 12, 0, 0, 0, time.UTC)
    fmt.Println(b.Sub(a))
}

Zeitpunkte vergleichen

Verwenden Sie Before, After und Equal, um Zeitpunkte zu vergleichen. Vermeiden Sie ==, da dabei auch die interne Location verglichen wird.

package main

import (
    "fmt"
    "time"
)

func main() {
    a := time.Date(2026, 5, 30, 9, 0, 0, 0, time.UTC)
    b := time.Date(2026, 5, 30, 10, 0, 0, 0, time.UTC)
    fmt.Println(a.Before(b))
}

Unix-Zeitstempel

t.Unix() liefert die Anzahl der Sekunden seit dem 1. Januar 1970. time.Unix(sec, 0) wandelt diesen Wert wieder in eine time.Time um.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, 5, 30, 0, 0, 0, 0, time.UTC)
    secs := t.Unix()
    fmt.Println(time.Unix(secs, 0).UTC().Year())
}

Kurze Überprüfung

Was liefert t2.Sub(t1)?

Zusammenfassung: Zeit und Duration

Sie haben das grundlegende Zeitmodell kennengelernt:

time.Time bezeichnet einen Zeitpunkt, time.Duration eine Zeitspanne.
Erzeugen Sie Werte mit Now und Date; verschieben Sie sie mit Add und AddDate.
Messen Sie Zeitspannen mit Sub und vergleichen Sie Zeitpunkte mit Before/After.

package main

import (
    "fmt"
    "time"
)

func main() {
    start := time.Date(2026, 5, 30, 8, 0, 0, 0, time.UTC)
    end := start.Add(45 * time.Minute)
    fmt.Println(end.Sub(start).Minutes(), "minutes")
}

Häufig gestellte Fragen

Ist die Lektion „Zeit und Dauer“ kostenlos?

Ja — der vollständige Text von „Zeit und Dauer“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Zeit und Dauer“?

Zeitpunkte und Intervalle darstellen Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Zeit und Dauer“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Go Academy