Rubyでは、「select」と「map」を組み合わせたArrayメソッドはありますか？

いくつかの文字列値を含むRuby配列があります。する必要がある：

1. 一部の述語に一致するすべての要素を検索します
2. 一致する要素を変換で実行します
3. 結果を配列として返す

現在、私のソリューションは次のようになります。

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

selectとmapを組み合わせて単一の論理ステートメントにするArrayまたはEnumerableメソッドはありますか？

私は通常、選択基準mapとcompact一緒にPostfixとして使用します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,1,2,3,4].reduce([]) { |a, n| a.push(n*3) if n==1; a }
=> [3, 3, 3] 

つまり、必要な状態（この場合は空のリストを埋める：）になるように状態を初期化[]し、元のリストの各要素（この場合は変更された要素）を変更して、必ずこの値を返すようにします。リストにプッシュされます）。

これは、1つのパス（map+ selectまたはcompact 2つのパスが必要）でです。

あなたの場合：

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

Ruby 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、再び配列を返します。比較すると、遅延評価では配列が1回だけ作成されます。これは、最初のコレクションオブジェクトが大きい場合に役立ちます。また、無限列挙子（例：）を操作することもできます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***"]

あるかわかりません。列挙モジュール追加、selectおよびはmap、いずれかが表示されません。

select_and_transformメソッドに2つのブロックを渡す必要がありますが、これは少し直感的ではありません。

もちろん、それらをチェーン化することもできます。

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

簡単な答え：

あなたは、n個の記録を持っていて、したい場合selectやmap、条件に基づいて、

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

ここで、attributeは、レコードに必要なものであり、任意のチェックを行うことができる条件です。

コンパクトは、if条件から出てきた不要なnilをフラッシュすることです

いいえ、でも次のようにできます：

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

2つの異なる配列を作成したくない場合は、使用できますcompact!が、注意してください。

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

興味深いことに、compact!nilのインプレース削除を行います。の戻り値compact!は、変更があった場合は同じ配列ですが、nilがない場合はnilです。

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