Как получить текущее время в миллисекундах?

Question

Как я могу получить текущее время в миллисекундах, как я могу на Java?

System.currentTimeMillis() 

Answer 1

Вы можете использовать time crate:

extern crate time; 

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

Это возвращает Tm, который вы можете получить то, что точность вы хотите.

Answer 2

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

Rust Playground

Answer 3

Если вы просто хотите, чтобы делать простые тайминги с миллисекундах, вы можете использовать std::time::Instant так:

use std::time::Instant; 

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

    // do stuff 

    let elapsed = start.elapsed(); 
    // debug format: 
    println!("{:?}", elapsed); 
    // or format as milliseconds: 
    println!("Elapsed: {} ms", 
      (elapsed.as_secs() * 1_000) + (elapsed.subsec_nanos()/1_000_000) as u64); 

} 

Answer 4

System.currentTimeMillis() в Java возвращает разницу в миллисекундах между текущим временем и полночь, 1 января 1970 года.

В Rust у нас есть time::get_time(), который возвращаетс текущим временем в секундах и смещение в наносекунд с полуночи 1 января 1970 года

Пример (используя 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); 
} 

Ссылка: Time crate, System.currentTimeMillis()

Answer 5

Так как ржавчина 1.8 , вам не нужно использовать ящик. Вместо этого, вы можете использовать SystemTime и 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); 
} 

Если вам нужно точно миллисекунды, вы можете преобразовать Duration:

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

Answer 6

Я нашел четкое решение с chrono в coinnect:

use chrono::prelude::*; 

pub fn get_unix_timestamp_ms() -> i64 { 
    let now = Utc::now(); 
    let seconds: i64 = now.timestamp(); 
    let nanoseconds: i64 = now.nanosecond() as i64; 
    (seconds * 1000) + (nanoseconds/1000/1000) 
} 

pub fn get_unix_timestamp_us() -> i64 { 
    let now = Utc::now(); 
    let seconds: i64 = now.timestamp(); 
    let nanoseconds: i64 = now.nanosecond() as i64; 
    (seconds * 1000 * 1000) + (nanoseconds/1000) 
}