2014-10-27 22 views

उत्तर

13

आप उपयोग कर सकते हैं time crate:

extern crate time; 

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

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

+2

'precise_time _...' कि टोकरा से कार्यों अगर एक बस रिश्तेदार बार को मापने के लिए चाहता है भी प्रासंगिक हैं। – huon

+0

मैं मिलीसेकंड कैसे प्राप्त करूं? –

+1

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

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

+0

यह System.currentTimeMillis() – josehzz

+0

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

+0

@contradictioned https://play.rust-lang.org/?gist=c047b64111280878ba5f674024374278&version=stable –

13

तुम सिर्फ मिलीसेकेंड के साथ सरल समय क्या करना चाहते हैं, तो आप इस तरह 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); 

} 
+0

भी देखें [आरएफसी मुद्दा 1545] (https://github.com/rust-lang/rfcs/issues/1545) जोड़ने के लिए 'as_millis'' अवधि 'तक। – robinst

+0

आप https://doc.rust-lang.org/1.8.0/std/time/struct.Instant.html#method.duration_since चेकआउट करने के लिए अगर आप अवधि चाहते हैं कर सकते हैं। – vinyll

2

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

जंग में हम time::get_time() है जो एक 012,331 रिटर्न सेकंड के रूप में वर्तमान समय और आधी रात के बाद से नैनोसेकंड में ऑफसेट, 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); 
} 

संदर्भ: Time crate, System.currentTimeMillis()

14

के बाद से जंग 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; 
1

मैं coinnect में chrono के साथ एक स्पष्ट समाधान मिल गया है:

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) 
} 
संबंधित मुद्दे

 संबंधित मुद्दे