¿Cómo puedo obtener la hora actual en milisegundos?

¿Cómo puedo obtener la hora actual en milisegundos como puedo en Java?

System.currentTimeMillis()

Desde Rust 1.8, no es necesario utilizar una caja. En su lugar, puede usar SystemTimey 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 necesita exactamente milisegundos, puede convertir el Duration .

Óxido 1.33

let in_ms = since_the_epoch.as_millis();

Óxido 1,27

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

Óxido 1.8

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

Si solo desea hacer tiempos simples con milisegundos, puede usar std::time::Instantasí:

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

Salida:

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

Puedes usar la caja de tiempo :

extern crate time;

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

Devuelve un valor Tmque puede obtener la precisión que desee.

Encontré una solución clara con chrono en 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()
}

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

Patio de recreo de óxido

System.currentTimeMillis() en Java devuelve la diferencia en milisegundos entre la hora actual y la medianoche del 1 de enero de 1970.

En Rust tenemos time::get_time()que devuelve un Timespeccon la hora actual en segundos y el desplazamiento en nanosegundos desde la medianoche del 1 de enero de 1970.

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

Referencia: caja de tiempo , System.currentTimeMillis ()