blocks|key|1358253|text|使用each遍历Ruby语言中的范围时，会对范围中的第一个对象调用succ方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1358254|$+4.succ
=>+5|code-block|syntax|javascript|1358255|5在范围之外。|1358256|你可以用这个技巧来模拟反向迭代：|1358257|(-4..0).each+{+%7Cn%7C+puts+n.abs+}|1358258|John指出，如果跨度为0，这将不起作用。这将：|1358259|>>+(-2..2).each+{+%7Cn%7C+puts+-n+}
2
1
0
-1
-2
=>+-2..2|1358260|我不能说我真的喜欢他们中的任何一个，因为他们有点模糊了意图。|1358261|entityMap^0|2|4|X|4|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|15|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|17|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|19|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|X|$]]

Iterating over a range in Ruby with <code>each</code> calls the <code>succ</code> method on the first object in the range.

<pre><code>$ 4.succ
=&gt; 5
</code></pre>

And 5 is outside the range.

You can simulate reverse iteration with this hack:

<pre><code>(-4..0).each { |n| puts n.abs }
</code></pre>

John pointed out that this will not work if it spans 0. This would:

<pre><code>&gt;&gt; (-2..2).each { |n| puts -n }
2
1
0
-1
-2
=&gt; -2..2
</code></pre>

Can't say I really like any of them because they kind of obscure the intent.

blocks|key|1358278|text|如果列表没有那么大的话。我认为[*0..4].reverse.each+{+%7Ci%7C+puts+i+}是最简单的方式。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1358279|entityMap^0|F|Z|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

if list is not that big.
i think
<code>[*0..4].reverse.each { |i| puts i }</code> 
is simplest way.

blocks|key|1358327|text|我添加了另一种可能性，如何在反向范围内实现迭代。我没有使用它，但它是一种可能性。为ruby核心对象打补丁有点冒险。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1358328|class+Range

++def+each(&block)
++++direction+=+(first<=last+?+1+:+-1)
++++i+=+first
++++not_reached_the_end+=+if+first<=last
++++++++++++++++++++++++++++lambda+{%7Ci%7C+i<=last}
++++++++++++++++++++++++++else
++++++++++++++++++++++++++++lambda+{%7Ci%7C+i>=last}
++++++++++++++++++++++++++end
++++while+not_reached_the_end.call(i)
++++++yield+i
++++++i+%2B=+direction
++++end
++end
end|code-block|syntax|javascript|1358329|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|$]]

I add one another possibility how to realise iteration over reverse Range. I do not use it, but it is a possibility. It is a bit risky to monkey patch ruby core objects.

<pre><code>class Range

 def each(&amp;block)
 direction = (first&lt;=last ? 1 : -1)
 i = first
 not_reached_the_end = if first&lt;=last
 lambda {|i| i&lt;=last}
 else
 lambda {|i| i&gt;=last}
 end
 while not_reached_the_end.call(i)
 yield i
 i += direction
 end
 end
end
</code></pre>

blocks|key|1358360|text|根据“编程Ruby”一书，Range对象存储range的两个端点，并使用.succ成员生成中间值。根据您在范围中使用的数据类型，您始终可以创建Integer的子类并重新定义.succ成员，以便它像反向迭代器一样工作(您可能还希望重新定义.next+)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1358361|您也可以在不使用范围的情况下获得所需的结果。试试这个：|1358362|4.step(0,+-1)+do+%7Ci%7C
++++puts+i
end|code-block|syntax|javascript|1358363|这将以-1的步长从4步进到0。但是，我不知道这是否适用于除Integer参数之外的任何东西。|1358364|entityMap^0|10|5|1Z|7|2E|5|3A|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

According to the book "Programming Ruby", the Range object stores the two endpoints of the range and uses the <code>.succ</code> member to generate the intermediate values. Depending on what kind of data type you are using in your range, you can always create a subclass of <code>Integer</code> and re-define the <code>.succ</code> member so that it acts like a reverse iterator (you would probably also want to re-define <code>.next</code> as well).

You can also achieve the results you are looking for without using a Range. Try this:

<pre><code>4.step(0, -1) do |i|
 puts i
end
</code></pre>

This will step from 4 to 0 in steps of -1. However, I don't know if this will work for anything except Integer arguments.

blocks|key|1143280|text|正如bta所说，原因是Range#each将succ发送到其开头，然后发送到succ调用的结果，依此类推，直到结果大于结束值。你不能通过调用succ从4到0，实际上你已经开始大于结束了。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1143281|entityMap^0|B|A|M|4|12|4|1Y|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

As bta said, the reason is that <code>Range#each</code> sends <code>succ</code> to its beginning, then to the result of that <code>succ</code> call, and so on until the result is greater than the end value. You can't get from 4 to 0 by calling <code>succ</code>, and in fact you already start out greater than the end.

blocks|key|1358481|text|您甚至可以使用for循环：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1358482|for+n+in+4.downto(0)+do
++print+n
end|code-block|syntax|javascript|1358483|打印的内容：|1358484|4
3
2
1
0|1358485|entityMap^0|7|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

You can even use a <code>for</code> loop:

<pre><code>for n in 4.downto(0) do
 print n
end
</code></pre>

which prints:

<pre><code>4
3
2
1
0
</code></pre>

blocks|key|1143391|text|向后迭代范围的(0..1).reverse_each怎么样？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1143392|entityMap^0|7|J|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

How about <code>(0..1).reverse_each</code> which iterates the range backwards?

blocks|key|1358577|text|另一种方式是(1..10).to_a.reverse|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1358578|entityMap^0|6|K|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Another way is <code>(1..10).to_a.reverse</code>

blocks|key|1358611|text|这适用于我的懒惰用例|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1358612|(-999999..0).lazy.map{%7Cx%7C+-x}.first(3)
#=>+[999999,+999998,+999997]|code-block|syntax|javascript|1358613|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|$]]

This worked for my lazy use case

<pre><code>(-999999..0).lazy.map{|x| -x}.first(3)
#=&gt; [999999, 999998, 999997]
</code></pre>

blocks|key|1143481|text|对我来说，最简单的方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1143482|[*0..9].reverse|code-block|syntax|javascript|1143483|迭代for枚举的另一种方法：|1143484|(1..3).reverse_each{%7Cv%7C+p+v}|1143485|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|$]]

As for me the simplest way is:

<pre><code>[*0..9].reverse
</code></pre>

Another way to iterate for enumeration:

<pre><code>(1..3).reverse_each{|v| p v}
</code></pre>

I tried to iterate backwards with using a Range and <code>each</code>:

<pre><code>(4..0).each do |i|
 puts i
end
==&gt; 4..0
</code></pre>

Iteration through <code>0..4</code> writes the numbers. On the other Range <code>r = 4..0</code> seems to be ok, <code>r.first == 4</code>, <code>r.last == 0</code>.

It seems to be strange to me that the construct above does not produce the expected result. What is the a reason for that? What are the situations when this behaviour is reasonable?

Is there a reason that we cannot iterate on "reverse Range" in ruby?

我尝试使用范围和each向后迭代(4..0).each do |i|  puts iend==> 4..0通过0..4迭代写入数字。在另一个范围内，r = 4..0似乎是好的，r.first == 4，r.last == 0。上面的构造没有产生预期的结果，这对我来说似乎很奇怪。这么做的原因是什么？在什么情况下，这种行为...

问为什么我们不能在ruby中迭代“反转范围”？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我们不能在ruby中迭代“反转范围”？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我们不能在ruby中迭代“反转范围”？
EN