¿Cómo obtener la hora actual como un entero de 13 dígitos en Ruby?

Tengo esta jQueryfunción que devuelve la hora actual como el número de milisegundos desde la época (1 de enero de 1970):

time = new Date().getTime();

¿Hay alguna forma de hacer lo mismo en Ruby?

En este momento, estoy usando Ruby, Time.now.to_ique funciona muy bien pero devuelve un número entero de 10 dígitos (número de segundos)

¿Cómo puedo hacer que muestre el número de milisegundos, como en jQuery?

require 'date'

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

Javascript gettime()devuelve el número de milisegundos desde época.

Ruby's Time.now.to_ite dará la cantidad de segundos desde la época. Si cambia eso a Time.now.to_f, todavía obtiene segundos pero con un componente fraccionario. Simplemente multiplique eso por 1,000 y tendrá milisegundos. Luego utilícelo #to_ipara convertirlo en un número entero. Y terminas con:

(Time.now.to_f * 1000).to_i

(Time.now.to_f * 1000).to_i debería hacer lo mismo.

Con strftime, puede obtener la cantidad de segundos y agregar milisegundos fraccionarios (o unidades más pequeñas, si es necesario):

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

Sin embargo, tenga en cuenta que esto no se redondea, se trunca, como puede ver con to_fo si sale a microsegundos:

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

y la solución to_f/ to_itiene el mismo problema:

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

así que si realmente le importa la precisión de milisegundos, una mejor apuesta puede ser to_fcon round:

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

Dicho esto, como se indica en los documentos , "IEEE 754 double no es lo suficientemente preciso para representar el número de nanosegundos desde la Época", así que si realmente te importa, considera en to_rlugar de to_f:

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

- aunque si solo está redondeando a milisegundos probablemente esté bien.

Tenga cuidado, no se confunda. El hecho de que Ruby apoye la idea de los segundos fraccionarios como flotante no lo convierte en realidad en un número de coma flotante. Me metí en problemas con esto cuando estaba haciendo comparaciones de tiempo de marca de tiempo de Wireshark en Python ... los cálculos de tiempo en pcap-ng simplemente no funcionaban. Fue solo cuando traté las dos partes (segundos integrales y nanosegundos integrales) como ambos enteros que pude obtener los números adecuados.

Eso es porque los números de coma flotante tienen problemas de precisión . De hecho, un poco de Ruby le mostrará que to_f no es igual, digamos, 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

Programador de advertencias. Puede estar seguro de tener 3 dígitos significativos, pero el hecho es que los números de coma flotante en las computadoras son aproximaciones. Los contadores de nanosegundos de las computadoras modernas son números enteros.

Obtener un objeto Time con la Time.nowllamada #to_idevuelve una marca de tiempo de Unix (segundos desde la época). #to_fda fracciones de segundo que puede usar para obtener milisegundos de época:

Time.now.to_f * 1000

El encasillado Integer (1e6 * Time.now.to_f) devuelve un Bignum que puede contener milisegundos