Gibt es in Ruby eine Array-Methode, die 'select' und 'map' kombiniert?

Ich habe ein Ruby-Array mit einigen Zeichenfolgenwerten. Ich muss einfach:

1. Finden Sie alle Elemente, die einem Prädikat entsprechen
2. Führen Sie die übereinstimmenden Elemente durch eine Transformation
3. Geben Sie die Ergebnisse als Array zurück

Im Moment sieht meine Lösung so aus:

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

Gibt es eine Array- oder Enumerable-Methode, die select und map zu einer einzigen logischen Anweisung kombiniert?

Normalerweise verwende ich mapund compactzusammen mit meinen Auswahlkriterien als Postfix if. compactwird die Nullen los.

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] 

Sie können reducedies verwenden, was nur einen Durchgang erfordert:

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

Mit anderen Worten, initialisieren Sie den Status so, wie Sie es möchten (in unserem Fall eine leere Liste, die gefüllt werden muss :) [], und stellen Sie dann immer sicher, dass Sie diesen Wert mit Änderungen für jedes Element in der ursprünglichen Liste (in unserem Fall das geänderte Element) zurückgeben auf die Liste geschoben).

Dies ist am effizientesten, da die Liste nur mit einem Durchgang durchlaufen wird ( map+ selectoder compactzwei Durchgänge erforderlich sind).

In deinem Fall:

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

Ruby 2.7+

Da ist jetzt!

Ruby 2.7 wird filter_mapgenau für diesen Zweck eingeführt. Es ist idiomatisch und performant, und ich würde erwarten, dass es sehr bald zur Norm wird.

Beispielsweise:

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

Hier ist eine gute Lektüre zu diesem Thema .

Hoffe das ist nützlich für jemanden!

Eine andere Art, dies zu erreichen, ist die Verwendung des Neuen (relativ zu dieser Frage) Enumerator::Lazy:

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

Die .lazyMethode gibt einen Lazy Enumerator zurück. Wenn Sie einen Lazy Enumerator aufrufen .selectoder .mapaktivieren, wird ein anderer Lazy Enumerator zurückgegeben. Erst wenn Sie aufrufen, .uniqwird der Enumerator erzwungen und ein Array zurückgegeben. Was also effektiv passiert, ist, dass Ihre .selectund .mapAnrufe zu einem zusammengefasst werden - Sie iterieren nur @lineseinmal, um beides .selectund zu tun .map.

Mein Instinkt ist, dass Adams reduceMethode etwas schneller sein wird, aber ich denke, dass dies weitaus besser lesbar ist.

Die Hauptfolge davon ist, dass für jeden nachfolgenden Methodenaufruf keine Zwischenarrayobjekte erstellt werden. Gibt in einer normalen @lines.select.mapSituation selectein Array zurück, das dann von geändert wird map, und gibt erneut ein Array zurück. Im Vergleich dazu erstellt die verzögerte Auswertung ein Array nur einmal. Dies ist nützlich, wenn Ihr anfängliches Sammlungsobjekt groß ist. Es ermöglicht Ihnen auch, mit unendlichen Enumeratoren zu arbeiten - z random_number_generator.lazy.select(&:odd?).take(10).

Wenn Sie eine haben select, die den caseOperator ( ===) verwenden kann, grepist dies eine gute Alternative:

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

Wenn wir eine komplexere Logik benötigen, können wir Lambdas erstellen:

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

Ich bin mir nicht sicher, ob es einen gibt. Das Enumerable-Modul , das selectund hinzufügt map, zeigt keines an.

Sie müssten in zwei Blöcken an die select_and_transformMethode übergeben, was meiner Meinung nach etwas unintuitiv wäre.

Natürlich können Sie sie einfach miteinander verketten, was besser lesbar ist:

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

Einfache Antwort:

Wenn Sie n Datensätze haben und möchten selectund mapbasierend auf der Bedingung dann

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

Hier ist das Attribut das, was Sie von dem Datensatz und der Bedingung erwarten, die Sie überprüfen können.

Kompakt ist es, die unnötigen Nullen zu spülen, die aus diesem Zustand hervorgegangen sind

Nein, aber Sie können es so machen:

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

Oder noch besser:

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

Ich denke, dass dieser Weg besser lesbar ist, da die Filterbedingungen und der zugeordnete Wert aufgeteilt werden, während klar bleibt, dass die Aktionen miteinander verbunden sind:

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

Und eliminieren Sie in Ihrem speziellen Fall die resultVariable insgesamt:

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 und 1.8.7 können Sie Iteratoren auch verketten und umschließen, indem Sie ihnen einfach keinen Block übergeben:

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

In diesem Fall ist dies jedoch nicht wirklich möglich, da die Typen der Blockrückgabewerte von selectund mapnicht übereinstimmen. Für so etwas macht es mehr Sinn:

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

AFAICS, das Beste, was Sie tun können, ist das erste Beispiel.

Hier ist ein kleines Beispiel:

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

Aber was Sie wirklich wollen, ist ["A", "B", "C", "D"].

Sie sollten versuchen, meine Bibliothek Rearmed Ruby zu verwenden, in der ich die Methode hinzugefügt habe Enumerable#select_map. Hier ein Beispiel:

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

Wenn Sie nicht zwei verschiedene Arrays erstellen möchten, können Sie diese verwenden, compact!aber seien Sie vorsichtig.

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

Interessanterweise compact!wird an Ort und Stelle Null entfernt. Der Rückgabewert von compact!ist das gleiche Array, wenn Änderungen vorgenommen wurden, aber Null, wenn keine Nullen vorhanden waren.

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

Wäre ein Einzeiler.

Deine Version:

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

Meine Version:

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

Dies führt 1 Iteration durch (mit Ausnahme der Sortierung) und hat den zusätzlichen Vorteil, dass die Eindeutigkeit erhalten bleibt (wenn Sie sich nicht für Uniq interessieren, machen Sie die Ergebnisse einfach zu einem Array und results.push(line) if ...

Hier ist ein Beispiel. Es ist nicht dasselbe wie Ihr Problem, kann aber das sein, was Sie wollen, oder kann einen Hinweis auf Ihre Lösung geben:

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