Comment générer un lisible par l'homme intervalle de temps à l'aide de ruby on rails

J'essaie de trouver la meilleure façon de générer la sortie suivante

<name> job took 30 seconds
<name> job took 1 minute and 20 seconds
<name> job took 30 minutes and 1 second
<name> job took 3 hours and 2 minutes

J'ai commencé ce code

def time_range_details
  time = (self.created_at..self.updated_at).count
  sync_time = case time 
    when 0..60 then "#{time} secs"       
    else "#{time/60} minunte(s) and #{time-min*60} seconds"
  end
end

Est-il un moyen plus efficace de le faire. Il semble que beaucoup de code redondant pour quelque chose de super simple.

Une autre utilisation est la suivante:

<title> was posted 20 seconds ago
<title> was posted 2 hours ago

Le code est similaire, mais au lieu de cela j'utilise de Temps.maintenant:

def time_since_posted
  time = (self.created_at..Time.now).count
  ...
  ...
end
InformationsquelleAutor csanz | 2010-11-09
  1. 60

    Si vous avez besoin de quelque chose de plus "précis" que distance_of_time_in_words, vous pouvez écrire quelque chose le long de ces lignes:

    def humanize secs
  [[60, :seconds], [60, :minutes], [24, :hours], [Float::INFINITY, :days]].map{ |count, name|
    if secs > 0
      secs, n = secs.divmod(count)

      "#{n.to_i} #{name}" unless n.to_i==0
    end
  }.compact.reverse.join(' ')
end

p humanize 1234
#=>"20 minutes 34 seconds"
p humanize 12345
#=>"3 hours 25 minutes 45 seconds"
p humanize 123456
#=>"1 days 10 hours 17 minutes 36 seconds"
p humanize(Time.now - Time.local(2010,11,5))
#=>"4 days 18 hours 24 minutes 7 seconds"

    Oh, une remarque sur ton code:

    (self.created_at..self.updated_at).count

    est vraiment mauvaise façon de se faire la différence. Utilisez simplement:

    self.updated_at - self.created_at
    • juste par curiosité, pourquoi est-il mauvais? (l'auto.created_at..auto.updated_at).le comte merci pour la propre réponse!
    • dans ce cas, parcourt un tableau de chaque seconde entre les deux horodatages et les compte. Que si vous voulez calculer le résultat de l'expression 100-50 en comptant tous les nombres entre 50 et 100.
    • Je préfère le DateHelper méthodes. Si vous allez pour la peine de le convertir en anglais, alors vous ne voulez probablement pas à combiner des jours et des secondes. C'est un artificiel de précision.
    • Vrai, mais en grande partie selon le contexte. Par exemple, j'avais besoin de quelque chose de similaire pour l'affichage de la durée de chaque élément dans un tableau. J'ai essayé DateHelper début, mais plus tard remplacé par méthode personnalisée qui affiche quelque chose comme 5:30:25, rigt alignés. Beaucoup plus lisible dans un tableau de données que le "flou" des expressions de DH.
    • C'est précisément mon point de vue. Il y a des moments pour utiliser un format de données, dans lequel la précision est importante, et il y a des moments pour l'utilisation de la conversation Française, où trop de précision est dans la manière.
    • J'ai modifié un peu et jeté dans un module pour une utilisation flexible: gist.github.com/jonathansimmons/24fa43ac6ee53819fb93 Spécialement faire de chaque section, (secondes, minutes, heures, jours), en option et utilisé au pluriel pour retourner une chaîne de caractères comme 1 day 10 hours vs 1 days 10 hours le code ci-dessus retours.
    • Ce code est grande, mais il ne fonctionne pas si, pour quelque chose de plus de 1 000 jours (86_400_000 secondes). humanize(86_400_001) => "0 days 0 hours 0 minutes 1 seconds" est faux. Ce bug peut être corrigé par la mise à jour du dernier élément du tableau à [Float::INFINITY, :days].
    • DateHelper est bonne, mais si vous voulez quelque chose personnalisable, alors la réponse ci-dessus est un bon exemple. Donc, vous peut éviter l'artificiel de précision en prenant seulement les deux premiers éléments de la matrice résultante. Vous pouvez décider de la façon de gérer des valeurs de plus de nombreux jours.

    InformationsquelleAutor Mladen Jablanović
  2. 27

    Il existe deux méthodes DateHelper qui pourraient vous donner ce que vous voulez:

    1. time_ago_in_words

      time_ago_in_words( 1234.seconds.from_now ) #=> "21 minutes"

time_ago_in_words( 12345.seconds.ago )     #=> "about 3 hours"

    2. distance_of_time_in_words

      distance_of_time_in_words( Time.now, 1234.seconds.from_now ) #=> "21 minutes"

distance_of_time_in_words( Time.now, 12345.seconds.ago )     #=> "about 3 hours"
    • Notez que distance_of_time_in_words est i18n-conscient et a une double interface : il peut être utilisé directement sur une durée : distance_of_time_in_words(6270.873) #=> environ 2 heures (en français)
    InformationsquelleAutor Doug R
  3. 7

    chronic_duration analyse numérique du temps lisible et vice versa

    InformationsquelleAutor usr
  4. 2

    Si vous voulez montrer significative des durées en secondes pour les jours de plage, une alternative serait (car il n'a pas à effectuer le meilleur):

    def human_duration(secs, significant_only = true)
  n = secs.round
  parts = [60, 60, 24, 0].map{|d| next n if d.zero?; n, r = n.divmod d; r}.
    reverse.zip(%w(d h m s)).drop_while{|n, u| n.zero? }
  if significant_only
    parts = parts[0..1] # no rounding, sorry
    parts << '0' if parts.empty?
  end
  parts.flatten.join
end
start = Time.now
# perform job
puts "Elapsed time: #{human_duration(Time.now - start)}"

human_duration(0.3) == '0'
human_duration(0.5) == '1s'
human_duration(60) == '1m0s'
human_duration(4200) == '1h10m'
human_duration(3600*24) == '1d0h'
human_duration(3600*24 + 3*60*60) == '1d3h'
human_duration(3600*24 + 3*60*60 + 59*60) == '1d3h' # simple code, doesn't round
human_duration(3600*24 + 3*60*60 + 59*60, false) == '1d3h59m0s'

    Vous pouvez également être intéressé seulement par le décapage de la partie secondes quand il n'a pas d'importance (en montrant également une autre approche):

    def human_duration(duration_in_seconds)
  n = duration_in_seconds.round
  parts = []
  [60, 60, 24].each{|d| n, r = n.divmod d; parts << r; break if n.zero?}
  parts << n unless n.zero?
  pairs = parts.reverse.zip(%w(d h m s)[-parts.size..-1])
  pairs.pop if pairs.size > 2 # do not report seconds when irrelevant
  pairs.flatten.join
end

    Espère que ça aide.

    InformationsquelleAutor rosenfeld
  5. 0

    Il y a un problème avec distance_of_time_in_words si u ll y passer 1 heure 30 min ll retour environ 2 heures

    Simplement ajouter dans helper:

     PERIODS = {
   'day' => 86400,
   'hour' => 3600,
   'minute' => 60
   }


def formatted_time(total)
  return 'now' if total.zero?

  PERIODS.map do |name, span|
    next if span > total
    amount, total = total.divmod(span)
    pluralize(amount, name)
  end.compact.to_sentence
end

    Fondamentalement, il suffit de transmettre vos données en quelques secondes.

    InformationsquelleAutor Denis
  6. 0

    Rails a un DateHelper pour les vues. Si ce n'est pas exactement ce que vous voulez, vous pouvez écrire votre propre.

    @Mladen Jablanović a une réponse avec des exemples de code. Toutefois, si vous n'avez pas l'esprit continuant à personnaliser d'un échantillon d'humaniser la méthode, cela pourrait être un bon point de départ.

    def humanized_array_secs(sec)
  [[60, 'minutes '], [60, 'hours '], [24, 'days ']].inject([[sec, 'seconds']]) do |ary, (count, next_name)|
    div, prev_name = ary.pop

    quot, remain = div.divmod(count)
    ary.push([remain, prev_name])
    ary.push([quot, next_name])
    ary
  end.reverse
end

    Cela vous donne un tableau de valeurs et de l'unité de noms que vous pouvez manipuler.

    Si le premier élément est non nul, c'est le nombre de jours. Vous pouvez écrire du code pour gérer plusieurs jours, comme montrant des semaines, des mois et des années. Sinon, coupez la pointe 0 valeurs, et de prendre les deux.

    def humanized_secs(sec)
  return 'now' if 1 > sec

  humanized_array = humanized_array_secs(sec.to_i)
  days = humanized_array[-1][0]
  case
    when 366 <= days
      "#{days /365} years"
    when 31 <= days
      "#{days /31} months"
    when 7 <= days
      "#{days /7} weeks"
    else
      while humanized_array.any? && (0 == humanized_array[-1][0])
        humanized_array.pop
      end
      humanized_array.reverse[0..1].flatten.join
  end
end

    Le code trouve même utiliser un ruby while déclaration.

    InformationsquelleAutor Marlin Pierce