Die chrono-Bibliothek für Rust: Vollständige Anleitung für Datum und Zeit

1. Was ist chrono und warum braucht man es?

Die Bibliothek chrono ist der De-facto-Standard für die Arbeit mit Datum und Zeit im Rust-Ökosystem. Sie bietet eine leistungsstarke, typsichere und ergonomische API zum Parsen, Formatieren, für Arithmetik und Manipulation von Zeitstempeln. Im Gegensatz zur Standardbibliothek von Rust, die nur grundlegende Funktionen über std::time bietet (nur für Dauern und Systemzeit), deckt chrono nahezu alle Entwicklerbedürfnisse ab: von der Arbeit mit Zeitzonen bis hin zu komplexen Kalenderberechnungen.

Warum braucht man sie? Wenn Sie eine Anwendung schreiben, die Geburtsdaten verarbeitet, Ereignisse mit Nanosekunden-Genauigkeit protokolliert, Zeitpläne erstellt oder mit internationalen Zeitzonen arbeitet – dann führt kein Weg an chrono vorbei. Es unterstützt die Formate ISO 8601, RFC 2822, RFC 3339 und ermöglicht die Erstellung eigener Formatierer. Dank des strengen Typsystems von Rust hilft chrono, Fehler durch ungültige Daten (z. B. 30. Februar) oder Verwechslungen zwischen UTC und Ortszeit zu vermeiden.

Die Bibliothek wird von der Community aktiv gepflegt, hat eine hervorragende Dokumentation und wird in tausenden Projekten eingesetzt, darunter bekannte wie tokio, actix-web und diesel. Version 0.4.x ist stabil und wird für den Produktionseinsatz empfohlen.

2. Installation

Um chrono zu Ihrem Rust-Projekt hinzuzufügen, verwenden Sie den Paketmanager Cargo. Führen Sie im Terminal im Stammverzeichnis Ihres Projekts aus:

cargo add chrono

Oder fügen Sie die Abhängigkeit manuell in Ihre Cargo.toml-Datei ein:

[dependencies]
chrono = "0.4"

Führen Sie anschließend cargo build aus, um die Bibliothek und ihre Abhängigkeiten herunterzuladen. Für die Arbeit mit Zeitzonen (z. B. zum Parsen von Städtenamen) kann es erforderlich sein, das Feature serde oder clock zu aktivieren:

[dependencies]
chrono = { version = "0.4", features = ["serde"] }

3. Schnellstart – Minimales Arbeitsbeispiel

Erstellen Sie eine Datei main.rs und fügen Sie folgenden Code ein:

use chrono::{Local, Utc, DateTime, Duration};

fn main() {
    // Aktuelle Zeit in UTC
    let utc_now: DateTime = Utc::now();
    println!("Aktuelle UTC-Zeit: {}", utc_now);

    // Aktuelle lokale Zeit
    let local_now: DateTime = Local::now();
    println!("Aktuelle Ortszeit: {}", local_now);

    // Datum formatieren
    println!("Formatiertes Datum: {}", local_now.format("%Y-%m-%d %H:%M:%S"));

    // Arithmetik: 2 Tage hinzufügen
    let future = utc_now + Duration::days(2);
    println!("In 2 Tagen (UTC): {}", future);
}

Starten Sie das Programm mit dem Befehl cargo run. Sie sehen die aktuelle UTC-Zeit, die Ortszeit, einen formatierten String und das Datum in zwei Tagen.

4. Wichtige Methoden/Funktionen

Im Folgenden werden 8 wichtige Methoden und Typen aus der chrono-Bibliothek vorgestellt. Für jede gibt es die Signatur, eine Beschreibung und ein Code-Beispiel.

4.1. Utc::now()

Signatur: pub fn now() -> DateTime<Utc>

Beschreibung: Gibt den aktuellen Zeitpunkt in der UTC-Zeitzone zurück. Dies ist die sicherste Methode, um einen Zeitstempel zu erhalten, da sie nicht von den System-Zeitzoneneinstellungen abhängt.

use chrono::Utc;

fn main() {
    let now = Utc::now();
    println!("Aktuelle UTC-Zeit: {}", now);
    // Ausgabe: 2025-03-15 14:30:00.123456 UTC
}

4.2. Local::now()

Signatur: pub fn now() -> DateTime<Local>

Beschreibung: Gibt den aktuellen Zeitpunkt in der lokalen Zeitzone zurück.

use chrono::Local;

fn main() {
    let now = Local::now();
    println!("Aktuelle Ortszeit: {}", now);
    // Ausgabe: 2025-03-15 16:30:00.123456 +02:00
}

4.3. DateTime::format()

Signatur: pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>

Beschreibung: Formatiert das Datum/Zeit-Objekt in einen String gemäß dem angegebenen Format-String (strftime-ähnlich).

use chrono::{Utc, DateTime};

fn main() {
    let now = Utc::now();
    let formatted = now.format("%d.%m.%Y %H:%M:%S");
    println!("Formatiert: {}", formatted);
    // Ausgabe: 15.03.2025 14:30:00
}

4.4. NaiveDate::from_ymd()

Signatur: pub fn from_ymd(year: i32, month: u32, day: u32) -> NaiveDate

Beschreibung: Erstellt ein NaiveDate (Datum ohne Zeitzone) aus Jahr, Monat und Tag. Gibt einen panic bei ungültigen Daten aus.

use chrono::NaiveDate;

fn main() {
    let date = NaiveDate::from_ymd(2025, 12, 24);
    println!("Datum: {}", date);
    // Ausgabe: 2025-12-24
}

4.5. NaiveDate::parse_from_str()

Signatur: pub fn parse_from_str(input: &str, fmt: &str) -> ParseResult<NaiveDate>

Beschreibung: Parst einen String in ein NaiveDate gemäß dem angegebenen Format. Gibt ein Result zurück.

use chrono::NaiveDate;

fn main() {
    let date = NaiveDate::parse_from_str("25.12.2025", "%d.%m.%Y").unwrap();
    println!("Geparstes Datum: {}", date);
    // Ausgabe: 2025-12-25
}

4.6. DateTime::checked_add_signed()

Signatur: pub fn checked_add_signed(self, rhs: OldDuration) -> Option<DateTime<Tz>>

Beschreibung: Addiert eine Zeitspanne (Duration) sicher zum DateTime-Objekt. Gibt None bei Überlauf zurück, statt zu panicken.

use chrono::{Utc, Duration};

fn main() {
    let now = Utc::now();
    let in_10_days = now.checked_add_signed(Duration::days(10));
    match in_10_days {
        Some(date) => println!("In 10 Tagen: {}", date),
        None => println!("Überlauf aufgetreten!"),
    }
}

4.7. DateTime::timestamp()

Signatur: pub fn timestamp(&self) -> i64

Beschreibung: Gibt die Anzahl der Sekunden seit dem 1. Januar 1970 (Unix-Epoche) als i64 zurück.

use chrono::Utc;

fn main() {
    let now = Utc::now();
    let ts = now.timestamp();
    println!("Unix-Timestamp: {}", ts);
    // Ausgabe: 1742041800
}

4.8. DateTime::from_timestamp()

Signatur: pub fn from_timestamp(secs: i64, nsecs: u32) -> Option<DateTime<Utc>>

Beschreibung: Erstellt ein DateTime<Utc> aus einem Unix-Timestamp (Sekunden und Nanosekunden). Gibt None bei ungültigen Werten zurück.

use chrono::{DateTime, Utc};

fn main() {
    let dt = DateTime::from_timestamp(1742041800, 0).unwrap();
    println!("Datum aus Timestamp: {}", dt);
    // Ausgabe: 2025-03-15 14:30:00 UTC
}

5. Fazit

Die chrono-Bibliothek ist ein unverzichtbares Werkzeug für jeden Rust-Entwickler, der mit Datum und Zeit arbeitet. Sie bietet eine sichere, typsichere und umfassende API, die von einfachen Formatierungen bis zu komplexen Zeitzonenberechnungen alles abdeckt. Mit der Installation über Cargo und den hier gezeigten Beispielen können Sie sofort loslegen. Für weiterführende Informationen empfehlen wir die offizielle Dokumentation auf docs.rs.