Comment obtenir l’heure actuelle sous forme d’entier à 13 chiffres dans Ruby?

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

gettime() de Javascript renvoie le nombre de millisecondes depuis l’époque.

Time.now.to_i de Ruby 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 un composant fractionnaire. Il suffit de multiplier cela par 1 000 et vous avez des millisecondes. Ensuite, utilisez #to_i pour le convertir en un entier. Et vous vous retrouvez avec:

 (Time.now.to_f * 1000).to_i 

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

Faites attention, ne vous trompez pas. Le fait que Ruby prenne en charge l’idée de secondes fractionnelles en tant que valeur flottante ne constitue pas réellement un nombre à virgule flottante. J’ai eu des problèmes avec ça quand je faisais des comparaisons de temps d’horodatage 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) que les deux entiers étaient capables d’obtenir des nombres corrects.

C’est parce que les nombres à virgule flottante ont des problèmes de précision . En effet, un petit bout de Ruby vous montrera que to_f n’égale pas, 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 

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

Obtenez un object Time avec Time.now , appelant #to_i renvoie un horodatage Unix (secondes à partir de l’époque). #to_f donne des fractions de secondes que vous pouvez utiliser pour obtenir des millisecondes à partir de l’époque:

 Time.now.to_f * 1000 

En utilisant strftime , vous pouvez obtenir le nombre de secondes et append des 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 que cela ne contourne pas, il tronque, comme vous pouvez le voir avec to_f ou si vous sortez en microsecondes:

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

et la solution to_f / to_i a le même problème:

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

Donc, si vous vous souciez vraiment de la précision en millisecondes, un meilleur pari peut être to_f avec round :

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

Cela dit, comme indiqué dans les documents , “le double de la norme IEEE 754 n’est pas assez précis pour représenter le nombre de nanosecondes depuis l’époque”, donc si vous vous en souciez vraiment , considérez to_r au lieu de to_f –

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

– bien que si vous arrondissez seulement en millisecondes, vous allez probablement bien.

Le type Integer (1e6 * Time.now.to_f) renvoie un Bignum pouvant contenir les millisecondes