Có lý do gì mà chúng ta không thể lặp lại trên "Dải ngược" trong ruby ​​không?

Tôi đã cố gắng lặp lại bằng cách sử dụng Phạm vi và each:

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

Lặp lại thông qua 0..4ghi các số. Mặt khác Phạm vi r = 4..0có vẻ là ok, r.first == 4, r.last == 0.

Có vẻ như là lạ đối với tôi rằng cấu trúc trên không tạo ra kết quả như mong đợi. Lý do cho điều đó là gì? Những tình huống nào khi hành vi này là hợp lý?

Một phạm vi chỉ là: một cái gì đó được xác định bởi bắt đầu và kết thúc của nó, không phải bởi nội dung của nó. "Lặp lại" trên một phạm vi không thực sự có ý nghĩa trong trường hợp chung. Ví dụ: hãy xem xét cách bạn sẽ "lặp lại" trong phạm vi được tạo bởi hai ngày. Bạn có lặp lại theo ngày không? theo tháng? Theo năm? Theo tuần? Nó không được xác định rõ ràng. IMO, thực tế là nó được phép cho phạm vi chuyển tiếp chỉ nên được xem như một phương pháp tiện lợi.

Nếu bạn muốn lặp lại trong một phạm vi như vậy, bạn luôn có thể sử dụng downto:

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

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

Dưới đây là một số suy nghĩ khác của những người khác về lý do tại sao rất khó để vừa cho phép lặp lại vừa phải đối phó một cách nhất quán với phạm vi đảo ngược.

Làm thế nào về việc (0..1).reverse_eachlặp lại phạm vi ngược lại?

Lặp lại trên một phạm vi trong Ruby với eachcác lệnh gọi succphương thức trên đối tượng đầu tiên trong phạm vi.

$ 4.succ
=> 5

Và 5 nằm ngoài phạm vi.

Bạn có thể mô phỏng lặp lại ngược với hack này:

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

John chỉ ra rằng điều này sẽ không hoạt động nếu nó kéo dài đến 0. Điều này sẽ:

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

Không thể nói rằng tôi thực sự thích bất kỳ ai trong số họ bởi vì họ loại bỏ ý định.

Theo cuốn sách "Lập trình Ruby", đối tượng Range lưu trữ hai điểm cuối của phạm vi và sử dụng .succthành viên để tạo ra các giá trị trung gian. Tùy thuộc vào loại dữ liệu bạn đang sử dụng trong phạm vi của mình, bạn luôn có thể tạo một lớp con Integervà xác định lại .succthành viên để nó hoạt động giống như một trình lặp ngược (có thể bạn cũng muốn định nghĩa lại .next).

Bạn cũng có thể đạt được kết quả bạn đang tìm kiếm mà không cần sử dụng Phạm vi. Thử cái này:

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

Điều này sẽ chuyển từ 4 đến 0 trong các bước -1. Tuy nhiên, tôi không biết liệu điều này có hoạt động với bất kỳ điều gì ngoại trừ các đối số Số nguyên hay không.

Một cách khác là (1..10).to_a.reverse

Bạn thậm chí có thể sử dụng một forvòng lặp:

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

mà in:

4
3
2
1
0

nếu danh sách không phải là lớn. tôi nghĩ [*0..4].reverse.each { |i| puts i } là cách đơn giản nhất.

Như bta đã nói, lý do là nó Range#eachgửi succđến đầu của nó, sau đó đến kết quả của succcuộc gọi đó , và cứ như vậy cho đến khi kết quả lớn hơn giá trị cuối. Bạn không thể nhận được từ 4 đến 0 bằng cách gọi succ, và trên thực tế, bạn đã bắt đầu lớn hơn kết thúc.

Tôi thêm một khả năng khác làm thế nào để nhận ra sự lặp lại trên Phạm vi đảo ngược. Tôi không sử dụng nó, nhưng nó là một khả năng. Có một chút rủi ro khi khỉ vá các vật thể có lõi bằng ruby.

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

Điều này làm việc cho trường hợp sử dụng lười biếng của tôi

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

OP đã viết

Có vẻ như là lạ đối với tôi rằng cấu trúc trên không tạo ra kết quả như mong đợi. Lý do cho điều đó là gì? Những tình huống nào khi hành vi này là hợp lý?

không phải là 'Nó có thể được thực hiện?' nhưng để trả lời câu hỏi chưa được hỏi trước khi chuyển sang câu hỏi thực sự đã được hỏi:

$ 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

Vì reverse_each được cho là xây dựng toàn bộ một mảng, nên rõ ràng downto sẽ hiệu quả hơn. Thực tế là một nhà thiết kế ngôn ngữ thậm chí có thể xem xét việc triển khai những thứ như vậy tương tự như câu trả lời cho câu hỏi thực tế như được hỏi.

Để trả lời câu hỏi như thực sự đã hỏi ...

Lý do là vì Ruby là một ngôn ngữ vô cùng ngạc nhiên. Một số ngạc nhiên là thú vị, nhưng có rất nhiều hành vi bị phá vỡ hoàn toàn. Ngay cả khi một số ví dụ sau đây được sửa chữa bởi các bản phát hành mới hơn, thì vẫn có rất nhiều ví dụ khác và chúng vẫn như những cáo buộc về tư duy của thiết kế ban đầu:

nil.to_s
   .to_s
   .inspect

kết quả là "" nhưng

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

kết quả trong

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

Bạn có thể mong đợi << và push giống nhau để thêm vào các mảng, nhưng

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

Bạn có thể mong đợi 'grep' hoạt động giống như dòng lệnh Unix tương đương của nó, nhưng nó === không khớp với = ~, mặc dù tên của nó.

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

Các phương pháp khác nhau là bí danh của nhau một cách bất ngờ, vì vậy bạn phải học nhiều tên cho cùng một thứ - ví dụ findvà detect- ngay cả khi bạn giống như hầu hết các nhà phát triển và chỉ sử dụng cái này hay cái kia. Nhiều cùng đi cho size, countvà length, ngoại trừ cho các lớp học mà xác định mỗi khác nhau, hoặc không xác định một hoặc hai ở tất cả.

Trừ khi ai đó đã triển khai một cái gì đó khác - như phương pháp cốt lõi tapđã được xác định lại trong các thư viện tự động hóa khác nhau để nhấn một cái gì đó trên màn hình. Chúc may mắn khi tìm ra điều gì đang xảy ra, đặc biệt nếu một số mô-đun được yêu cầu bởi một số mô-đun khác đã đóng một mô-đun khác để làm điều gì đó không có tài liệu.

Đối tượng biến môi trường, ENV không hỗ trợ 'hợp nhất', vì vậy bạn phải viết

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

Như một phần thưởng, bạn thậm chí có thể xác định lại các hằng số của mình hoặc của người khác nếu bạn thay đổi ý định về những gì chúng nên là.

Đối với tôi, cách đơn giản nhất là:

[*0..9].reverse

Một cách khác để lặp lại để liệt kê:

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