In Ruby, esiste un metodo Array che combina "select" e "map"?

Ho un array Ruby contenente alcuni valori di stringa. Ho bisogno di:

1. Trova tutti gli elementi che corrispondono a un predicato
2. Esegui gli elementi corrispondenti attraverso una trasformazione
3. Restituisce i risultati come un array

In questo momento la mia soluzione è simile a questa:

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

Esiste un metodo Array o Enumerable che combina selezione e mappatura in un'unica istruzione logica?

Di solito uso mape compactinsieme ai miei criteri di selezione come suffisso if. compactsi sbarazza dei nils.

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] 

Puoi usare reduceper questo, che richiede un solo passaggio:

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

In altre parole, inizializza lo stato in modo che sia quello che desideri (nel nostro caso, un elenco vuoto da riempire :) [], quindi assicurati sempre di restituire questo valore con modifiche per ogni elemento nell'elenco originale (nel nostro caso, l'elemento modificato inserito nell'elenco).

Questo è il più efficiente poiché scorre l'elenco con un solo passaggio ( map+ selecto compactrichiede due passaggi).

Nel tuo caso:

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

Ruby 2.7+

Adesso c'è!

Ruby 2.7 sta introducendo proprio filter_mapper questo scopo. È idiomatico e performante, e mi aspetto che diventi la norma molto presto.

Per esempio:

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

Ecco una buona lettura sull'argomento .

Spero sia utile a qualcuno!

Un altro modo diverso di affrontare questo problema è usare il nuovo (relativo a questa domanda) Enumerator::Lazy:

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

Il .lazymetodo restituisce un enumeratore pigro. La chiamata .selecto .mapsu un enumeratore pigro restituisce un altro enumeratore pigro. Solo una volta chiamato .uniq, forza effettivamente l'enumeratore e restituisce un array. Quindi ciò che effettivamente accade è che le tue chiamate .selecte .mapsono combinate in una sola: ripeti solo @linesuna volta per fare entrambe le cose .selecte .map.

Il mio istinto è che il reducemetodo di Adam sarà un po 'più veloce, ma penso che questo sia molto più leggibile.

La conseguenza principale di ciò è che non viene creato alcun oggetto array intermedio per ogni successiva chiamata al metodo. In una @lines.select.mapsituazione normale , selectrestituisce un array che viene quindi modificato da map, restituendo nuovamente un array. In confronto, la valutazione pigra crea una matrice solo una volta. Ciò è utile quando il tuo oggetto di raccolta iniziale è grande. Ti consente anche di lavorare con infiniti enumeratori, ad es random_number_generator.lazy.select(&:odd?).take(10).

Se hai un selectche può usare l' caseoperatore ( ===), grepè una buona 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"]

Se abbiamo bisogno di una logica più complessa, possiamo creare lambda:

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***"]

Non sono sicuro che ce ne sia uno. Il modulo Enumerable , che aggiunge selecte map, non ne mostra uno.

Ti verrà richiesto di passare in due blocchi al select_and_transformmetodo, il che sarebbe un po 'poco intuitivo IMHO.

Ovviamente, potresti semplicemente concatenarli insieme, il che è più leggibile:

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

Risposta semplice:

Se hai n record e lo desideri selecte in mapbase alla condizione, allora

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

Qui, l'attributo è quello che vuoi dal record e la condizione puoi mettere qualsiasi segno di spunta.

compact è quello di lavare gli inutili nil che sono usciti da quella condizione if

No, ma puoi farlo in questo modo:

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

O ancora meglio:

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

Penso che in questo modo sia più leggibile, perché divide le condizioni del filtro e il valore mappato pur rimanendo chiaro che le azioni sono collegate:

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

E, nel tuo caso specifico, elimina resulttutte le variabili:

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

In Ruby 1.9 e 1.8.7, puoi anche concatenare e avvolgere gli iteratori semplicemente non passandogli un blocco:

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

Ma in questo caso non è davvero possibile, poiché i tipi di blocco restituiscono i valori di selecte mapnon corrispondono. Ha più senso per qualcosa del genere:

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

AFAICS, il meglio che puoi fare è il primo esempio.

Ecco un piccolo esempio:

%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"]

Ma quello che vuoi veramente è ["A", "B", "C", "D"].

Dovresti provare a usare la mia libreria Rearmed Ruby in cui ho aggiunto il metodo Enumerable#select_map. Ecco un esempio:

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]}

Se non vuoi creare due array diversi, puoi usarli compact!ma fai attenzione.

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

È interessante notare che compact!esegue una rimozione sul posto di zero. Il valore restituito di compact!è lo stesso array se ci sono stati cambiamenti ma nil se non ci sono stati nil.

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

Sarebbe un one liner.

La tua versione:

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

La mia versione:

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

Questo farà 1 iterazione (eccetto l'ordinamento) e ha il vantaggio aggiuntivo di mantenere l'unicità (se non ti interessa uniq, allora fai semplicemente un array e results.push(line) if ...

Ecco un esempio. Non è lo stesso del tuo problema, ma potrebbe essere quello che vuoi, o può dare un indizio per la tua soluzione:

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