blocks|key|1434795|text|你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1434796|Time.at(t.to_i/(15*60)*(15*60))|code-block|syntax|javascript|1434797|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You could do:

<pre><code>Time.at(t.to_i/(15*60)*(15*60))
</code></pre>

blocks|key|1649448|text|您当前的评估使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1649449|min+/+15+*+15+|code-block|syntax|javascript|1649450|只是截断了最小值，所以|1649451|15+=>+15
16+=>+15
..
29+=>+15
30+=>+30+|1649452|这不是“四舍五入”。|1649453|你可以用一种不好的方式来近似舍入|1649454|((+min+%2B+7.5+)+/+15).to_i+*+15+|1649455|或者，使用内部组件：|1649456|(+min.to_f+/+15+).round+*+15|1649457|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Your current evaluation using 

<pre><code>min / 15 * 15 
</code></pre>

is only truncating the min, so 

<pre><code>15 =&gt; 15
16 =&gt; 15
..
29 =&gt; 15
30 =&gt; 30 
</code></pre>

Which is not 'rounding'.

You can approximate rounding in a bad-way with

<pre><code>(( min + 7.5 ) / 15).to_i * 15 
</code></pre>

Or, using internals: 

<pre><code>( min.to_f / 15 ).round * 15
</code></pre>

blocks|key|1434880|text|由于Ruby允许在Times上进行算术运算(以秒为单位)，因此您可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1434881|t+=+Time.new
rounded_t+=+t-t.sec-t.min%2515*60|code-block|syntax|javascript|1434882|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Since Ruby allows arithmetic (in seconds) on Times, you can just do this:

<pre><code>t = Time.new
rounded_t = t-t.sec-t.min%15*60
</code></pre>

blocks|key|1434886|text|#+this+is+an+extension+of+Ryan+McGeary's+solution,+specifically+for+Rails.
#+Note+the+use+of+utc,+which+is+necessary+to+keep+Rails+time+zone+stuff+happy.
#+put+this+in+config/initializers/time_extensions

require+'rubygems'
require+'active_support'

module+TimeExtensions
++%25w[+round+floor+ceil+].each+do+%7C_method%7C
++++define_method+_method+do+%7C*args%7C
++++++seconds+=+args.first+%7C%7C+60
++++++Time.at((self.to_f+/+seconds).send(_method)+*+seconds).utc
++++end
++end
end

Time.send+:include,+TimeExtensions|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1434887|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code># this is an extension of Ryan McGeary's solution, specifically for Rails.
# Note the use of utc, which is necessary to keep Rails time zone stuff happy.
# put this in config/initializers/time_extensions

require 'rubygems'
require 'active_support'

module TimeExtensions
 %w[ round floor ceil ].each do |_method|
 define_method _method do |*args|
 seconds = args.first || 60
 Time.at((self.to_f / seconds).send(_method) * seconds).utc
 end
 end
end

Time.send :include, TimeExtensions
</code></pre>

blocks|key|1434928|text|我想我应该发布另一个解决方案，提供向上和向下舍入到给定的最接近的秒数。哦，而且这不会像其他一些解决方案那样改变时区。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1434929|class+Time
++def+round(sec=1)
++++down+=+self+-+(self.to_i+%25+sec)
++++up+=+down+%2B+sec

++++difference_down+=+self+-+down
++++difference_up+=+up+-+self

++++if+(difference_down+<+difference_up)
++++++return+down
++++else
++++++return+up
++++end
++end
end

t+=+Time.now+++++++++++++++++++++++++++++#+=>+Mon+Nov+15+10:18:29+%2B0200+2010
t.round(15.minutes)++++++++++++++++++++++#+=>+Mon+Nov+15+10:15:00+%2B0200+2010
t.round(20.minutes)++++++++++++++++++++++#+=>+Mon+Nov+15+10:20:00+%2B0200+2010
t.round(60.minutes)++++++++++++++++++++++#+=>+Mon+Nov+15+10:00:00+%2B0200+2010|code-block|syntax|javascript|1434930|在x.minutes特性的示例中使用了ActiveSupport。您可以使用15+*+60。|1434931|基于该方案可以很容易地实现floor和ceil方法。|1434932|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I thought I would post another solution that provides rounding up and down to the nearest number of seconds given. Oh, and this does not change the time zone like some of the other solutions.

<pre><code>class Time
 def round(sec=1)
 down = self - (self.to_i % sec)
 up = down + sec

 difference_down = self - down
 difference_up = up - self

 if (difference_down &lt; difference_up)
 return down
 else
 return up
 end
 end
end

t = Time.now # =&gt; Mon Nov 15 10:18:29 +0200 2010
t.round(15.minutes) # =&gt; Mon Nov 15 10:15:00 +0200 2010
t.round(20.minutes) # =&gt; Mon Nov 15 10:20:00 +0200 2010
t.round(60.minutes) # =&gt; Mon Nov 15 10:00:00 +0200 2010
</code></pre>

ActiveSupport was used in the examples for the x.minutes feature. You can use 15 * 60 instead.

Methods floor and ceil can be easily implemented based on this solution.

blocks|key|1649610|text|Chuck的答案虽然优雅，但如果您尝试以这种方式比较派生的值，将会遇到麻烦；usecs没有归零。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1649611|Shalmanese的答案可以解决这个问题，或者Chuck的答案可以修改为：|1649612|t+=+Time.new
truncated_t+=+Time.at(t.to_i+-+t.sec+-+t.min+%25+15+*+60)|code-block|syntax|javascript|1649613|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Chuck's answer, while elegant, will run you into trouble if you try to compare values derived in this way; the usecs are not zeroed out.

Shalmanese' answer takes care of that, or Chuck's can be modified as:

<pre><code>t = Time.new
truncated_t = Time.at(t.to_i - t.sec - t.min % 15 * 60)
</code></pre>

blocks|key|1649657|text|我找到了一个可读性很强的解决方案；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1649658|这将使您的时间四舍五入到最后15分钟。您可以将15.minutes更改为所有可能的时间刻度。|offset|length|style|CODE|1649659|Time.at(Time.now.to_i+-+(Time.now.to_i+%25+15.minutes))|code-block|syntax|javascript|1649660|entityMap^0|0|N|A|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I found a very readable solution;

This will round your time to the last rounded 15 minutes. You can change the <code>15.minutes</code> to every timescale possible.

<pre><code>Time.at(Time.now.to_i - (Time.now.to_i % 15.minutes))
</code></pre>

blocks|key|1649679|text|Ryan+McGeary的解决方案不适用于不在半小时内的时区。例如，加德满都是%2B5:45，所以舍入到30分钟得到了错误的结果。这应该是可行的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1649680|class+ActiveSupport::TimeWithZone
++def+floor(seconds+=+60)
++++return+self+if+seconds.zero?
++++Time.at(((self+-+self.utc_offset).to_f+/+seconds).floor+*+seconds).in_time_zone+%2B+self.utc_offset
++end

++def+ceil(seconds+=+60)
++++return+self+if+seconds.zero?
++++Time.at(((self+-+self.utc_offset).to_f+/+seconds).ceil+*+seconds).in_time_zone+%2B+self.utc_offset
++end

++#+returns+whichever+(out+of+#floor+and+#ceil)+is+closer+to+the+current+time
++def+closest(seconds+=+60)
++++down,+up+=+floor(seconds),+ceil(seconds)
++++((self+-+down).abs+>+(self+-+up).abs)+?+up+:+down
++end
end|code-block|syntax|javascript|1649681|和测试：|1649682|class+TimeHelperTest+<+ActionDispatch::IntegrationTest
++test+"floor"+do
++++t+=+Time.now.change(min:+14)
++++assert_equal+Time.now.change(min:+10),+t.floor(5.minutes)
++++assert_equal+Time.now.change(min:+0),+t.floor(30.minutes)
++end

++test+"ceil"+do
++++t+=+Time.now.change(min:+16)
++++assert_equal+Time.now.change(min:+20),+t.ceil(5.minutes)
++++assert_equal+Time.now.change(min:+30),+t.ceil(30.minutes)
++end

++test+"closest"+do
++++t+=+Time.now.change(min:+18)
++++assert_equal+Time.now.change(min:+20),+t.closest(5.minutes)
++++assert_equal+Time.now.change(min:+30),+t.closest(30.minutes)
++++assert_equal+Time.now.change(min:+0),+t.closest(60.minutes)
++end

++test+"works+in+time+zones+that+are+off+the+half+hour"+do
++++Time.zone+=+"Kathmandu"
#2.1.0p0+:028+>+Time.zone.now
#+=>+Tue,+30+Sep+2014+06:46:12+NPT+%2B05:45+#+doing+.round(30.minutes)+here+would+give+06:45+under+the+old+method

++++t+=+Time.zone.now.change(min:+30)
++++assert_equal+Time.zone.now.change(min:+30),+t.closest(30.minutes)

++++t+=+Time.zone.now.change(min:+0)
++++assert_equal+Time.zone.now.change(min:+0),+t.closest(30.minutes)
++end
end|1649683|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Ryan McGeary's solution didn't work for time zones that were not on the half hour. For example, Kathmandu is +5:45, so rounding to 30.minutes was getting the wrong results. This should work:

<pre><code>class ActiveSupport::TimeWithZone
 def floor(seconds = 60)
 return self if seconds.zero?
 Time.at(((self - self.utc_offset).to_f / seconds).floor * seconds).in_time_zone + self.utc_offset
 end

 def ceil(seconds = 60)
 return self if seconds.zero?
 Time.at(((self - self.utc_offset).to_f / seconds).ceil * seconds).in_time_zone + self.utc_offset
 end

 # returns whichever (out of #floor and #ceil) is closer to the current time
 def closest(seconds = 60)
 down, up = floor(seconds), ceil(seconds)
 ((self - down).abs &gt; (self - up).abs) ? up : down
 end
end
</code></pre>

And tests:

<pre><code>class TimeHelperTest &lt; ActionDispatch::IntegrationTest
 test "floor" do
 t = Time.now.change(min: 14)
 assert_equal Time.now.change(min: 10), t.floor(5.minutes)
 assert_equal Time.now.change(min: 0), t.floor(30.minutes)
 end

 test "ceil" do
 t = Time.now.change(min: 16)
 assert_equal Time.now.change(min: 20), t.ceil(5.minutes)
 assert_equal Time.now.change(min: 30), t.ceil(30.minutes)
 end

 test "closest" do
 t = Time.now.change(min: 18)
 assert_equal Time.now.change(min: 20), t.closest(5.minutes)
 assert_equal Time.now.change(min: 30), t.closest(30.minutes)
 assert_equal Time.now.change(min: 0), t.closest(60.minutes)
 end

 test "works in time zones that are off the half hour" do
 Time.zone = "Kathmandu"
#2.1.0p0 :028 &gt; Time.zone.now
# =&gt; Tue, 30 Sep 2014 06:46:12 NPT +05:45 # doing .round(30.minutes) here would give 06:45 under the old method

 t = Time.zone.now.change(min: 30)
 assert_equal Time.zone.now.change(min: 30), t.closest(30.minutes)

 t = Time.zone.now.change(min: 0)
 assert_equal Time.zone.now.change(min: 0), t.closest(30.minutes)
 end
end
</code></pre>

blocks|key|1649741|text|我编写了Rounding+gem来处理这类情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1649742|向下舍入时间就像在时间上调用floor_to一样简单。还支持向上舍入和舍入到最近的值(ceil_to和round_to)。|style|CODE|1649743|require+"rounding"

Time.current.floor_to(15.minutes)+#+=>+Thu,+07+May+2015+16:45:00+UTC+%2B00:00
Time.current.ceil_to(15.minutes)++#+=>+Thu,+07+May+2015+17:00:00+UTC+%2B00:00
Time.current.round_to(15.minutes)+#+=>+Thu,+07+May+2015+16:45:00+UTC+%2B00:00|code-block|syntax|javascript|1649744|保留原始时间的时区(本例中为UTC)。你不需要加载ActiveSupport+--你可以写floor_to(15*60)，它会工作的很好。gem使用Rational数字来避免舍入误差。您可以通过提供偏移量round_to(1.week,+Time.parse("2015-5-4+00:00:00+UTC"))来舍入到最近的星期一。我们在生产中使用它。|1649745|我写了一个blog+post来解释更多。希望这对你有帮助。|1649746|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/brianhempel/rounding|1|http://ruby-doc.org/core-2.2.2/Rational.html|2|http://collectiveidea.com/blog/archives/2015/05/01/better-ruby-rounding/^0|4|C|0|0|E|8|17|7|1F|8|0|0|19|F|2U|1H|22|8|1|0|5|9|2|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|6|7|16|8|@$A|17|B|18|F|G]|$A|19|B|1A|F|G]|$A|1B|B|1C|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|1D|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1E|8|@$A|1F|B|1G|F|G]|$A|1H|B|1I|F|G]]|9|@$A|1J|B|1K|1|1L]]|C|$]]|$1|O|3|P|5|6|7|1M|8|@]|9|@$A|1N|B|1O|1|1P]]|C|$]]|$1|Q|3|-4|5|6|7|1Q|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]|Y|$5|T|U|V|C|$W|Z]]|10|$5|T|U|V|C|$W|11]]]]

I wrote the <a href="https://github.com/brianhempel/rounding" rel="noreferrer">Rounding gem</a> to handle these sort of cases.

Rounding down a time becomes as simple as calling <code>floor_to</code> on the time. Rounding up and rounding to the nearest are also supported (<code>ceil_to</code> and <code>round_to</code>).

<pre><code>require "rounding"

Time.current.floor_to(15.minutes) # =&gt; Thu, 07 May 2015 16:45:00 UTC +00:00
Time.current.ceil_to(15.minutes) # =&gt; Thu, 07 May 2015 17:00:00 UTC +00:00
Time.current.round_to(15.minutes) # =&gt; Thu, 07 May 2015 16:45:00 UTC +00:00
</code></pre>

The time zone of the original time is preserved (UTC in this case). You don't need ActiveSupport loaded—you can write <code>floor_to(15*60)</code> and it will work fine. The gem uses <a href="http://ruby-doc.org/core-2.2.2/Rational.html" rel="noreferrer">Rational</a> numbers to avoid rounding errors. You can round to the nearest Monday by providing an offset <code>round_to(1.week, Time.parse("2015-5-4 00:00:00 UTC"))</code>. We use it in production.

I wrote a <a href="http://collectiveidea.com/blog/archives/2015/05/01/better-ruby-rounding/" rel="noreferrer">blog post</a> that explains more. Hope you find it helpful.

Is there an easy way to round a Time down to the nearest 15 minutes? 

This is what I'm currently doing. Is there an easier way to do it?

<pre><code>t = Time.new
rounded_t = Time.local(t.year, t.month, t.day, t.hour, t.min/15*15)
</code></pre>

How to round a time down to the nearest 15 minutes in Ruby?

有没有一种简单的方法将时间四舍五入到最近的15分钟？这就是我目前正在做的事情。有没有更简单的方法呢？t = Time.newrounded_t = Time.local(t.year, t.month, t.day, t.hour, t.min/15*15)

问在Ruby中如何将时间向下舍入到最接近的15分钟？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中如何将时间向下舍入到最接近的15分钟？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中如何将时间向下舍入到最接近的15分钟？
EN