sintaxis - iteration ruby

Diferencias de bucle en Ruby usando Range vs. Times

Question

Estoy tratando de resolver un problema del Proyecto Euler usando Ruby, usé 4 métodos diferentes de bucle, el bucle for, tiempos, rango y hasta el método, sin embargo el método times solo produce la respuesta esperada, mientras que el bucle for, el rango y hasta el método no lo hace. Supongo que son algo iguales, pero descubrí que no lo es. ¿Puede alguien explicar las diferencias entre estos métodos?

Aquí está la estructura de bucle que utilicé

# for-loop method
for n in 0..1
  puts n
end

0
1
=> 0..1

# times method
2.times do |n|
  puts n
end

0
1
=> 2

# range method
(0..1).each do |n|
  puts n
end

0
1
=> 0..1

# upto method
0.upto(1) do |n|
  puts n
end

0
1
=> 0

Answer 1

Esta información se puede obtener fácilmente mediante la inspección de la documentación.

Array#each tiene una firma de array.each {|item| block } → array array.each {|item| block } → array , así que podemos ver que el valor de retorno de foo.each { ... } es foo .

Del mismo modo, Int#upto tiene una firma de int.upto(limit) {|i| block } => int int.upto(limit) {|i| block } => int , de modo que x.upto(y) { ... } siempre devolverá x .

Luego también podemos ver que 2.times { ... } devolverá 2 debido a la firma de Integer#times .

Tengo problemas para encontrar la documentación correcta, pero for x in y... se traduce a y.each do |x| ... y.each do |x| ... , por eso su bucle for-in devuelve lo mismo que su bucle .each .

De todos modos, dependiendo de los valores de retorno de estas construcciones en bucle es ... un enfoque extraño. No creo que esto suceda mucho (¿en absoluto?) En el código de Ruby idiomático.

Answer 2

Si te entendí correctamente, estás preguntando por qué n.times es el único método que itera hasta no incluir n . En ese caso:

Para los rangos es simple: x..y define un rango de x a y inclusive y x...y define un rango de x a y exclusivo. Entonces, si quieres el mismo comportamiento que los tiempos, usa 0...n .

Para x.upto(y) solo hay una versión que iterará hasta e incluyendo y . Esto es simplemente cómo hasta que se define y documenta para trabajar.

También está bastante claro por qué n.times no incluye n: si iterara de 0 a n (inclusive), produciría n+1 veces. Pero como el método se llama n.times , claramente solo debería rendir n veces.