Différence entre DateTime et de Temps en Ruby

[Modifier Juillet 2018]

Tous les ci-dessous reste vrai en Ruby 2.5.1. À partir de la la documentation de référence:

DateTime ne considère pas toutes les secondes intercalaires, ne pas suivre tout l'été règles de temps.

Ce qui n'a pas été noté dans ce fil avant est l'un des rares avantages de DateTime: il est au courant du calendrier des réformes alors que Time n'est pas:

[...] Ruby est Temps de classe implémente un calendrier gregorien et n'a pas de concept de la réforme du calendrier [...].

La documentation de référence se termine par la recommandation de l'utilisation de Time exclusivement affaire avec le proche passé, actuel ou futur de la date/heure et de n'utiliser DateTime lorsque, par exemple, de Shakespeare anniversaire doit être exactement de la conversion: (italiques ajoutés)

Donc quand devez-vous utiliser DateTime en Ruby et quand devez-vous utiliser le Temps? Presque certainement, vous aurez envie d'utiliser le Temps depuis votre application est probablement traiter avec le courant des dates et des heures. Toutefois, si vous avez besoin de traiter avec les dates et heures dans un contexte historique, vous aurez envie d'utiliser DateTime [...]. Si vous aussi, vous avez à traiter avec les fuseaux horaires puis le meilleur de la chance - il suffit de garder à l'esprit que vous aurez probablement à faire avec local solaires fois, puisqu'il n'était pas jusqu'à ce que le 19ème siècle, l'introduction des chemins de fer nécessité pour l'Heure Standard et, éventuellement, de fuseaux horaires.

[/Edit Juillet 2018]

De ruby 2.0, la plupart des informations dans les autres réponses, c'est hors de date.

En particulier, Time est maintenant pratiquement indépendant. Elle peut être plus ou moins de même 63 bits loin de l'Époque:

irb(main):001:0> RUBY_VERSION
=> "2.0.0"
irb(main):002:0> Time.at(2**62-1).utc # within Integer range
=> 146138514283-06-19 07:44:38 UTC
irb(main):003:0> Time.at(2**128).utc # outside of Integer range
=> 10783118943836478994022445751222-08-06 08:03:51 UTC
irb(main):004:0> Time.at(-2**128).utc # outside of Integer range
=> -10783118943836478994022445747283-05-28 15:55:44 UTC

La seule conséquence de l'utilisation de plus grandes valeurs de performance, ce qui est mieux quand Integers sont utilisés (vs Bignums (valeurs en dehors de Integer gamme) ou Rationals (lorsque nanosecondes sont suivis)):

Depuis Ruby 1.9.2, le Temps de la mise en œuvre utilise un signé 63 bits entier, Bignum ou Rationnelle. Le nombre entier est un nombre de nanosecondes depuis l'Époque ce qui peut représenter 1823-11-12 à 2116-02-20. Lorsque Bignum ou Rationnel est utilisé (avant 1823, après 2116, en vertu de l'ordre de la nanoseconde), le Temps plus lentement que lors de l'entier est utilisé.
(http://www.ruby-doc.org/core-2.1.0/Time.html)

En d'autres termes, comme je le comprends, DateTime n'est plus couvre un plus large éventail de valeurs possibles que Time.

En outre, deux précédemment sous silence les restrictions de DateTime devrait probablement être noté:

DateTime ne considère aucun leapseconds, ne pas suivre tout l'été règles de temps.
(http://www.ruby-doc.org/stdlib-2.1.0/libdoc/date/rdoc/Date.html#class-Date-label-DateTime)

D'abord, DateTime a pas de notion de secondes intercalaires:

irb(main):001:0> RUBY_VERSION
=> "2.0.0"
irb(main):002:0> require "date"
=> true
irb(main):003:0> t = Time.new(2012,6,30,23,59,60,0)
=> 2012-06-30 23:59:60 +0000
irb(main):004:0> dt = t.to_datetime; dt.to_s
=> "2012-06-30T23:59:59+00:00"
irb(main):005:0> t == dt.to_time
=> false
irb(main):006:0> t.to_i
=> 1341100824
irb(main):007:0> dt.to_i
=> 1341100823

Deuxième, DateTime a une compréhension très limitée des zones de temps et, en particulier, n'a aucune notion de l'heure d'été. Il gère les fuseaux horaires comme simple UTC + X décalages:

irb(main):001:0> RUBY_VERSION
=> "2.0.0"
irb(main):002:0> require "date"
=> true
irb(main):003:0> t = Time.local(2012,7,1)
=> 2012-07-01 00:00:00 +0200
irb(main):004:0> t.zone
=> "CEST"
irb(main):005:0> t.dst?
=> true
irb(main):006:0> dt = t.to_datetime; dt.to_s
=> "2012-07-01T00:00:00+02:00"
irb(main):007:0> dt.zone
=> "+02:00"
irb(main):008:0> dt.dst?
NoMethodError: undefined method `dst?' for #<DateTime:0x007f34ea6c3cb8>

Cela peut causer des problèmes lorsque les temps sont entrés comme de l'heure d'été, puis converti en une non-de l'heure d'été de fuseau horaire, sans garder une trace de l'corriger les décalages à l'extérieur de DateTime lui-même (de nombreux systèmes d'exploitation peuvent déjà prendre soin de cela pour vous).

Dans l'ensemble, je dirais que de nos jours Time est le meilleur choix pour la plupart des applications.

Remarque également une différence importante sur plus: lorsque vous ajoutez un nombre à un objet de Temps, il est compté en secondes, mais lorsque vous ajoutez un nombre à un DateTime, il est compté en jours.

Je pense que la réponse à "quelle est la différence" est l'un des la malheureuse commune réponses à cette question dans le Rubis bibliothèques standard: les deux classes/libs ont été créés différemment par des personnes différentes à des moments différents. C'est l'une des conséquences malheureuses de la nature communautaire de Ruby évolution par rapport à soigneusement planifié le développement de quelque chose comme Java. Les développeurs veulent de nouvelles fonctionnalités, mais ne veulent pas marcher sur les APIs existantes pour qu'elles puissent créer une nouvelle classe à l'utilisateur final, il n'y a pas de raison évidente pour les deux existent.

Cela est vrai pour les bibliothèques de logiciels en général: souvent la raison pour laquelle certains de code ou de l'API est la façon dont il est s'avère être historique plutôt que logique.

La tentation est de commencer avec DateTime parce qu'il semble plus générique. Date... et le Temps, non? Mal. Le temps fait aussi des dates de mieux, et en fait peut analyser les fuseaux horaires où DateTime peut pas. Aussi, il a de meilleures performances.

J'ai fini par utiliser le Temps partout.

Pour être sûr de bien, j'ai tendance à permettre DateTime arguments à être passé dans mon Timey Api, et de convertir. Aussi, si je sais que les deux ont la méthode, je suis intéressé par j'accepte, soit, comme cette méthode que j'ai écrit pour la conversion de temps à XML (pour les fichiers XMLTV)

# Will take a date time as a string or as a Time or DateTime object and
# format it appropriately for xmtlv. 
# For example, the 22nd of August, 2006 at 20 past midnight in the British Summertime
# timezone (i.e. GMT plus one hour for DST) gives: "20060822002000 +0100"
def self.format_date_time(date_time)
  if (date_time.respond_to?(:rfc822)) then
    return format_time(date_time)
  else 
    time = Time.parse(date_time.to_s)
    return format_time(time)
  end    
end

# Note must use a Time, not a String, nor a DateTime, nor Date.
# see format_date_time for the more general version
def self.format_time(time)
  # The timezone feature of DateTime doesn't work with parsed times for some reason
  # and the timezone of Time is verbose like "GMT Daylight Saving Time", so the only
  # way I've discovered of getting the timezone in the form "+0100" is to use 
  # Time.rfc822 and look at the last five chars
  return "#{time.strftime( '%Y%m%d%H%M%S' )} #{time.rfc822[-5..-1]}"
end

Examiner comment ils traitent les fuseaux horaires différemment personnalisée avec des instanciations:

irb(main):001:0> Time.new(2016,9,1)
=> 2016-09-01 00:00:00 -0400
irb(main):002:0> DateTime.new(2016,9,1)
=> Thu, 01 Sep 2016 00:00:00 +0000
irb(main):003:0> Time.new(2016,9,1).to_i
=> 1472702400
irb(main):004:0> DateTime.new(2016,9,1).to_i
=> 1472688000

Cela peut être difficile lors de la création de plages de temps, etc.