`SystemTime` în Rust

Timp: Instant, Duration, SystemTime Rust 1.8

Ora sistemului (ceasul din calendar); diferența față de UNIX_EPOCH dă timestamp-ul Unix în secunde.

Sintaxă

use std::time::{SystemTime, UNIX_EPOCH};

fn now() -> SystemTime
fn duration_since(&self, earlier: SystemTime) -> Result<Duration, SystemTimeError>
pub const UNIX_EPOCH: SystemTime

Ce face `SystemTime`

SystemTime::now() citește ceasul obișnuit al sistemului. Spre deosebire de Instant, acest ceas poate fi schimbat (manual sau de sincronizarea automată), deci poate sări și înapoi. De aceea duration_since returnează Result: Err dacă momentul „mai vechi” este de fapt mai nou.

UNIX_EPOCH (exportat și ca SystemTime::UNIX_EPOCH) este 1 ianuarie 1970, ora 00:00:00 UTC. SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs() dă timestamp-ul Unix, folosit în baze de date, API-uri și nume de fișiere.

Biblioteca standard nu transformă un SystemTime în zi, lună, an sau oră locală. Pentru asta se folosesc crate-urile chrono sau time; pentru calcule simple în UTC te descurci cu împărțiri la 86400.

Parametri

Parametru	Descriere
`earlier`	La `duration_since`: momentul față de care se măsoară.

Ce returnează

now: un SystemTime. duration_since: Result<Duration, SystemTimeError>.

Exemple

Exemplul 1: Timestamp-ul Unix de acum

Valoarea diferă la fiecare rulare; rezultatul de mai jos este din 19 octombrie 2026.

use std::time::{SystemTime, UNIX_EPOCH};

fn main() {
    let acum = SystemTime::now().duration_since(UNIX_EPOCH).expect("ceasul este după 1970");
    println!("timestamp: {}", acum.as_secs());
    println!("zile de la 1 ianuarie 1970: {}", acum.as_secs() / 86_400);
}

Rezultat posibil (diferă la fiecare rulare)

timestamp: 1792402887
zile de la 1 ianuarie 1970: 20745

Exemplul 2: Calcule cu un moment fix

Pornim de la un timestamp cunoscut, ca rezultatul să fie mereu același. Al doilea duration_since dă eroare, pentru că ordinea este inversă.

use std::time::{Duration, SystemTime, UNIX_EPOCH};

fn main() {
    let moment = UNIX_EPOCH + Duration::from_secs(1_700_000_000);
    let secunde = moment.duration_since(UNIX_EPOCH).unwrap().as_secs();

    let in_zi = secunde % 86_400;
    println!("zile de la epoch: {}", secunde / 86_400);
    println!("ora UTC: {:02}:{:02}:{:02}", in_zi / 3600, in_zi % 3600 / 60, in_zi % 60);

    let peste_o_ora = moment + Duration::from_secs(3600);
    println!("diferență: {:?}", peste_o_ora.duration_since(moment));
    println!("invers: {:?}", moment.duration_since(peste_o_ora).map_err(|e| e.to_string()));
    println!("SystemTime::UNIX_EPOCH == UNIX_EPOCH: {}", SystemTime::UNIX_EPOCH == UNIX_EPOCH);
}

Rezultat

zile de la epoch: 19675
ora UTC: 22:13:20
diferență: Ok(3600s)
invers: Err("second time provided was later than self")
SystemTime::UNIX_EPOCH == UNIX_EPOCH: true

Exemplul 3: Vechimea unui fișier

Fișierul tocmai a fost creat, deci vechimea lui este sub o secundă.

use std::fs;
use std::time::{Duration, SystemTime};

fn main() -> std::io::Result<()> {
    fs::write("cache.json", "{}")?;
    let modificat = fs::metadata("cache.json")?.modified()?;
    let vechime = SystemTime::now().duration_since(modificat).unwrap_or(Duration::ZERO);
    println!("cache-ul este proaspăt: {}", vechime < Duration::from_secs(60));
    Ok(())
}