Ruby'de "Ters Aralık" üzerinde yinelemememizin bir nedeni var mı?

Bir Aralık kullanarak geriye doğru yinelemeye çalıştım ve each:

(4..0).each do |i|
  puts i
end
==> 4..0

Yineleme 0..4, sayıları yazar. Diğer taraftan Menzil r = 4..0ok gibi görünüyor, r.first == 4, r.last == 0.

Yukarıdaki yapının beklenen sonucu vermemesi bana garip geliyor. Bunun sebebi nedir? Bu davranışın makul olduğu durumlar nelerdir?

Aralık sadece şudur: içeriği ile değil, başlangıcı ve bitişi ile tanımlanan bir şey. Bir aralıkta "yinelemek" genel bir durumda gerçekten mantıklı değildir. Örneğin, iki tarih tarafından üretilen aralık üzerinde nasıl "yineleme" yapacağınızı düşünün. Gün geçtikçe tekrar eder misin? ayda? yıla göre? haftalık İyi tanımlanmış değil. IMO, ileri menzillere izin verildiği gerçeği, yalnızca uygun bir yöntem olarak görülmelidir.

Böyle bir aralıkta geriye doğru yineleme yapmak istiyorsanız, her zaman kullanabilirsiniz downto:

$ r = 10..6
=> 10..6

$ (r.first).downto(r.last).each { |i| puts i }
10
9
8
7
6

İşte biraz daha düşünceler hem yinelemeyi izin ve tutarlı ters aralıkları ile uğraşmak zor olduğunu neden diğerlerinden.

Peki (0..1).reverse_eachhangi aralık geriye doğru dolaşır?

Ruby'de bir aralık üzerinde yinelemek, aralıktaki ilk nesnede yöntemi eachçağırır succ.

$ 4.succ
=> 5

Ve 5 aralığın dışında.

Bu hack ile ters yinelemeyi simüle edebilirsiniz:

(-4..0).each { |n| puts n.abs }

John, 0'ı kaplarsa bunun işe yaramayacağına işaret etti. Bu:

>> (-2..2).each { |n| puts -n }
2
1
0
-1
-2
=> -2..2

Bunların herhangi birini gerçekten sevdiğimi söyleyemem çünkü niyeti belirsizleştiriyorlar.

"Programlama Ruby" kitabına göre, Range nesnesi aralığın iki uç noktasını saklar ve .succüyeyi ara değerleri oluşturmak için kullanır . Aralığınızda ne tür veri kullandığınıza bağlı olarak, her zaman bir alt sınıf oluşturabilir Integerve .succbir ters yineleyici gibi davranması için üyeyi yeniden tanımlayabilirsiniz (muhtemelen siz de yeniden tanımlamak isteyeceksiniz .next).

Ayrıca, Aralık kullanmadan da aradığınız sonuçları elde edebilirsiniz. Bunu dene:

4.step(0, -1) do |i|
    puts i
end

Bu, -1'lik adımlarla 4'ten 0'a adım atacaktır. Ancak, bunun Tamsayı bağımsız değişkenleri dışında herhangi bir şey için işe yarayıp yaramayacağını bilmiyorum.

Başka bir yol (1..10).to_a.reverse

Bir fordöngü bile kullanabilirsiniz :

for n in 4.downto(0) do
  print n
end

hangi yazdırır:

4
3
2
1
0

liste o kadar büyük değilse. bence [*0..4].reverse.each { |i| puts i } en basit yol.

Bta dediği gibi, nedeni olduğunu Range#eachgönderir succo sonucuna kendi başlarına succve böylece sonuç bitiş değerinden büyük olana kadar aramaya. Arayarak 4'ten 0'a ulaşamazsınız succve aslında zaten sondan daha büyük başlıyorsunuz.

Reverse Range üzerinden yinelemenin nasıl gerçekleştirileceğine dair bir olasılık daha ekliyorum. Kullanmıyorum ama bu bir olasılık. Yakut çekirdek nesnelerine yama yapmak biraz risklidir.

class Range

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

Bu tembel kullanım durumum için çalıştı

(-999999..0).lazy.map{|x| -x}.first(3)
#=> [999999, 999998, 999997]

OP yazdı

Yukarıdaki yapının beklenen sonucu vermemesi bana garip geliyor. Bunun sebebi nedir? Bu davranışın makul olduğu durumlar nelerdir?

"Yapılabilir mi?" ama aslında sorulan soruya gelmeden önce sorulmayan soruyu cevaplamak için:

$ irb
2.1.5 :001 > (0..4)
 => 0..4
2.1.5 :002 > (0..4).each { |i| puts i }
0
1
2
3
4
 => 0..4
2.1.5 :003 > (4..0).each { |i| puts i }
 => 4..0
2.1.5 :007 > (0..4).reverse_each { |i| puts i }
4
3
2
1
0
 => 0..4
2.1.5 :009 > 4.downto(0).each { |i| puts i }
4
3
2
1
0
 => 4

Reverse_each'in tüm bir diziyi oluşturduğu iddia edildiğinden, aşağıya doğru açıkça daha verimli olacaktır. Bir dil tasarımcısının bu tür şeyleri uygulamayı bile düşünebilmesi, sorulduğu gibi asıl sorunun cevabına bağlanır.

Soruyu gerçekten sorulduğu gibi cevaplamak için ...

Bunun nedeni, Ruby'nin sonsuz derecede şaşırtıcı bir dil olmasıdır. Bazı sürprizler hoştur, ancak tamamen bozulmuş birçok davranış vardır. Aşağıdaki örneklerden bazıları daha yeni sürümlerle düzeltilse bile, başka pek çok örnek var ve bunlar orijinal tasarımın zihniyetine yönelik suçlamalar olarak kalıyor:

nil.to_s
   .to_s
   .inspect

"" ile sonuçlanır ancak

nil.to_s
#  .to_s   # Don't want this one for now
   .inspect

sonuçlanır

 syntax error, unexpected '.', expecting end-of-input
 .inspect
 ^

Muhtemelen << ve dizilere ekleme için aynı olmasını beklersiniz, ancak

a = []
a << *[:A, :B]    # is illegal but
a.push *[:A, :B]  # isn't.

Muhtemelen 'grep'in Unix komut satırı eşdeğeri gibi davranmasını beklersiniz, ancak ismine rağmen === eşleşmeyen = ~ ile eşleşmez.

$ echo foo | grep .
foo
$ ruby -le 'p ["foo"].grep(".")'
[]

Çeşitli yöntemler beklenmedik şekilde birbirlerinin takma adlarıdır, bu nedenle aynı şey için birden fazla ad öğrenmeniz gerekir - örneğin findve detect- çoğu geliştiriciyi sevseniz ve yalnızca birini veya diğerini kullansanız bile. Hemen hemen aynı için de geçerlidir size, countve lengthfarklı şekilde tanımlamak ya da hiç bir ya da iki tanımlamaz sınıfları haricinde.

Birisi başka bir şey uygulamadıysa - tapekrandaki bir şeye basmak için çeşitli otomasyon kitaplıklarında çekirdek yöntem yeniden tanımlanmış gibi. Neler olup bittiğini öğrenmede iyi şanslar, özellikle de başka bir modülün gerektirdiği bazı modül, belgelenmemiş bir şey yapmak için başka bir modül başlattıysa.

Ortam değişkeni nesnesi, ENV 'birleştirmeyi' desteklemiyor, bu yüzden yazmanız gerekiyor

 ENV.to_h.merge('a': '1')

Bonus olarak, ne olması gerektiği konusunda fikrinizi değiştirirseniz, kendinizin veya bir başkasının sabitlerini yeniden tanımlayabilirsiniz.

Bana gelince, en basit yol:

[*0..9].reverse

Numaralandırma için yinelemenin başka bir yolu:

(1..3).reverse_each{|v| p v}