Comment obtenir l'heure actuelle sous forme d'un nombre entier à 13 chiffres en Ruby ?

Question

J'ai ceci jQuery qui renvoie l'heure actuelle sous la forme du nombre de millisecondes depuis l'époque (1er janvier 1970) :

time = new Date().getTime();

Existe-t-il un moyen de faire la même chose en Ruby ?

Pour l'instant, j'utilise l'outil de Ruby Time.now.to_i qui fonctionne très bien mais renvoie un 10 chiffres nombre entier (nombre de secondes)

Comment puis-je faire en sorte qu'il affiche le nombre de millisecondes, comme dans jQuery ?

Answer 1

require 'date'

p DateTime.now.strftime('%s') # "1384526946" (seconds)
p DateTime.now.strftime('%Q') # "1384526946523" (milliseconds)

Answer 2

Javascript gettime() renvoie le nombre de millisecondes depuis epoch.

Ruby's Time.now.to_i vous donnera le nombre de secondes depuis l'époque. Si vous changez cela en Time.now.to_f vous obtenez toujours des secondes, mais avec une composante fractionnaire. Il suffit de multiplier par 1 000 et vous obtenez des millisecondes. Utilisez ensuite #to_i pour le convertir en un nombre entier. Et on se retrouve avec :

(Time.now.to_f * 1000).to_i

Answer 3

(Time.now.to_f * 1000).to_i devrait faire la même chose.

Answer 4

Utilisation de strftime vous pouvez obtenir le nombre de secondes et ajouter des fractions de millisecondes (ou des unités plus petites, si nécessaire) :

2.2.2 :001 > t = Time.new
 => 2015-06-02 12:16:56 -0700 
2.2.2 :002 > t.strftime('%s%3N')
 => "1433272616888" 

Notez cependant que cela n'arrondit pas, cela tronque, comme vous pouvez le voir avec to_f ou si vous allez jusqu'aux microsecondes :

2.2.2 :003 > t.to_f
 => 1433272616.888615
2.2.2 :004 > t.usec
 => 888615 

et le to_f / to_i a le même problème ( to_i n'est pas rond, il tronqué ) :

2.2.2 :009 > (t.to_f * 1000).to_i
 => 1433272616888

donc si vous tenez vraiment à une précision de l'ordre de la milliseconde, un meilleur pari peut être to_f con round :

2.2.2 :010 > (t.to_f * 1000).round
 => 1433272616889

Cela dit, comme noté dans les docs le double de l'IEEE 754 n'est pas assez précis pour représenter le nombre de nanosecondes depuis l'époque", donc si vous voulez vraiment vraiment soins, envisager to_r au lieu de to_f --

2.2.2 :011 > (t.to_r * 1000).round
 => 1433272616889 

-- Mais si vous n'arrondissez qu'à la milliseconde, tout va probablement bien.

Answer 5

Fais attention, ne t'embrouille pas. Le fait que Ruby prenne en charge l'idée d'une fraction de seconde sous forme de flottant n'en fait pas pour autant un nombre à virgule flottante. J'ai eu des problèmes avec cela lorsque je faisais des comparaisons de temps de timestamp Wireshark en Python... les calculs de temps dans le pcap-ng ne fonctionnaient tout simplement pas. Ce n'est que lorsque j'ai traité les deux parties (secondes intégrales et nanosecondes intégrales) comme des entiers que j'ai pu obtenir des nombres corrects.

C'est parce que les nombres à virgule flottante ont Problèmes de précision . En effet, un petit peu de Ruby vous montrera que to_f n'est pas égal à, disons, nsec :

irb(main):019:0> t=Time.now
=> 2015-04-10 16:41:35 -0500
irb(main):020:0> puts "#{t.to_f}; #{t.nsec}"
1428702095.1435847; 143584844

Programmeur Caveat. Vous pouvez être sûr à 3 chiffres significatifs près, mais le fait demeure : Les nombres à virgule flottante sur les ordinateurs sont des approximations. Les compteurs de nanosecondes des ordinateurs modernes sont des entiers.