Como obter a hora atual como um número inteiro de 13 dígitos em Ruby?

Tenho esta jQueryfunção que retorna a hora atual como o número de milissegundos desde a época (1 de janeiro de 1970):

time = new Date().getTime();

Existe uma maneira de fazer o mesmo em Ruby?

No momento, estou usando Ruby, Time.now.to_ique funciona muito bem, mas retorna um número inteiro de 10 dígitos (número de segundos)

Como faço para que ele exiba o número de milissegundos, como em jQuery?

require 'date'

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

O Javascript gettime()retorna o número de milissegundos desde a época.

O Ruby Time.now.to_ifornecerá o número de segundos desde a época. Se você alterar para Time.now.to_f, ainda terá segundos, mas com um componente fracionário. Basta multiplicar isso por 1.000 e você terá milissegundos. Em seguida, use #to_ipara convertê-lo em um inteiro. E você acaba com:

(Time.now.to_f * 1000).to_i

(Time.now.to_f * 1000).to_i deve fazer a mesma coisa.

Usando strftime, você pode obter o número de segundos e acrescentar milissegundos fracionários (ou unidades menores, se necessário):

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

Observe que isso não é arredondado, ele trunca, como você pode ver com to_fou se chegar a microssegundos:

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

e a solução to_f/ to_item o mesmo problema:

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

então, se você realmente se preocupa com a precisão de milissegundos, uma aposta melhor pode ser to_fcom round:

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

Dito isso, conforme observado nos documentos , "IEEE 754 double não é preciso o suficiente para representar o número de nanossegundos desde a época", portanto, se você realmente se importa, considere em to_rvez de to_f-

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

- embora se você estiver apenas arredondando para milissegundos, provavelmente estará bem.

Tenha cuidado, não se confunda. O fato de Ruby suportar a ideia de segundos fracionários como um número flutuante não o torna um número de ponto flutuante. Tive problemas com isso quando estava fazendo comparações de tempo de carimbo de data / hora do Wireshark em Python ... os cálculos de tempo no pcap-ng simplesmente não estavam funcionando. Somente quando tratei as duas partes (segundos inteiros e nanossegundos inteiros) como ambos os inteiros, pude obter os números adequados.

Isso ocorre porque os números de ponto flutuante têm problemas de precisão . De fato, um pouco de Ruby irá mostrar a você que to_f não é 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

Advertência Programador. Você pode estar seguro com 3 dígitos significativos, mas o fato permanece: os números de ponto flutuante em computadores são aproximações. Os contadores de nanossegundos em computadores modernos são inteiros.

Obtenha um objeto Time com Time.now, a chamada #to_iretorna um carimbo de data / hora Unix (segundos da época). #to_ffornece segundos fracionários que você pode usar para obter milissegundos da época:

Time.now.to_f * 1000

O typecast Integer (1e6 * Time.now.to_f) retorna um Bignum que pode conter os milissegundos