Làm cách nào để tính thời gian hiện tại tính bằng mili giây?

Làm cách nào tôi có thể lấy thời gian hiện tại tính bằng mili giây như tôi có thể làm trong Java?

System.currentTimeMillis()

Kể từ Rust 1.8, bạn không cần sử dụng thùng. Thay vào đó, bạn có thể sử dụng SystemTimevà 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);
}

Nếu bạn cần chính xác mili giây, bạn có thể chuyển đổi Duration.

Gỉ 1,33

let in_ms = since_the_epoch.as_millis();

Gỉ 1,27

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

Rust 1.8

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

Nếu bạn chỉ muốn tính thời gian đơn giản với mili giây, bạn có thể sử dụng std::time::Instantnhư sau:

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

Đầu ra:

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

Bạn có thể sử dụng thùng thời gian :

extern crate time;

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

Nó trả về giá trị Tmmà bạn có thể nhận được bất kỳ độ chính xác nào bạn muốn.

Tôi đã tìm thấy một giải pháp rõ ràng với chrono trong 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);
}

Sân chơi Rust

System.currentTimeMillis() trong Java trả về sự khác biệt tính bằng mili giây giữa thời điểm hiện tại và nửa đêm, ngày 1 tháng 1 năm 1970.

Trong Rust, chúng tôi có time::get_time()trả về a Timespecvới thời gian hiện tại là giây và phần bù tính bằng nano giây kể từ nửa đêm, ngày 1 tháng 1 năm 1970.

Ví dụ (sử dụng 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);
}

Tham khảo: Time crate , System.currentTimeMillis ()