Omita la iteración en Enumerable # collect

(1..4).collect do |x| next if x == 3 x + 1 end # => [2, 3, nil, 5] # desired => [2, 3, 5] 

Si se cumple la condición para el next , la collect coloca nil en la matriz, mientras que lo que estoy tratando de hacer es no colocar ningún elemento en la matriz devuelta si se cumple la condición. ¿Es esto posible sin llamar a delete_if { |x| x == nil } delete_if { |x| x == nil } en la matriz devuelta?

(Usando Ruby 1.8.7; mi extracto de código está muy resumido)

Hay un método Enumerable#reject que sirve solo para el propósito:

 (1..4).reject{|x| x == 3}.collect{|x| x + 1} 

La práctica de usar directamente una salida de un método como una entrada de otro se llama encadenamiento de métodos y es muy común en Ruby.

Por cierto, el map (o collect ) se utiliza para la asignación directa de la entrada enumerable a la de salida. Si necesita generar un número diferente de elementos, es probable que necesite otro método de Enumerable .

Edición: Si le molesta el hecho de que algunos de los elementos se iteran dos veces, puede usar una solución menos elegante basada en inject (o su método similar denominado each_with_object ):

 (1..4).each_with_object([]){|x,a| a << x + 1 unless x == 3} 

Simplemente llamaría a .compact en la matriz resultante, lo que elimina cualquier instancia de nil en una matriz. Si desea modificar la matriz existente (no hay razón para no hacerlo), use .compact! :

 (1..4).collect do |x| next if x == 3 x end.compact! 

Solo una sugerencia, ¿por qué no lo haces de esta manera?

 result = [] (1..4).each do |x| next if x == 3 result << x end result # => [1, 2, 4] 

de esa manera, guardó otra iteración para eliminar elementos nulos de la matriz. Espero que ayude =)

sugeriría utilizar:

 (1..4).to_a.delete_if {|x| x == 3} 

en lugar de la colecta + siguiente statement.

Podría colocar la toma de decisiones en un método auxiliar, y usarlo a través de Enumerable#reduce :

 def potentially_keep(list, i) if i === 3 list else list.push i end end # => :potentially_keep (1..4).reduce([]) { |memo, i| potentially_keep(memo, i) } # => [1, 2, 4]