web-dev-qa-db-fra.com

Comment puis-je obtenir l'heure actuelle en millisecondes?

Comment puis-je obtenir l'heure actuelle en millisecondes comme je le peux en Java?

System.currentTimeMillis()
rust
50
アレックス

Depuis Rust 1.8, vous n'avez pas besoin d'utiliser une caisse. À la place, vous pouvez utiliser SystemTime et 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);
}

Si vous avez besoin d'exactement millisecondes, vous pouvez convertir Duration .

Rouille 1,33

let in_ms = since_the_Epoch.as_millis();

Rouille 1,27

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

Rouille 1,8

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

Si vous voulez simplement faire des timings simples avec les millisecondes, vous pouvez utiliser std::time::Instant comme ceci:

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);
}

Sortie:

Debug: 10.93993ms
Millis: 10 ms
Millis: 10 ms
19
robinst

Vous pouvez utiliser la caisse horaire :

extern crate time;

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

Il renvoie un Tm qui vous permet d'obtenir la précision que vous souhaitez.

18
Steve Klabnik

J'ai trouvé une solution claire avec chrono in coinnect :

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()
}
7
DenisKolodin
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);
}

Aire de jeux de rouille

6
Zijun Luo

System.currentTimeMillis() in Java renvoie la différence en millisecondes entre l'heure actuelle et minuit, le 1er janvier 1970.

Dans Rust nous avons time::get_time() qui retourne un Timespec avec l'heure actuelle en secondes et l'offset en nanosecondes depuis minuit, 1 janvier 1970.

Exemple (en utilisant 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);
}

Référence: Time crate , System.currentTimeMillis ()

4
josehzz