Calculer le nombre de jours ouvrables entre deux jours

J'ai besoin de calculer le nombre de jours ouvrables entre deux dates. Comment puis-je l'enlever à l'aide de Ruby (Rails ou...si il y a des Rails spécifiques aides).

De même, j'aimerais être en mesure d'ajouter des jours à une date donnée.

Si une date tombe un jeudi et j'ai ajouté les 3 jours ouvrables, il serait de retour le mardi suivant.

Je pense que de certaines façons de le faire, mais vous devez dire ce que le comportement que vous souhaitez lors de la "journée de référence" est un jour non ouvrable (samedi->lundi 0 jour ou 1 jour? Est jeudi->le samedi de 1 ou 2 jours?)

InformationsquelleAutor Shpigford | 2010-10-26

31

Prendre un coup d'oeil à business_time. Il peut être utilisé pour les deux choses que vous demandez.

Calcul de jours ouvrables entre deux dates:
```
wednesday = Date.parse("October 17, 2018")
monday = Date.parse("October 22, 2018")
wednesday.business_days_until(monday) # => 3
```
L'ajout d'affaires de jours à une date donnée:
```
4.business_days.from_now
8.business_days.after(some_date)
```
Historique réponse

Lorsque cette question a été initialement demandé, business_time ne pas fournir les business_days_until méthode la méthode ci-dessous a été fourni pour répondre à la première partie de la question.

Cela pourrait encore être utile à quelqu'un qui n'a pas besoin de toutes les autres fonctionnalités de business_time et voulait éviter l'ajout d'une dépendance.
```
def business_days_between(date1, date2)
  business_days = 0
  date = date2
  while date > date1
   business_days = business_days + 1 unless date.saturday? or date.sunday?
   date = date - 1.day
  end
  business_days
end
```
Cela peut aussi être réglé pour gérer les cas qui Tipx mentionne dans la façon dont vous le souhaitez.
- Le combo de business_time plus votre extrait de code est parfait.
- comme de maintenant, il ya une méthode qui peut calculer les jours ouvrables entre deux dates dans le bijou que vous posté le: business_days_until
- merci pour le suivi. J'ai mis à jour la réponse à réfléchir. Cheers!
InformationsquelleAutor mikej

Nous utilisons l'algorithme proposé dans la mikej réponse et a découvert que le calcul de 25 000 gammes de plusieurs années, chacun prend 340 secondes.

Voici un autre algorithme à complexité asymptotique O(1). Il effectue les mêmes calculs dans 0.41 secondes.

# Calculates the number of business days in range (start_date, end_date]
#
# @param start_date [Date]
# @param end_date [Date]
#
# @return [Fixnum]
def business_days_between(start_date, end_date)
  days_between = (end_date - start_date).to_i
  return 0 unless days_between > 0

  # Assuming we need to calculate days from 9th to 25th, 10-23 are covered
  # by whole weeks, and 24-25 are extra days.
  #
  # Su Mo Tu We Th Fr Sa    # Su Mo Tu We Th Fr Sa
  #        1  2  3  4  5    #        1  2  3  4  5
  #  6  7  8  9 10 11 12    #  6  7  8  9 ww ww ww
  # 13 14 15 16 17 18 19    # ww ww ww ww ww ww ww
  # 20 21 22 23 24 25 26    # ww ww ww ww ed ed 26
  # 27 28 29 30 31          # 27 28 29 30 31
  whole_weeks, extra_days = days_between.divmod(7)

  unless extra_days.zero?
    # Extra days start from the week day next to start_day,
    # and end on end_date's week date. The position of the
    # start date in a week can be either before (the left calendar)
    # or after (the right one) the end date.
    #
    # Su Mo Tu We Th Fr Sa    # Su Mo Tu We Th Fr Sa
    #        1  2  3  4  5    #        1  2  3  4  5
    #  6  7  8  9 10 11 12    #  6  7  8  9 10 11 12
    # ## ## ## ## 17 18 19    # 13 14 15 16 ## ## ##
    # 20 21 22 23 24 25 26    # ## 21 22 23 24 25 26
    # 27 28 29 30 31          # 27 28 29 30 31
    #
    # If some of the extra_days fall on a weekend, they need to be subtracted.
    # In the first case only corner days can be days off,
    # and in the second case there are indeed two such days.
    extra_days -= if start_date.tomorrow.wday <= end_date.wday
                    [start_date.tomorrow.sunday?, end_date.saturday?].count(true)
                  else
                    2
                  end
  end

  (whole_weeks * 5) + extra_days
end

InformationsquelleAutor shock_one

business_time a toutes les fonctionnalités que vous souhaitez.

Du readme:

#vous pouvez aussi calculer les affaires de la durée entre deux dates

friday = Date.parse("December 24, 2010")
monday = Date.parse("December 27, 2010")
friday.business_days_until(monday) #=> 1

L'ajout d'affaires de jours à une date donnée:

some_date = Date.parse("August 4th, 1969")
8.business_days.after(some_date) #=> 14 Aug 1969

InformationsquelleAutor Eyal Levin

1

Prendre un coup d'oeil à Workpattern. Il s'installe en vous permettant de spécifier de travail et les périodes de repos et peut ajouter/soustraire des durées vers/à partir d'une date ainsi que de calculer les minutes entre deux dates.

Vous pouvez configurer workpatterns pour les différents scénarios tels que lun-ven de travail ou dim.-jeu. et vous pouvez avoir des vacances et tout ou partie des jours.

J'ai écrit ce que l'écart d'apprendre Ruby. Encore besoin d'en faire plus Ruby-ish.

InformationsquelleAutor callenb

Voici ma (non gem et non de vacances) jour de la semaine comte exemple:

first_date = Date.new(2016,1,5)
second_date = Date.new(2016,1,12)
count = 0
(first_date...second_date).each{|d| count+=1 if (1..5).include?(d.wday)}
count

InformationsquelleAutor Cliff Thelin

0

Basé sur @mikej de réponse. Mais cela prend aussi en compte les jours fériés, et renvoie une fraction de journée (jusqu'à l'heure de précision):
```
def num_days hi, lo
  num_hours = 0
  while hi > lo
    num_hours += 1 if hi.workday? and !hi.holiday?
    hi -= 1.hour
  end
  num_hours.to_f / 24
end
```
Il utilise le vacances et business_time gemmes.

InformationsquelleAutor Brian Armstrong

Script Simple pour calculer le nombre total de jours de travail

require 'date'
(DateTime.parse('2016-01-01')...DateTime.parse('2017-01-01')).
inject({}) do |s,e| 
   s[e.month]||=0
   if((1..5).include?(e.wday)) 
     s[e.month]+=1
   end
   s
end

# => {1=>21, 2=>21, 3=>23, 4=>21, 5=>22, 6=>22, 7=>21, 8=>23, 9=>22, 10=>21, 11=>22, 12=>22}

InformationsquelleAutor Oleksandr Mishyn

0

Il y a deux problèmes avec les solutions les plus populaires répertoriées ci-dessus:
1. Ils impliquent des boucles de compter chaque jour entre la date de chacun (ce qui signifie que la performance devient pire, plus la distance entre les dates sont.
2. Ils ne sont pas claires quant à savoir si ils comptent à partir du début de la journée ou de la fin. Si vous comptez partir, le matin, il y a un jour de la semaine entre le vendredi et le samedi. Si vous comptez à partir de la nuit, il y a zéro les jours de la semaine entre le vendredi et le samedi.
Après cuisson à l'étouffée sur elle, je propose cette solution qui résout ces deux problèmes. Ci-dessous prend une date de référence et à une autre date et calcule le nombre de jours ouvrables entre eux (retourne un nombre négatif si l'autre est avant la date de référence). L'argument eod_base contrôle si le comptage est fait à partir de la fin de la journée (nem) ou en début de journée. Il pourrait être écrite de manière plus compacte, mais j'espère que c'est relativement facile à comprendre et il ne nécessite pas des gemmes ou des rails.
```
  require 'date'

  def weekdays_between(ref,otr,eod_base=true)
        dates = [ref,otr].sort
        return 0 if dates[0] == dates[1]
        full_weeks = ((dates[1]-dates[0])/7).floor  
        dates[eod_base ? 0 : 1] += (eod_base ? 1 : -1)
        part_week = Range.new(dates[0],dates[1])
                         .inject(0){|m,v|  (v.wday >=1 && v.wday <= 5) ? (m+1) : m }
        return (otr <=> ref) * (full_weeks*5 + part_week)
  end
```
InformationsquelleAutor David Foster

Vous devez vous connecter pour publier un commentaire.