Comment faire pour convertir un timestamp unix (nombre de secondes depuis l'epoch) à Ruby DateTime?

Comment voulez-vous convertir un timestamp Unix (nombre de secondes depuis l'epoch) à Ruby DateTime?

InformationsquelleAutor Tronathan | 2011-10-19

325

DateTime.strptime peut poignée de secondes depuis l'epoch. Le nombre doit être convertie en une chaîne de caractères:
```
require 'date'
DateTime.strptime("1318996912",'%s')
```
- Ce ne gère pas les fractions de secondes
- Il ne poignée de millisecondes avec " %Q tho.
- merci @TheMiniJohn
- À suivre sur @TheMiniJohn de réponse. Il ressemble à Time est nécessaire au lieu de DateTime. Donc, utiliser Time.strptime("1318996912345",'%Q').to_f et vous verrez les millisecondes préservée, tandis que DateTime.strptime("1318996912345",'%Q').to_f ne pas le conserver.
InformationsquelleAutor steenslag
602

Désolé, bref moment de la synapse échec. Voici la vraie réponse.
```
require 'date'

Time.at(seconds_since_epoch_integer).to_datetime
```
Bref exemple (cela prend en compte le système actuel fuseau horaire):
```
$ date +%s
1318996912

$ irb

ruby-1.9.2-p180 :001 > require 'date'
 => true 

ruby-1.9.2-p180 :002 > Time.at(1318996912).to_datetime
 => #<DateTime: 2011-10-18T23:01:52-05:00 (13261609807/5400,-5/24,2299161)> 
```
Nouvelle mise à jour (UTC):
```
ruby-1.9.2-p180 :003 > Time.at(1318996912).utc.to_datetime
 => #<DateTime: 2011-10-19T04:01:52+00:00 (13261609807/5400,0/1,2299161)>
```
Récente mise à Jour: j'ai comparé les meilleures solutions dans ce fil, tout en travaillant sur un service HA a une ou deux semaines, et a été surpris de constater que Time.at(..) surpasse DateTime.strptime(..) (mise à jour: ajout de repères).
```
# ~ % ruby -v
#  => ruby 2.1.5p273 (2014-11-13 revision 48405) [x86_64-darwin13.0]
irb(main):038:0> Benchmark.measure do
irb(main):039:1*   ["1318996912", "1318496912"].each do |s|
irb(main):040:2*     DateTime.strptime(s, '%s')
irb(main):041:2>   end
irb(main):042:1> end
=> #<Benchmark ... @real=2.9e-05 ... @total=0.0>
irb(main):044:0> Benchmark.measure do
irb(main):045:1>   [1318996912, 1318496912].each do |i|
irb(main):046:2>     DateTime.strptime(i.to_s, '%s')
irb(main):047:2>   end
irb(main):048:1> end
=> #<Benchmark ... @real=2.0e-05 ... @total=0.0>
irb(main):050:0* Benchmark.measure do
irb(main):051:1*   ["1318996912", "1318496912"].each do |s|
irb(main):052:2*     Time.at(s.to_i).to_datetime
irb(main):053:2>   end
irb(main):054:1> end
=> #<Benchmark ... @real=1.5e-05 ... @total=0.0>
irb(main):056:0* Benchmark.measure do
irb(main):057:1*   [1318996912, 1318496912].each do |i|
irb(main):058:2*     Time.at(i).to_datetime
irb(main):059:2>   end
irb(main):060:1> end
=> #<Benchmark ... @real=2.0e-05 ... @total=0.0>
```
- Merci... La réponse suivante est un peu plus succincte, j'ai trouvé le Temps.mais essaie de trouver un DateTime équivalent.
- C'est marrant, mais le Temps.à().to_datetime semble de plus agréable que de DateTime.strptime() tout simplement parce que de la lisibilité...tout Au moins pour moi en tout cas
- Ce n'est pas le même que ci-dessus, anser, Temps.à l'suppose fuseau horaire actuel, où DateTime.strptime UTC.
- Espérons que ma mise à jour efface que pour vous.
- Il n'est pas trop surprenant que Time.at surpasse DateTime.strptime. Ce dernier doit analyser une chaîne de caractères, qui est généralement beaucoup plus lent que de prendre un numéro directement.
- Votre référence n'est pas exactement tests DateTime.strptime parce que c'est la création de deux nouvelles Chaînes de caractères à chaque itération, ce qui est très coûteux. Ce n'est pas seulement le traitement de chaîne comme @griffe dit
- et al - Merci, noté. Voir mise à jour des référentiels.
- J'ai raté votre commentaire en quelque sorte, mais le simple fait que strptime nécessite une chaîne de caractères rend intrinsèquement plus cher. Des acclamations.
InformationsquelleAutor Adam Eberlin
59

Temps De La Zone De Manutention

Je veux juste préciser, même si cela a été commenté ainsi le futur, les personnes ne manquez pas cette distinction très importante.
```
DateTime.strptime("1318996912",'%s') # => Wed, 19 Oct 2011 04:01:52 +0000
```
affiche une valeur de retour à l'UTC et nécessite l'secondes pour être une Chaîne de caractères et des sorties d'une Heure UTC de l'objet, alors que
```
Time.at(1318996912) # => 2011-10-19 00:01:52 -0400
```
affiche une valeur de retour dans le fuseau horaire LOCAL, nécessite normalement un FixNum argument, mais la durée de l'objet en lui-même est encore en UTC, même si l'affichage n'est pas.

Donc, même si j'ai passé par le même entier pour les deux méthodes, je n'ai apparemment deux résultats différents en raison de la façon dont la classe' #to_s méthode fonctionne. Cependant, comme @Eero dû me le rappeler deux fois:
```
Time.at(1318996912) == DateTime.strptime("1318996912",'%s') # => true
```
Une comparaison d'égalité entre les deux valeurs de retour renvoie toujours vrai. Encore une fois, c'est parce que les valeurs sont fondamentalement les mêmes (bien que différent de la classe, le #== méthode prend soin de cela pour vous), mais la #to_s méthode imprime radicalement différentes chaînes. Bien que, si l'on regarde les chaînes, on peut voir qu'ils sont en effet le même temps, tout imprimé dans des fuseaux horaires différents.

Argument D'Une Méthode De Clarification

Les docs aussi dire "Si un argument numérique est fourni, le résultat est en heure locale." qui fait sens, mais a été un peu difficile pour moi parce qu'ils ne donnent pas toutes des exemples de non-arguments entiers dans les docs. Ainsi, pour certains non-argument entier exemples:
```
Time.at("1318996912")
TypeError: can't convert String into an exact number
```
vous ne pouvez pas utiliser un argument de type Chaîne, mais vous pouvez utiliser un argument de Temps en Time.at et il va retourner le résultat dans le fuseau horaire de l'argument:
```
Time.at(Time.new(2007,11,1,15,25,0, "+09:00"))
=> 2007-11-01 15:25:00 +0900
```
****édité à ne pas être complètement et totalement incorrectes dans tous les sens****
- Semblait plausible, et je upvoted déjà (ne peut pas résilier maintenant), mais après vérification de votre demande concernant l'UTC est faux. Le résultant DateTime/objet de Temps sera en UTC vs local, oui, mais l'original timestamp est interprétée comme étant en UTC, dans les deux cas! Donc, le moment dans le temps est égal quelle que soit la méthode. Essayez Time.at(1318996912) == DateTime.strptime("1318996912",'%s') dans un non-fuseau horaire UTC et, vous verrez!
- Merci, @Eero. Je vais corriger cette erreur.
- Je suis désolé, mais ce que vous avez corrigé est encore faux! 🙂 Exécuter Time.use_zone "Samoa" do Time.at(1318996912) == DateTime.strptime("1318996912",'%s') end pour vérifier que les temps sont égaux, il n'y a pas de timestamp LOCAL, et dans les deux cas, le timestamp Unix de l'est interprétée comme étant en UTC. Time.at cadeaux le délai imposé objet dans la zone de l'heure locale, et DateTime.strptime cadeaux la résultante de l'objet DateTime au format UTC, mais indépendamment de la présentation qu'ils sont égaux, car ils sont l'équivalent moment dans le temps.
- J'ai juste modifié l'autre jour nouveau. Désolé, Eero, et. al.
- La déclaration de alors que Time.at(1318996912) # => 2011-10-19 00:01:52 -0400 affiche une valeur de retour dans le fuseau horaire LOCAL ne semble pas être précis... Pouvez vous s'il vous plaît vérifier? Je crois que votre déclaration ne serait vrai si vous avez utilisé Time.zone.at(1318996912)
- Oui, ça semble être exacte. Ma machine locale est définie à l'est et le temps d'affichage dans l'est.
- Pouvez-vous donner un exemple où ce n'est pas le cas @BigRon? Ce que la zone horaire, la version de ruby, etc ne pas se comporter de cette façon?
- Ruby 2.3.0: Time.zone.name #=> "Central Time (US & Canada)" Time.at(1318996912) #=> 2011-10-19 04:01:52 +0000 Time.zone.at(1318996912) #=> Tue, 18 Oct 2011 23:01:52 CDT -05:00. Temps.à sera toujours temps de retour à l'UTC, non?
- ... mais le ruby docs semblent d'accord avec vous, "Si un argument numérique est fourni, le résultat est en heure locale." En quelque sorte, mes résultats sont différents...
- Le temps est un mfer. Je suppose que je suis arriver à ces résultats en raison de la façon Rails de figurants Time.at, et de mon Temps.la zone ne doit pas être fixé correctement dans Ruby
- ouais, essayez de démarrer en un cisr console en dehors de tout projet ou sertie avec des rails installés pour vérifier si vous êtes un super curieux
InformationsquelleAutor WattsInABox

Une commande pour convertir la date en temps Unix format, puis à la chaîne

    DateTime.strptime(Time.now.utc.to_i.to_s,'%s').strftime("%d %m %y")
Time.now.utc.to_i #Converts time from Unix format
DateTime.strptime(Time.now.utc.to_i.to_s,'%s') #Converts date and time from unix format to DateTime

enfin strftime est utilisé pour le format de date

Exemple:

    irb(main):034:0> DateTime.strptime("1410321600",'%s').strftime("%d %m %y")
"10 09 14"

InformationsquelleAutor Tejasvi Manmatha

1

C'est vous dire la date de la nombre de secondes dans le futur à partir du moment où vous exécutez le code.
```
time = Time.new + 1000000000 #date in 1 billion seconds
```
met(temps)

en fonction de l'heure actuelle je suis à répondre à la question de l'impression 047-05-14 05:16:16 +0000 (1 milliard de secondes dans le futur)

ou si vous voulez compter milliards de secondes à partir d'un moment donné, il est en format Time.mktime(year, month,date,hours,minutes)
```
time = Time.mktime(1987,8,18,6,45) + 1000000000
```
puts("je voudrais être de 1 Milliard de secondes sur: "+temps)

InformationsquelleAutor sbutterworth
0

Si vous vouliez seulement une Date, vous pouvez le faire Date.strptime(invoice.date.to_s, '%s') où invoice.date se présente sous la forme d'unFixnum et puis converti en String.
- Time.at(1500923406).to_date.to_s => "2017-07-24"
InformationsquelleAutor pjammer

Vous devez vous connecter pour publier un commentaire.