¿Hay alguna razón por la que no podamos iterar en "Rango inverso" en ruby?

Question

me trataron de una iteración hacia atrás con el uso de un rango y each:

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

iteración a través 0..4 escribe los números. Por otro lado, el rango r = 4..0 parece estar bien, r.first == 4, r.last == 0.

Parece extraño para mí que la construcción anterior no produzca el resultado esperado. ¿Cuál es el motivo para eso? ¿Cuáles son las situaciones cuando este comportamiento es razonable?

Answer 1

Una gama es precisamente eso: algo definido por su inicio y su final, no por su contenido. "Iterar" en un rango en realidad no tiene sentido en un caso general. Considere, por ejemplo, cómo "iteraría" sobre el rango producido por dos fechas. ¿Podrías iterar por día? ¿Por mes? ¿por año? ¿por semana? No está bien definido. OMI, el hecho de que está permitido para los rangos de avance debe verse como un método de conveniencia solamente.

Si desea recorrer hacia atrás sobre un rango de esa manera, siempre se puede utilizar downto:

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

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

Éstos son some more thoughts de los demás acerca de por qué es difícil tanto permitir la iteración y trate a fondo inversas rangos.

Answer 2

Iterar un rango en Ruby con each llama al método succ en el primer objeto del rango.

$ 4.succ 
=> 5 

Y 5 está fuera del intervalo.

Puede simular iteración inversa con este truco:

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

John señaló que esto no funcionará si se extiende por 0. Esto haría:

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

¿No decir que me gusta cualquiera de ellos porque oscurecen la intención.

Answer 3

si la lista no es tan grande. creo que [*0..4].reverse.each { |i| puts i } es la forma más sencilla.

Answer 4

Agrego otra posibilidad de cómo realizar la iteración sobre el rango inverso. No lo uso, pero es una posibilidad. Es un poco arriesgado para los objetos de núcleo de rubí mono parche.

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 

Answer 5

Según el libro "Programación Ruby", el objeto Range almacena los dos puntos extremos de la gama y utiliza el miembro de .succ para generar los valores intermedios. Dependiendo del tipo de tipo de datos que esté utilizando en su rango, siempre puede crear una subclase de Integer y redefinir el miembro .succ para que actúe como un iterador inverso (también es probable que desee redefinir .next también)

También puede obtener los resultados que busca sin utilizar un Rango.Pruebe esto:

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

Esto pasará de 4 a 0 en pasos de -1. Sin embargo, no sé si esto funcionará para nada, excepto los argumentos enteros.

Answer 6

Como dijo BTA, la razón es que Range#each envía succ a su comienzo, a continuación, con el resultado de que succ llamada, y así sucesivamente hasta que el resultado es mayor que el valor final. No puede obtener de 4 a 0 llamando al succ, y de hecho ya comienza más que al final.

Answer 7

incluso se puede utilizar un bucle for:

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

que imprime:

4 
3 
2 
1 
0 

Answer 8

¿Qué tal (0..1).reverse_each la que itera el rango hacia atrás?

Answer 9

Otra forma es (1..10).to_a.reverse

Answer 10

Esto funcionó para mi caso de uso perezoso

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

Answer 11

La OP escribió

Parece ser extraño para mí que la construcción anterior no produce el resultado esperado. ¿Cuál es el motivo para eso? ¿Cuáles son las situaciones cuando este comportamiento es razonable?

no '¿Se puede hacer?' pero para responder a la pregunta que no se pidió antes de llegar a la pregunta que en realidad se le preguntó:

$ 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 

Desde reverse_each se demanda para construir toda una matriz, downto está claro que va a ser más eficiente. El hecho de que un diseñador de lenguaje incluso podría considerar la implementación de cosas así se relaciona con la respuesta a la pregunta real tal como se le preguntó.

Para responder a la pregunta en realidad se le preguntó ...

La razón se debe a que Ruby es un lenguaje infinitamente sorprendente. Algunas sorpresas son agradables, pero hay un montón de comportamientos que se rompen por completo. Incluso si algunos de estos ejemplos siguientes se corrigen por versiones más recientes, hay un montón de otros, y que permanecen como acusaciones en el modo de pensar del diseño original:

nil.to_s 
    .to_s 
    .inspect 

resultados en "" pero

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

resultados en

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

es probable que esperar < < y empuje a ser el mismo para anexar a las matrices, pero

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

Es probable que esperar 'grep' a comportarse como su equivalente de línea de comandos de Unix, pero sí === juego no = ~, a pesar de su nombre.

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

Varios métodos son inesperadamente alias de uno al otro, por lo que tiene que aprender varios nombres para la misma cosa - por ejemplo, find y detect - incluso si le gusta la mayoría de los desarrolladores y solo utiliza uno u otro. Lo mismo ocurre con size, count y length, excepto las clases que definen cada una de manera diferente, o no definen una o dos en absoluto.

A menos que alguien haya implementado otra cosa, como el método central tap se ha redefinido en varias bibliotecas de automatización para presionar algo en la pantalla. Buena suerte para descubrir qué está pasando, especialmente si algún módulo requerido por algún otro módulo ha monkeado otro módulo para hacer algo no documentado.

El objeto variable de entorno, ENV no apoyar 'fusión', por lo que tiene que escribir

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

Como beneficio adicional, incluso se puede redefinir sus o de alguien más constantes si cambia de opinión acerca de lo que debiera ser.