มีเหตุผลไหมที่เราไม่สามารถทำซ้ำใน "Reverse Range" ในทับทิมได้?

ฉันพยายามทำซ้ำไปข้างหลังโดยใช้ Range และeach:

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

การวนซ้ำ0..4เขียนตัวเลข ในอีกช่วงหนึ่งr = 4..0ดูเหมือนจะโอเคr.first == 4, r.last == 0.

ดูเหมือนว่าจะแปลกสำหรับฉันที่โครงสร้างข้างต้นไม่ได้ผลลัพธ์ที่คาดหวัง อะไรคือเหตุผลสำหรับสิ่งนั้น? อะไรคือสถานการณ์เมื่อพฤติกรรมนี้สมเหตุสมผล?

ช่วงคือสิ่งที่กำหนดโดยจุดเริ่มต้นและจุดสิ้นสุดไม่ใช่โดยเนื้อหา การ "วนซ้ำ" ในช่วงไม่สมเหตุสมผลในกรณีทั่วไป ตัวอย่างเช่นลองพิจารณาว่าคุณจะ "วนซ้ำ" อย่างไรในช่วงที่เกิดจากวันที่สองวัน คุณจะทำซ้ำในแต่ละวันหรือไม่? ตามเดือน? ตามปี? ตามสัปดาห์? มันไม่ได้กำหนดไว้อย่างชัดเจน IMO ความจริงที่อนุญาตสำหรับช่วงการส่งต่อควรถูกมองว่าเป็นวิธีอำนวยความสะดวกเท่านั้น

หากคุณต้องการย้อนกลับในช่วงดังกล่าวคุณสามารถใช้downto:

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

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

ต่อไปนี้เป็นความคิดเพิ่มเติมจากผู้อื่นว่าเหตุใดจึงยากที่จะยอมให้ทำซ้ำและจัดการกับช่วงย้อนกลับอย่างสม่ำเสมอ

แล้ว(0..1).reverse_eachจะวนซ้ำช่วงใดไปข้างหลัง?

การทำซ้ำในช่วงใน Ruby พร้อมกับeachเรียกใช้succเมธอดบนวัตถุแรกในช่วง

$ 4.succ
=> 5

และ 5 อยู่นอกช่วง

คุณสามารถจำลองการย้อนกลับได้ด้วยแฮ็คนี้:

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

จอห์นชี้ให้เห็นว่าสิ่งนี้จะใช้ไม่ได้หากมีช่วง 0 สิ่งนี้จะ:

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

ไม่สามารถพูดได้ว่าฉันชอบพวกเขามาก ๆ เพราะมันบดบังเจตนา

อ้างอิงจากหนังสือ "Programming Ruby" วัตถุ Range จะเก็บจุดปลายทั้งสองของช่วงและใช้.succสมาชิกเพื่อสร้างค่ากลาง ขึ้นอยู่กับประเภทข้อมูลที่คุณใช้ในช่วงของคุณคุณสามารถสร้างคลาสย่อยIntegerและกำหนด.succสมาชิกใหม่ได้ตลอดเวลาเพื่อให้ทำหน้าที่เหมือนตัวย้อนกลับ (คุณอาจต้องการกำหนดใหม่ด้วย.nextเช่นกัน)

คุณยังสามารถบรรลุผลลัพธ์ที่ต้องการได้โดยไม่ต้องใช้ Range ลองสิ่งนี้:

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

ขั้นตอนนี้จะเพิ่มจาก 4 ถึง 0 ในขั้นตอนที่ -1 อย่างไรก็ตามฉันไม่รู้ว่าสิ่งนี้จะใช้ได้กับอะไรยกเว้นอาร์กิวเมนต์จำนวนเต็ม

อีกวิธีหนึ่งคือ (1..10).to_a.reverse

คุณยังสามารถใช้forลูป:

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

ซึ่งพิมพ์:

4
3
2
1
0

ถ้ารายการไม่ใหญ่ขนาดนั้น ฉันคิดว่า [*0..4].reverse.each { |i| puts i } เป็นวิธีที่ง่ายที่สุด

ดังที่ bta กล่าวไว้เหตุผลก็คือRange#eachส่งsuccไปยังจุดเริ่มต้นจากนั้นไปยังผลลัพธ์ของการsuccเรียกนั้นและอื่น ๆ จนกว่าผลลัพธ์จะมากกว่าค่าสุดท้าย คุณไม่สามารถโทรจาก 4 ถึง 0 succได้และในความเป็นจริงคุณได้เริ่มต้นมากกว่าจุดจบแล้ว

ฉันเพิ่มความเป็นไปได้อีกวิธีหนึ่งในการตระหนักถึงการวนซ้ำในช่วงย้อนกลับ ฉันไม่ได้ใช้มัน แต่มันเป็นไปได้ มีความเสี่ยงเล็กน้อยที่จะปะกับวัตถุหลักของทับทิม

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

สิ่งนี้ใช้ได้กับกรณีการใช้งานที่ขี้เกียจของฉัน

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

OP เขียน

ดูเหมือนว่าจะแปลกสำหรับฉันที่โครงสร้างข้างต้นไม่ได้ผลลัพธ์ที่คาดหวัง อะไรคือเหตุผลสำหรับสิ่งนั้น? อะไรคือสถานการณ์เมื่อพฤติกรรมนี้สมเหตุสมผล?

ไม่สามารถทำได้หรือไม่ แต่เพื่อตอบคำถามที่ไม่ได้ถามก่อนที่จะไปถึงคำถามที่ถามจริง:

$ 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 ถูกอ้างว่าสร้างอาร์เรย์ทั้งหมดการหยุดทำงานจะมีประสิทธิภาพมากขึ้นอย่างชัดเจน ความจริงที่ว่านักออกแบบภาษาสามารถพิจารณานำสิ่งต่างๆเช่นนั้นไปใช้กับคำตอบของคำถามจริงตามที่ถามได้

เพื่อตอบคำถามตามที่ถามจริง ...

เหตุผลก็เพราะว่า Ruby เป็นภาษาที่น่าประหลาดใจไม่รู้จบ สิ่งที่น่าประหลาดใจบางอย่างเป็นเรื่องที่น่ายินดี แต่มีพฤติกรรมหลายอย่างที่เสียไปอย่างสิ้นเชิง แม้ว่าตัวอย่างต่อไปนี้บางส่วนจะได้รับการแก้ไขโดยรุ่นที่ใหม่กว่า แต่ก็ยังมีตัวอย่างอื่น ๆ อีกมากมายและยังคงเป็นคำฟ้องในแนวคิดของการออกแบบดั้งเดิม:

nil.to_s
   .to_s
   .inspect

ผลลัพธ์เป็น "" แต่

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

ผลลัพธ์ใน

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

คุณอาจคาดหวัง << และผลักดันให้เหมือนกันสำหรับการต่อท้ายอาร์เรย์ แต่

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

คุณอาจคาดหวังว่า 'grep' จะทำงานเหมือนกับบรรทัดคำสั่ง Unix ที่เทียบเท่า แต่มันไม่ === จับคู่ไม่ = ~ แม้จะมีชื่อก็ตาม

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

วิธีการต่างๆเป็นนามแฝงซึ่งกันและกันโดยไม่คาดคิดดังนั้นคุณต้องเรียนรู้ชื่อหลายชื่อสำหรับสิ่งเดียวกันเช่นfindและdetectแม้ว่าคุณจะชอบนักพัฒนาซอฟต์แวร์ส่วนใหญ่และเคยใช้เพียงชื่อเดียว มากเหมือนกันไปสำหรับsize, countและlengthยกเว้นสำหรับการเรียนที่กำหนดแต่ละที่แตกต่างกันหรือไม่ได้กำหนดหนึ่งหรือสองที่ทั้งหมด

เว้นแต่จะมีใครนำไปใช้อย่างอื่นเช่นวิธีการหลักtapได้รับการกำหนดใหม่ในไลบรารีอัตโนมัติต่างๆเพื่อกดบางอย่างบนหน้าจอ ขอให้โชคดีในการค้นหาว่าเกิดอะไรขึ้นโดยเฉพาะอย่างยิ่งหากโมดูลบางโมดูลที่จำเป็นสำหรับโมดูลอื่น ๆ บางโมดูลได้แยกโมดูลอื่นเพื่อทำสิ่งที่ไม่มีเอกสาร

วัตถุตัวแปรสภาพแวดล้อม ENV ไม่รองรับ 'ผสาน' ดังนั้นคุณต้องเขียน

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

เป็นโบนัสคุณสามารถกำหนดค่าคงที่ของคุณหรือของคนอื่นใหม่ได้หากคุณเปลี่ยนใจเกี่ยวกับสิ่งที่ควรจะเป็น

สำหรับฉันวิธีที่ง่ายที่สุดคือ:

[*0..9].reverse

อีกวิธีในการทำซ้ำสำหรับการแจงนับ:

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