Czy w Rubim jest metoda Array, która łączy „select” i „map”?

Mam tablicę Ruby zawierającą wartości ciągów. Potrzebuję:

1. Znajdź wszystkie elementy, które pasują do jakiegoś predykatu
2. Przeprowadź transformację dopasowanych elementów
3. Zwróć wyniki jako tablicę

W tej chwili moje rozwiązanie wygląda następująco:

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

Czy istnieje metoda Array lub Enumerable, która łączy wybieranie i mapowanie w jedną instrukcję logiczną?

Zwykle używam mapi compactrazem z moimi kryteriami wyboru jako postfiksem if. compactpozbywa się zer.

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] 

Możesz użyć reducedo tego, co wymaga tylko jednego przejścia:

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

Innymi słowy, zainicjuj stan tak, jak chcesz (w naszym przypadku pusta lista do wypełnienia:) [], a następnie zawsze upewnij się, że zwracasz tę wartość z modyfikacjami dla każdego elementu z oryginalnej listy (w naszym przypadku zmodyfikowany element przeniesiony na listę).

Jest to najbardziej wydajne, ponieważ powoduje pętle po liście tylko jednym przebiegiem ( map+ selectlub compactwymaga dwóch przebiegów).

W Twoim przypadku:

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

Ruby 2.7+

Jest teraz!

W filter_maptym właśnie celu wprowadza się Ruby 2.7 . Jest idiomatyczny i performatywny i spodziewałbym się, że wkrótce stanie się normą.

Na przykład:

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

Oto dobra lektura na ten temat .

Mam nadzieję, że to komuś się przyda!

Innym innym sposobem podejścia jest użycie nowego (w stosunku do tego pytania) Enumerator::Lazy:

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

.lazyMetoda zwraca leniwe wyliczający. Wywołanie .selectlub .mapna leniwym module wyliczającym zwraca inny leniwy moduł wyliczający. Dopiero po wywołaniu .uniqfaktycznie wymusza to moduł wyliczający i zwraca tablicę. Skutecznie się dzieje, .selecta .mappołączenia są łączone w jedno - powtarzasz tylko @linesraz, aby wykonać oba .selecti .map.

Wydaje mi się, że reducemetoda Adama będzie trochę szybsza, ale myślę, że jest to znacznie bardziej czytelne.

Główną konsekwencją tego jest to, że dla każdego kolejnego wywołania metody nie są tworzone żadne pośrednie obiekty tablicy. W normalnej @lines.select.mapsytuacji selectzwraca tablicę, która jest następnie modyfikowana przez map, ponownie zwracając tablicę. Dla porównania, leniwa ocena tworzy tablicę tylko raz. Jest to przydatne, gdy początkowy obiekt kolekcji jest duży. Umożliwia także pracę z nieskończonymi modułami wyliczającymi - np random_number_generator.lazy.select(&:odd?).take(10).

Jeśli masz, selectże możesz użyć caseoperatora ( ===), grepjest to dobra alternatywa:

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

Jeśli potrzebujemy bardziej złożonej logiki, możemy stworzyć lambdy:

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

Nie jestem pewien, czy istnieje. Moduł Enumerable , która dodaje selecti mapnie wykazuje jeden.

Będziesz musiał przekazać select_and_transformmetodę w dwóch blokach , co byłoby nieco nieintuicyjne w IMHO.

Oczywiście możesz po prostu połączyć je ze sobą, co jest bardziej czytelne:

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

Prosta odpowiedź:

Jeśli masz n rekordów i chcesz, selecti mapna podstawie warunku, to

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

Tutaj atrybut jest tym, co chcesz z rekordu i warunkiem, który możesz sprawdzić.

compact to spłukanie niepotrzebnych zera, które wyszły z tego warunku if

Nie, ale możesz to zrobić w ten sposób:

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

Albo jeszcze lepiej:

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

Myślę, że ten sposób jest bardziej czytelny, ponieważ dzieli warunki filtru i zmapowaną wartość, pozostając jednocześnie jasnym, że akcje są połączone:

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

W swoim konkretnym przypadku usuń resultzmienną wszystkie razem:

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

W Rubim 1.9 i 1.8.7 możesz także łączyć i zawijać iteratory, po prostu nie przekazując im bloku:

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

Ale w tym przypadku nie jest to naprawdę możliwe, ponieważ typy bloków zwracają wartości selecti mapnie pasują do siebie. Ma to większy sens w przypadku czegoś takiego:

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

AFAICS, najlepsze, co możesz zrobić, to pierwszy przykład.

Oto mały przykład:

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

Ale to, czego naprawdę chcesz, to ["A", "B", "C", "D"].

Powinieneś spróbować użyć mojej biblioteki Rearmed Ruby, w której dodałem metodę Enumerable#select_map. Oto przykład:

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

Jeśli nie chcesz tworzyć dwóch różnych tablic, możesz ich użyć, compact!ale zachowaj ostrożność.

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

Co ciekawe, compact!usuwa zero na miejscu. Wartość zwracana compact!jest tą samą tablicą, jeśli wystąpiły zmiany, ale nil, jeśli nie było żadnych wartości zerowych.

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

Byłby to jeden liniowiec.

Twoja wersja:

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

Moja wersja:

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

Spowoduje to wykonanie 1 iteracji (z wyjątkiem sortowania) i ma dodatkową zaletę w postaci zachowania unikalności (jeśli nie obchodzi cię unikalność, po prostu utwórz z wyników tablicę i results.push(line) if ...

Oto przykład. To nie to samo, co twój problem, ale może być tym, czego chcesz lub może dać wskazówkę do rozwiązania:

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