Wie kann ich die aktuelle Zeit in Millisekunden abrufen?

Wie kann ich die aktuelle Zeit in Millisekunden wie in Java abrufen?

System.currentTimeMillis()

Seit Rust 1.8 müssen Sie keine Kiste mehr verwenden. Stattdessen können Sie verwenden SystemTimeund UNIX_EPOCH:

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

fn main() {
    let start = SystemTime::now();
    let since_the_epoch = start
        .duration_since(UNIX_EPOCH)
        .expect("Time went backwards");
    println!("{:?}", since_the_epoch);
}

Wenn Sie genau Millisekunden benötigen, können Sie die konvertieren Duration.

Rost 1.33

let in_ms = since_the_epoch.as_millis();

Rost 1.27

let in_ms = since_the_epoch.as_secs() as u128 * 1000 + 
            since_the_epoch.subsec_millis() as u128;

Rost 1.8

let in_ms = since_the_epoch.as_secs() * 1000 +
            since_the_epoch.subsec_nanos() as u64 / 1_000_000;

Wenn Sie nur einfache Timings mit den Millisekunden durchführen möchten, können Sie Folgendes verwenden std::time::Instant:

use std::time::Instant;

fn main() {
    let start = Instant::now();

    // do stuff

    let elapsed = start.elapsed();

    // Debug format
    println!("Debug: {:?}", elapsed); 

    // Format as milliseconds rounded down
    // Since Rust 1.33:
    println!("Millis: {} ms", elapsed.as_millis());

    // Before Rust 1.33:
    println!("Millis: {} ms",
             (elapsed.as_secs() * 1_000) + (elapsed.subsec_nanos() / 1_000_000) as u64);
}

Ausgabe:

Debug: 10.93993ms
Millis: 10 ms
Millis: 10 ms

Sie können die Zeitkiste verwenden :

extern crate time;

fn main() {
    println!("{}", time::now());
}

Es gibt eine zurück, mit Tmder Sie die gewünschte Präzision erzielen können.

Ich habe mit chrono in coinnect eine klare Lösung gefunden :

use chrono::prelude::*;

pub fn get_unix_timestamp_ms() -> i64 {
    let now = Utc::now();
    now.timestamp_millis()
}

pub fn get_unix_timestamp_us() -> i64 {
    let now = Utc::now();
    now.timestamp_nanos()
}

extern crate time;

fn timestamp() -> f64 {
    let timespec = time::get_time();
    // 1459440009.113178
    let mills: f64 = timespec.sec as f64 + (timespec.nsec as f64 / 1000.0 / 1000.0 / 1000.0);
    mills
}

fn main() {
    let ts = timestamp();
    println!("Time Stamp: {:?}", ts);
}

Rostspielplatz

System.currentTimeMillis() in Java gibt die Differenz in Millisekunden zwischen der aktuellen Zeit und Mitternacht, dem 1. Januar 1970, zurück.

In Rust haben wir eine, time::get_time()die a Timespecmit der aktuellen Zeit als Sekunden und dem Offset in Nanosekunden seit Mitternacht, dem 1. Januar 1970, zurückgibt .

Beispiel (mit Rust 1.13):

extern crate time; //Time library

fn main() {
    //Get current time
    let current_time = time::get_time();

    //Print results
    println!("Time in seconds {}\nOffset in nanoseconds {}",
             current_time.sec, 
             current_time.nsec);

    //Calculate milliseconds
    let milliseconds = (current_time.sec as i64 * 1000) + 
                       (current_time.nsec as i64 / 1000 / 1000);

    println!("System.currentTimeMillis(): {}", milliseconds);
}

Referenz: Zeitkiste , System.currentTimeMillis ()