मुझे रूबी में मिलीसेकंड में समय कैसे बीतता है?

98

अगर मेरे पास कोई Timeवस्तु है:

Time.now

और बाद में मैं उसी लाइन के साथ एक और ऑब्जेक्ट को इंस्टेंट करता हूं, मैं कैसे देख सकता हूं कि कितने मिलीसेकंड बीत चुके हैं? दूसरी वस्तु को उसी मिनट, अगले मिनटों या घंटों में भी बनाया जा सकता है।

ruby

— भू
स्रोत

133

जैसा कि पहले ही कहा गया है, आप Timeवस्तुओं पर काम कर सकते हैं जैसे कि वे संख्यात्मक (या अस्थायी बिंदु) मान थे। इन ऑपरेशनों के परिणामस्वरूप दूसरा रिज़ॉल्यूशन होता है जिसे आसानी से परिवर्तित किया जा सकता है।

उदाहरण के लिए:

def time_diff_milli(start, finish)
   (finish - start) * 1000.0
end

t1 = Time.now
# arbitrary elapsed time
t2 = Time.now

msecs = time_diff_milli t1, t2

आपको यह तय करने की आवश्यकता होगी कि उसे कम करना है या नहीं।

— ezpz
स्रोत

2

a_i जोड़ें और आपके पास यह पूर्णांक के रूप में है, जैसे: ((समाप्त - प्रारंभ) * 1000.0) .to_i

— ट्रैविस रीडर

finish.to_f - start.to_f?

— चिरस्थायी

1

finish - startपैदावार फ़्लोटिंग पॉइंट; .to_fबेमानी होगी।

— ezpz

5

यदि रेल या सक्रिय समर्थन का उपयोग करते हैं, तो आप समान रूपांतरण करने के लिए #in_milliseconds पद्धति का उपयोग कर सकते हैं(t2 - t1).in_milliseconds

— नाथन हन्ना

58

आप निम्नलिखित समाधान के साथ एक छोटे से वाक्य रचना चीनी जोड़ सकते हैं:

class Time
  def to_ms
    (self.to_f * 1000.0).to_i
  end
end

start_time = Time.now
sleep(3)
end_time = Time.now
elapsed_time = end_time.to_ms - start_time.to_ms  # => 3004

— phlipper
स्रोत

31

मुझे लगता है कि उत्तर गलत तरीके से चुना गया है, यह विधि सेकंड देती है, मिलीसेकंड नहीं।

t = Time.now.to_f
=> 1382471965.146

यहाँ मुझे लगता है कि अस्थायी मान मिलीसेकंड हैं

— LowFieldTheory
स्रोत

1

चुना हुआ उत्तर सही है। इसके अलावा या घटाव का उपयोग Time.nowदशमलव बिंदु से पहले सेकंड के साथ फ्लोटिंग पॉइंट वैल्यू के रूप में समय मान रहा है और दशमलव बिंदु के बाद नैनोसेकंड तक (हालांकि nsec पूरी तरह से सटीक नहीं हो सकता है)। तो उस मूल्य को कई गुना बढ़ाकर 1000.0मिलिससेकंड किया जाता है।

— dfherr

हां, लेकिन सिर्फ "Time.now" देना गलत है और इस सवाल का सही जवाब नहीं देता है।

— LowFieldTheory

12

मिलीसेकंड में समय पाने के लिए, इसे जोड़ना बेहतर है .round(3), इसलिए यह कुछ मामलों में अधिक सटीक होगा:

puts Time.now.to_f # => 1453402722.577573

(Time.now.to_f.round(3)*1000).to_i  # => 1453402722578

— स्टीवन यू
स्रोत

9

ezpz का जवाब लगभग सही है, लेकिन मुझे उम्मीद है कि मैं थोड़ा और जोड़ सकता हूं।

जियो ने मिलीसेकंड में समय के बारे में पूछा; यह एक पूर्णांक मात्रा की तरह लगता है, और मैं फ्लोटिंग-पॉइंट भूमि के माध्यम से चक्कर नहीं लगाऊंगा। इस प्रकार मेरा दृष्टिकोण होगा:

irb(main):038:0> t8 = Time.now
=> Sun Nov 01 15:18:04 +0100 2009
irb(main):039:0> t9 = Time.now
=> Sun Nov 01 15:18:18 +0100 2009
irb(main):040:0> dif = t9 - t8
=> 13.940166
irb(main):041:0> (1000 * dif).to_i
=> 13940

एक पूर्णांक 1000 से गुणा करना भिन्नात्मक संख्या को पूरी तरह से संरक्षित करता है और थोड़ा तेज भी हो सकता है।

यदि आप दिनांक और समय के साथ काम कर रहे हैं, तो आपको DateTime वर्ग का उपयोग करने की आवश्यकता हो सकती है । यह समान रूप से काम करता है लेकिन रूपांतरण कारक 24 * 3600 * 1000 = 86400000 है ।

मैं दिनांक समय के पाया है strptime और strftime कार्यों को पार्स और दिनांक / समय तार स्वरूपण में अमूल्य (जैसे करने के लिए / लॉग से)। जानने के लिए क्या काम आता है:

इन फ़ंक्शंस के लिए फ़ॉर्मेटिंग वर्ण (% H,% M,% S, ...) लगभग किसी भी यूनिक्स / लिनक्स सिस्टम पर पाए जाने वाले C फ़ंक्शंस के समान हैं; तथा
कुछ और हैं: विशेष रूप से, % L मिलीसेकंड करता है!

— कार्ल स्मोत्रिक्ज़
स्रोत

जानकार अच्छा लगा! धन्यवाद unknown:)

— जियो

1

वैसे भी% L केवल रूबी 1.9 में मौजूद है;)

— राफा डे कास्त्रो

7

DateTime.now.strftime("%Q")

उदाहरण का उपयोग:

>> DateTime.now.strftime("%Q")
=> "1541433332357"

>> DateTime.now.strftime("%Q").to_i
=> 1541433332357

— रयान मैकगिरी
स्रोत

6

Time.now.to_f आपकी मदद कर सकता है, लेकिन यह सेकंड में लौटता है।

सामान्य तौर पर, बेंचमार्क I के साथ काम करते समय:

वर्तमान समय में चर में डाल दिया;
परीक्षण के लिए ब्लॉक डालें;
वर्तमान समय में एक चर में डालें, पूर्ववर्ती वर्तमान-समय के मूल्य को घटाते हुए;

यह एक बहुत ही सरल प्रक्रिया है, इसलिए मुझे यकीन नहीं है कि आप वास्तव में यह पूछ रहे थे ...

6

%L रूबी में मिलीसेकंड देता है

require 'time'
puts Time.now.strftime("%Y-%m-%dT%H:%M:%S.%L")

या

puts Time.now.strftime("%Y-%m-%d %H:%M:%S.%L")

आपको मिलीसेकंड में वर्तमान टाइमस्टैम्प देगा।

— संदीप सिंह नागरा
स्रोत

यह नहीं कहता कि बीते हुए समय को कैसे प्राप्त किया जाए।

— रॉबर्ट

4

उत्तर कुछ इस प्रकार है:

t_start = Time.now
# time-consuming operation
t_end = Time.now

milliseconds = (t_start - t_end) * 1000.0

हालांकि Time.now दृष्टिकोण गलत होने का जोखिम रखता है। मुझे यह पोस्ट Luca Guidi द्वारा मिली:

https://blog.dnsimple.com/2018/03/elapsed-time-with-ruby-the-right-way/

सिस्टम घड़ी लगातार तैर रही है और यह केवल आगे की ओर नहीं चलती है। यदि आपके बीते हुए समय की गणना इस पर आधारित है, तो आप गणना त्रुटियों या आउटेज में भी भाग सकते हैं ।

तो, इसके Process.clock_gettimeबजाय उपयोग करने की सिफारिश की जाती है । कुछ इस तरह:

def measure_time
  start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
  yield
  end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
  elapsed_time = end_time - start_time
  elapsed_time.round(3)
end

उदाहरण:

elapsed = measure_time do
    # your time-consuming task here:
    sleep 2.2321
end

=> 2.232

— रॉबर्ट
स्रोत

3

पहली Time.now को दूसरी से घटाकर देखें। इस तरह:

a = Time.now
sleep(3)
puts Time.now - a # about 3.0

यह आपको दो बार (और उस, मिलीसेकंड) के बीच सेकंड का एक फ्लोटिंग-पॉइंट नंबर देता है।

— mrueg
स्रोत