Чи існує в Ruby метод Array, який поєднує 'select' та 'map'?

У мене є масив Ruby, що містить деякі рядкові значення. Мені потрібно:

1. Знайдіть усі елементи, які відповідають якомусь присудку
2. Запустіть відповідні елементи за допомогою перетворення
3. Повернути результати як масив

Зараз моє рішення виглядає так:

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

Чи існує метод Array або Enumerable, який поєднує в собі вибір та відображення в єдине логічне твердження?

Я зазвичай використовую mapі compactразом разом з моїми критеріями відбору в якості постфікса if. compactпозбавляється від нулів.

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] 

Ви можете використовувати reduceдля цього, що вимагає лише одного проходу:

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

Іншими словами, ініціалізуйте стан таким, яким ви хочете (у нашому випадку порожній список для заповнення:) [], а потім завжди переконайтеся, що повертаєте це значення із змінами для кожного елемента у вихідному списку (у нашому випадку модифікований елемент перенесено до списку).

Це найефективніше, оскільки він перебирає список лише одним проходом ( map+ selectабо compactвимагає двох проходів).

У вашому випадку:

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

Рубін 2.7+

Є зараз!

Ruby 2.7 представляє саме filter_mapз цією метою. Це ідіоматично та ефективно, і я сподівався б, що це стане нормою дуже скоро.

Наприклад:

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

Ось гарне читання на цю тему .

Сподіваюся, це комусь корисно!

Інший інший спосіб підходу до цього - використання нового (щодо цього питання) Enumerator::Lazy:

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

.lazyМетод повертає ледачий Нумератор. Виклик .selectабо .mapна лінивому перелічувачі повертає іншого ледачого перелічувача. Лише після того, як ви зателефонуєте .uniq, він фактично змушує перечислювач і повертає масив. Отже, фактично відбувається ваше .selectта .mapдзвінки об’єднуються в одне - ви повторюєте лише @linesодин раз, щоб зробити обидва .selectі .map.

Мій інстинкт полягає в тому, що reduceметод Адама буде трохи швидшим, але я думаю, що це набагато читабельніше.

Основним наслідком цього є те, що для кожного наступного виклику методу не створюються проміжні об'єкти масиву. У звичайній @lines.select.mapситуації selectповертає масив, який потім модифікується map, знову повертаючи масив. Для порівняння, лінива оцінка створює масив лише один раз. Це корисно, коли початковий об'єкт колекції великий. Це також дозволяє вам працювати з нескінченними перечислювачами - наприклад random_number_generator.lazy.select(&:odd?).take(10).

Якщо у вас є, selectякий може використовувати caseоператор ( ===), grepце гарна альтернатива:

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

Якщо нам потрібна більш складна логіка, ми можемо створити лямбди:

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

Я не впевнений, що такий є. Модуль Enumerable , який додає selectта mapне показує його.

Вам потрібно буде перейти у два блоки до select_and_transformметоду, який був би трохи неінтуїтивним IMHO.

Очевидно, ви можете просто зв'язати їх ланцюгами, що є більш читабельним:

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

Проста відповідь:

Якщо у вас є п записів, і ви хочете , selectі на mapоснові стану , то

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

Тут атрибут - це все, що ви хочете від запису, і умова, яку ви можете поставити будь-яку перевірку.

компактний - це змити непотрібні нулі, які вийшли з того стану if

Ні, але ви можете зробити це так:

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

Або ще краще:

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

Я думаю, що цей спосіб є більш читабельним, оскільки розділяє умови фільтра та відображене значення, залишаючи зрозумілим, що дії пов’язані:

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

І, у вашому конкретному випадку, виключіть resultзмінну разом:

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

У Ruby 1.9 та 1.8.7 ви також можете ланцюжком та обертати ітератори, просто не передаючи їм блок:

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

Але насправді це неможливо в цьому випадку, оскільки типи блоку повертають значення selectі mapне збігаються. Це має більше сенсу для чогось такого:

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

AFAICS, найкраще, що ви можете зробити, це перший приклад.

Ось невеликий приклад:

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

Але те, що ви насправді хочете, - це ["A", "B", "C", "D"].

Спробуйте використати мою бібліотеку Rearmed Ruby, до якої я додав метод Enumerable#select_map. Ось приклад:

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

Якщо ви хочете не створювати два різні масиви, ви можете використовувати, compact!але будьте обережні з цим.

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

Цікаво, що compact!робить на місці видалення нуля. Повернене значення - compact!це той самий масив, якщо були зміни, але нуль, якщо не було нулів.

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

Був би одним вкладишем.

Ваша версія:

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

Моя версія:

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

Це зробить 1 ітерацію (крім сортування) і додасть додатковий бонус збереження унікальності (якщо ви не дбаєте про uniq, просто зробіть результати масивом і results.push(line) if ...

Ось приклад. Це не те саме, що ваша проблема, але може бути тим, що ви хочете, або може дати підказку для вашого рішення:

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