En Ruby, ¿existe un método Array que combine 'seleccionar' y 'mapa'?

Tengo una matriz de Ruby que contiene algunos valores de cadena. Necesito:

1. Encuentra todos los elementos que coinciden con algún predicado
2. Ejecute los elementos coincidentes a través de una transformación
3. Devuelve los resultados como una matriz

En este momento, mi solución se ve así:

def example
  matchingLines = @lines.select{ |line| ... }
  results = matchingLines.map{ |line| ... }
  return results.uniq.sort
end

¿Existe un método Array o Enumerable que combine select y map en una sola declaración lógica?

Normalmente utilizo mapy compactjunto con mis criterios de selección como sufijo if. compactse deshace de los nulos.

jruby-1.5.0 > [1,1,1,2,3,4].map{|n| n*3 if n==1}    
 => [3, 3, 3, nil, nil, nil] 


jruby-1.5.0 > [1,1,1,2,3,4].map{|n| n*3 if n==1}.compact
 => [3, 3, 3] 

Puede usar reducepara esto, que requiere solo un pase:

[1,1,1,2,3,4].reduce([]) { |a, n| a.push(n*3) if n==1; a }
=> [3, 3, 3] 

En otras palabras, inicialice el estado para que sea el que desee (en nuestro caso, una lista vacía para llenar :) [], luego asegúrese siempre de devolver este valor con modificaciones para cada elemento en la lista original (en nuestro caso, el elemento modificado empujado a la lista).

Este es el más eficiente ya que solo recorre la lista con un pase ( map+ selecto compactrequiere dos pases).

En tu caso:

def example
  results = @lines.reduce([]) do |lines, line|
    lines.push( ...(line) ) if ...
    lines
  end
  return results.uniq.sort
end

Ruby 2.7+

¡Hay ahora!

Ruby 2.7 se presenta filter_mapcon este propósito exacto. Es idiomático y performativo, y espero que se convierta en la norma muy pronto.

Por ejemplo:

numbers = [1, 2, 5, 8, 10, 13]
enum.filter_map { |i| i * 2 if i.even? }
# => [4, 16, 20]

He aquí una buena lectura sobre el tema .

¡Espero que sea útil para alguien!

Otra forma diferente de abordar esto es usando el nuevo (en relación con esta pregunta) Enumerator::Lazy:

def example
  @lines.lazy
        .select { |line| line.property == requirement }
        .map    { |line| transforming_method(line) }
        .uniq
        .sort
end

El .lazymétodo devuelve un enumerador perezoso. Llamar .selecto .mapen un enumerador perezoso devuelve otro enumerador perezoso. Solo una vez que llama .uniq, realmente fuerza al enumerador y devuelve una matriz. Entonces, lo que sucede efectivamente es que sus llamadas .selecty .mapse combinan en una: solo se repite una @linesvez para hacer ambas .selecty.map .

Mi instinto es que el reducemétodo de Adam será un poco más rápido, pero creo que es mucho más legible.

La consecuencia principal de esto es que no se crean objetos de matriz intermedios para cada llamada de método subsiguiente. En una @lines.select.mapsituación normal , selectdevuelve una matriz que luego es modificada por map, devolviendo nuevamente una matriz. En comparación, la evaluación diferida solo crea una matriz una vez. Esto es útil cuando su objeto de colección inicial es grande. También le permite trabajar con enumeradores infinitos, por ejemplo random_number_generator.lazy.select(&:odd?).take(10).

Si tiene un selectque puede usar el caseoperador ( ===), grepes una buena alternativa:

p [1,2,'not_a_number',3].grep(Integer){|x| -x } #=> [-1, -2, -3]

p ['1','2','not_a_number','3'].grep(/\D/, &:upcase) #=> ["NOT_A_NUMBER"]

Si necesitamos una lógica más compleja podemos crear lambdas:

my_favourite_numbers = [1,4,6]

is_a_favourite_number = -> x { my_favourite_numbers.include? x }

make_awesome = -> x { "***#{x}***" }

my_data = [1,2,3,4]

p my_data.grep(is_a_favourite_number, &make_awesome) #=> ["***1***", "***4***"]

No estoy seguro de que haya uno. El módulo Enumerable , que agrega selectymap , no muestra uno.

Se le pedirá que pase en dos cuadras hasta el select_and_transform método, lo que sería un poco intuitivo en mi humilde opinión.

Obviamente, podría simplemente encadenarlos, lo que es más legible:

transformed_list = lines.select{|line| ...}.map{|line| ... }

Respuesta simple:

Si tiene n registros y lo desea selecty en mapfunción de la condición,

records.map { |record| record.attribute if condition }.compact

Aquí, el atributo es lo que desee del registro y la condición que puede marcar.

compacto es eliminar los cero innecesarios que surgieron de esa condición si

No, pero puedes hacerlo así:

lines.map { |line| do_some_action if check_some_property  }.reject(&:nil?)

O mejor:

lines.inject([]) { |all, line| all << line if check_some_property; all }

Creo que de esta manera es más legible, porque divide las condiciones del filtro y el valor mapeado mientras queda claro que las acciones están conectadas:

results = @lines.select { |line|
  line.should_include?
}.map do |line|
  line.value_to_map
end

Y, en su caso específico, elimine la resultvariable por completo:

def example
  @lines.select { |line|
    line.should_include?
  }.map { |line|
    line.value_to_map
  }.uniq.sort
end

def example
  @lines.select {|line| ... }.map {|line| ... }.uniq.sort
end

En Ruby 1.9 y 1.8.7, también puede encadenar y envolver iteradores simplemente sin pasarles un bloque:

enum.select.map {|bla| ... }

Pero no es realmente posible en este caso, ya que los tipos de bloque devuelven valores de selecty mapno coinciden. Tiene más sentido para algo como esto:

enum.inject.with_index {|(acc, el), idx| ... }

AFAICS, lo mejor que puede hacer es el primer ejemplo.

He aquí un pequeño ejemplo:

%w[a b 1 2 c d].map.select {|e| if /[0-9]/ =~ e then false else e.upcase end }
# => ["a", "b", "c", "d"]

%w[a b 1 2 c d].select.map {|e| if /[0-9]/ =~ e then false else e.upcase end }
# => ["A", "B", false, false, "C", "D"]

Pero lo que realmente quieres es ["A", "B", "C", "D"].

Debería intentar usar mi biblioteca Rearmed Ruby en la que agregué el método Enumerable#select_map. He aquí un ejemplo:

items = [{version: "1.1"}, {version: nil}, {version: false}]

items.select_map{|x| x[:version]} #=> [{version: "1.1"}]
# or without enumerable monkey patch
Rearmed.select_map(items){|x| x[:version]}

Si no desea crear dos matrices diferentes, puede usarlo, compact!pero tenga cuidado.

array = [1,1,1,2,3,4]
new_array = map{|n| n*3 if n==1}
new_array.compact!

Curiosamente, compact!hace una eliminación in situ de nil. El valor de retorno de compact!es la misma matriz si hubo cambios, pero nulo si no hubo nulos.

array = [1,1,1,2,3,4]
new_array = map{|n| n*3 if n==1}.tap { |array| array.compact! }

Sería un trazador de líneas.

Tu versión:

def example
  matchingLines = @lines.select{ |line| ... }
  results = matchingLines.map{ |line| ... }
  return results.uniq.sort
end

Mi version:

def example
  results = {}
  @lines.each{ |line| results[line] = true if ... }
  return results.keys.sort
end

Esto hará 1 iteración (excepto la ordenación) y tiene la ventaja adicional de mantener la singularidad (si no le importa uniq, simplemente haga que los resultados sean una matriz y results.push(line) if ...

He aquí un ejemplo. No es lo mismo que su problema, pero puede ser lo que desee o puede dar una pista de su solución:

def example
  lines.each do |x|
    new_value = do_transform(x)
    if new_value == some_thing
      return new_value    # here jump out example method directly.
    else
      next                # continue next iterate.
    end
  end
end