मुझे मिलीसेकंड में वर्तमान समय कैसे मिल सकता है?

Question

मुझे मिलीसेकंड में वर्तमान समय कैसे मिल सकता है जैसे मैं जावा में कर सकता हूं?

System.currentTimeMillis()

Answer 1

रस्ट 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;

Comments

सिस्टमटाइम तत्काल के बजाय क्यों?

— एंडी हेडन

@AndyHayden आप के लिए प्रलेखनInstant फिर से पढ़ने की इच्छा हो सकती है : एक पल से "सेकंड की संख्या" प्राप्त करने के लिए कोई विधि नहीं है। इसके बजाय, यह केवल दो इंस्टेंट (या दो इंस्टेंट की तुलना) के बीच की अवधि को मापने की अनुमति देता है।

— 1pm

Answer 2

यदि आप केवल मिलीसेकंड के साथ सरल समय करना चाहते हैं, तो आप 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

Comments

जोड़ने के लिए RFC समस्या 1545 भी देखें । as_millisDuration

— लूट

यदि आप अवधि चाहते हैं, तो आप doc.rust-lang.org/1.8.0/std/time/… चेकआउट कर सकते हैं ।

— vinyll

का कारण बना u128 is not supported।

— पेड्रो पाउलो अमोरिम

Answer 3

आप समय टोकरा का उपयोग कर सकते हैं :

extern crate time;

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

यह एक ऐसा रिटर्न देता है Tmजिसे आप प्राप्त कर सकते हैं जो भी आप चाहते हैं।

Comments

precise_time_...कि टोकरा से काम करता है, भी प्रासंगिक हैं अगर एक बस रिश्तेदार बार को मापने के लिए चाहता है।

— ह्युऑन

मुझे मिलीसेकंड कैसे मिले?

— ッ ク

आप उपयोग करने के लिए है time::now_utc()या time::get_time()जावा के System.currentTimeMillis () UTC समय देता है के बाद से। मैं लिखता हूंlet timespec = time::get_time(); let mills = timespec.sec + timespec.nsec as i64 / 1000 / 1000;

— नंदोर क्रैसर

समय :: सटीक_टाइम_इन्स () और समय :: सटीक_टाइम_एस ()

— tyoc213

यह टोकरा अब हटा दिया गया है। chronoइसकी जगह क्रेट का इस्तेमाल करें ।

— ओन्ड्रेज स्लिंत्क

Answer 4

मुझे सिक्को में क्रोनो के साथ एक स्पष्ट समाधान मिला है :

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

Answer 5

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

जंग का मैदान

Comments

यह System.currentTimeMillis ()

— josehzz

सच है, यह सेकंड में समय लौटाता है। मिलिस प्राप्त करने के लिए, आपको 1000 से गुणा करना होगा और nsec को 1000 से कम पर विभाजित करना होगा (जैसा कि अन्य उत्तर सही ढंग से करते हैं)।

— विरोधाभास

@contradictioned play.rust-lang.org/…

— Zijun Luo

Answer 6

System.currentTimeMillis() जावा में वर्तमान समय और मध्यरात्रि, 1 जनवरी, 1970 के बीच मिलीसेकंड में अंतर लौटता है।

जंग में हमारे पास वर्तमान समय के साथ सेकंड के रूप में time::get_time()वापसी होती है Timespecऔर 1 जनवरी, 1970 की मध्यरात्रि से नैनोसेकंड में ऑफसेट होता है।

उदाहरण (रुस्त 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);
}

संदर्भ: समय टोकरा , System.currentTimeMillis ()

Comments

टोकरा का लिंक मान्य नहीं है।

— Ixx

Answer 7

जैसा कि @ शेमेस्टर ने उल्लेख किया है, यह System.currentTimeMillis()जंग में जावा के बराबर है ।

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

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