如何在 Ruby 中获取两个日期之间的所有星期日?

问题描述 投票:0回答:4

我正在开发一个表单,用户输入日期范围并从复选框列表中选择一周中的一天/几天,即星期日、星期一、星期二、星期三、星期四、星期五和星期六。

提交表格后,我需要一种方法来获取根据所选日期输入的两个日期之间的日期列表,即给定的两个日期之间的所有星期一和星期四。我已经浏览了文档,但无法确定如何有效地做到这一点,即 ruby 方式。

ruby ruby-on-rails-3
4个回答
70
投票

有趣的一个! :D

 start_date = Date.today # your start
 end_date = Date.today + 1.year # your end
 my_days = [1,2,3] # day of the week in 0-6. Sunday is day-of-week 0; Saturday is day-of-week 6.
 result = (start_date..end_date).to_a.select {|k| my_days.include?(k.wday)}

使用上面的数据,您将获得从现在到明年之间所有周一/周二/周三的数组。


17
投票

另一种方法是按

wday
对日期范围进行分组,然后选择一周中的哪一天:

datesByWeekday = (start_date..end_date).group_by(&:wday)
datesByWeekday[0] # All Sundays

例如,要获取 2019 年 3 月的所有星期六:

> (Date.new(2019,03,01)..Date.new(2019,04,01)).group_by(&:wday)[0]
=> [Sun, 03 Mar 2019, Sun, 10 Mar 2019, Sun, 17 Mar 2019, Sun, 24 Mar 2019, Sun, 31 Mar 2019]

https://apidock.com/ruby/Date/wday


7
投票

对速度感到好奇,所以这就是我所做的。

这里有两种解决问题的方法:

  • 使用范围和过滤器
  • 找到第一天并将
    1.week
    添加到该天,直到停止

对于范围解决方案,有不同的使用范围的方法:

  • 获取所有日期并按工作日分组
  • 在范围内运行选择功能
  • 将范围转换为数组,然后运行 select

如何选择日期也很重要:

  • 在要求的日期运行
    include?
  • 查找两个数组之间的交集并检查是否为空

我制作了一个文件来测试所有这些方法。我称之为

test.rb
。我将它放在 Rails 应用程序的根目录下。我通过输入以下命令来运行它:

  • rails c
  • load 'test.rb'

这是测试文件:

@days = {
  'Sunday' => 0, 'Monday' => 1, 'Tuesday' => 2, 'Wednesday' => 3,
  'Thursday' => 4, 'Friday' => 5, 'Saturday' => 6,
}
@start = Date.today
@stop = Date.today + 1.year

# use simple arithmetic to count number of weeks and then get all days by adding a week
def division(args)
  my_days = args.map { |key| @days[key] }
  total_days = (@stop - @start).to_i
  start_day = @start.wday
  my_days.map do |wday|
    total_weeks = total_days / 7
    remaining_days = total_days % 7
    total_weeks += 1 if is_there_wday? wday, remaining_days, @stop
    days_to_add = wday - start_day
    days_to_add = days_to_add + 7 if days_to_add.negative?
    next_day = @start + days_to_add
    days = []
    days << next_day
    (total_weeks - 1).times do
      next_day = next_day + 1.week
      days << next_day
    end
    days
  end.flatten.sort
end

def is_there_wday?(wday, remaining_days, stop)
  new_start = stop - remaining_days
  (new_start..stop).map(&:wday).include? wday
end

# take all the dates and group them by weekday
def group_by(args)
  my_days = args.map { |key| @days[key] }
  grouped = (@start..@stop).group_by(&:wday)
  my_days.map { |wday| grouped[wday] }.flatten.sort
end

# run the select function on the range
def select_include(args)
  my_days = args.map { |key| @days[key] }
  (@start..@stop).select { |x| my_days.include? x.wday }
end

# run the select function on the range
def select_intersect(args)
  my_days = args.map { |key| @days[key] }
  (@start..@stop).select { |x| (my_days & [x.wday]).any? }
end

# take all the dates, convert to array, and then select
def to_a_include(args)
  my_days = args.map { |key| @days[key] }
  (@start..@stop).to_a.select { |k| my_days.include? k.wday }
end

# take all dates, convert to array, and check if interection is empty
def to_a_intersect(args)
  my_days = args.map { |key| @days[key] }
  (@start..@stop).to_a.select { |k| (my_days & [k.wday]).any? }
end

many = 10_000
Benchmark.bmbm do |b|
  [[], ['Sunday'], ['Sunday', 'Saturday'], ['Sunday', 'Wednesday', 'Saturday']].each do |days|
    str = days.map { |x| @days[x] }
    b.report("#{str} division")       { many.times { division days }}
    b.report("#{str} group_by")       { many.times { group_by days }}
    b.report("#{str} select_include") { many.times { select_include days }}
    b.report("#{str} select_&")       { many.times { select_intersect days }}
    b.report("#{str} to_a_include")   { many.times { to_a_include days }}
    b.report("#{str} to_a_&")         { many.times { to_a_intersect days }}
  end
end

排序结果

[] division               0.017671
[] select_include         2.459335
[] group_by               2.743273
[] to_a_include           2.880896
[] to_a_&                 4.723146
[] select_&               5.235843

[0] to_a_include          2.539350
[0] select_include        2.543794
[0] group_by              2.953319
[0] division              4.494644
[0] to_a_&                4.670691
[0] select_&              4.897872

[0, 6] to_a_include       2.549803
[0, 6] select_include     2.553911
[0, 6] group_by           4.085657
[0, 6] to_a_&             4.776068
[0, 6] select_&           5.016739
[0, 6] division          10.203996

[0, 3, 6] select_include  2.615217
[0, 3, 6] to_a_include    2.618676
[0, 3, 6] group_by        4.605810
[0, 3, 6] to_a_&          5.032614
[0, 3, 6] select_&        5.169711
[0, 3, 6] division       14.679557

趋势

  • range.select
    range.to_a.select
  • 稍快
  • include?
    intersect.any?
  • group_by
    intersect.any?
    快,但比
    include?
  • division
    在没有给出任何内容时速度很快,但传递的参数越多,速度就会显着减慢

结论

如果您结合

select
include?
,您将拥有解决此问题的最快且最可靠的解决方案


0
投票
(Date.new(2025, 1, 1)..Date.new(2025, 12, 31)).select(&:sunday?)

(Date.new(2025, 1, 1)..Date.new(2025, 12, 31)).find_all(&:sunday?)

根据需要修改开始和结束日期。

© www.soinside.com 2019 - 2024. All rights reserved.