如何获得以毫秒为单位的当前时间？

如何像在 Java 中那样获得以毫秒为单位的当前时间？

System.currentTimeMillis()
103676 次浏览
小开

你可使用 时间板条箱:

extern crate time;


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

它返回一个 Tm，你可以得到任何你想要的精度。

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

铁锈乐园

小开

如果你只想用毫秒计时，你可以像这样使用 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);
}

产出:

Debug: 10.93993ms
Millis: 10 ms
Millis: 10 ms
小开

Java 中的 System.currentTimeMillis()以毫秒为单位返回当前时间与1970年1月1日午夜之间的差值。

在 Rust 中，我们有 time::get_time()，它返回一个 Timespec，当前时间为秒，自1970年1月1日午夜以来的偏移量以纳秒为单位。

示例(使用 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);
}

参考文献: 时间箱，CurrentTimeMillis ()

小开

由于 Rust 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。

生锈1.33

let in_ms = since_the_epoch.as_millis();

生锈1.27

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

生锈1.8

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

我在 连接中找到了一个关于 Chrono的清晰解决方案:

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()
}
小开

正如@Shepmaster 提到的，这相当于 Java 在 Rust 中的 System.currentTimeMillis()。

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


fn get_epoch_ms() -> u128 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_millis()
}

提交答案