Di Ruby, apakah ada metode Array yang menggabungkan 'pilih' dan 'peta'?

Saya memiliki array Ruby yang berisi beberapa nilai string. Aku ingin:

1. Temukan semua elemen yang cocok dengan beberapa predikat
2. Jalankan elemen yang cocok melalui transformasi
3. Kembalikan hasilnya sebagai larik

Sekarang solusi saya terlihat seperti ini:

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

Apakah ada metode Array atau Enumerable yang menggabungkan select dan map menjadi satu pernyataan logis?

Saya biasanya menggunakan mapdan compactbersama dengan kriteria pemilihan saya sebagai postfix if. compactmenghilangkan nil.

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] 

Anda dapat menggunakan reduceuntuk ini, yang hanya membutuhkan satu izin:

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

Dengan kata lain, inisialisasi status menjadi apa yang Anda inginkan (dalam kasus kami, daftar kosong untuk diisi: [] , lalu selalu pastikan untuk mengembalikan nilai ini dengan modifikasi untuk setiap elemen dalam daftar asli (dalam kasus kami, elemen yang dimodifikasi didorong ke daftar).

Ini adalah yang paling efisien karena hanya mengulang daftar dengan satu pass ( map+ selectataucompact membutuhkan dua pass).

Dalam kasus Anda:

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

Ruby 2.7+

Ada sekarang!

Ruby 2.7 memperkenalkan filter_map untuk tujuan yang tepat ini. Ini idiomatis dan bagus, dan saya berharap itu menjadi norma segera.

Sebagai contoh:

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

Berikut bacaan yang bagus tentang masalah ini .

Semoga bermanfaat bagi seseorang!

Cara lain yang berbeda untuk mendekati ini adalah menggunakan yang baru (relatif terhadap pertanyaan ini) Enumerator::Lazy:

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

The .lazyMetode mengembalikan enumerator malas. Memanggil .selectatau .mappada pencacah malas mengembalikan pencacah malas lainnya. Hanya sekali Anda menelepon .uniqapakah itu benar-benar memaksa pencacah dan mengembalikan array. Jadi yang terjadi secara efektif adalah panggilan Anda .selectdan .mapdigabungkan menjadi satu - Anda hanya mengulangi @linessekali untuk melakukan keduanya .selectdan.map .

Naluri saya adalah bahwa reducemetode Adam akan sedikit lebih cepat, tetapi saya pikir ini jauh lebih mudah dibaca.

Konsekuensi utama dari hal ini adalah tidak ada objek larik perantara yang dibuat untuk setiap panggilan metode berikutnya. Dalam @lines.select.mapsituasi normal , selectmengembalikan larik yang kemudian dimodifikasi oleh map, kembali mengembalikan larik. Sebagai perbandingan, evaluasi malas hanya membuat larik satu kali. Ini berguna ketika objek koleksi awal Anda berukuran besar. Ini juga memberdayakan Anda untuk bekerja dengan enumerator tak terbatas - mis random_number_generator.lazy.select(&:odd?).take(10).

Jika Anda memiliki selectyang dapat menggunakan caseoperator ( ===), grepadalah alternatif yang baik:

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

Jika kita membutuhkan logika yang lebih kompleks, kita dapat membuat 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***"]

Saya tidak yakin ada satu. The modul Enumerable , yang menambahkan selectdan map, tidak menunjukkan satu.

Anda akan diminta untuk mengirimkan dua blok ke select_and_transformmetode ini, yang akan menjadi IMHO sedikit tidak intuitif.

Jelas, Anda bisa merangkainya, yang lebih mudah dibaca:

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

Jawaban Sederhana:

Jika Anda memiliki n catatan, dan Anda ingin selectdan mapberdasarkan kondisi maka

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

Di sini, atribut adalah apa pun yang Anda inginkan dari catatan dan kondisi, Anda dapat mencentangnya.

Compact adalah untuk membilas nil yang tidak perlu yang keluar dari kondisi tersebut

Tidak, tapi Anda bisa melakukannya seperti ini:

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

Atau bahkan lebih baik:

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

Saya pikir cara ini lebih mudah dibaca, karena membagi kondisi filter dan nilai yang dipetakan sambil tetap jelas bahwa tindakannya terhubung:

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

Dan, dalam kasus spesifik Anda, hilangkan resultvariabel semuanya:

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

Di Ruby 1.9 dan 1.8.7, Anda juga dapat merangkai dan membungkus iterator hanya dengan tidak memberikan satu blok kepada mereka:

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

Tapi itu tidak benar-benar mungkin dalam kasus ini, karena tipe blok mengembalikan nilai selectdan maptidak cocok. Lebih masuk akal untuk sesuatu seperti ini:

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

AFAICS, hal terbaik yang dapat Anda lakukan adalah contoh pertama.

Inilah contoh kecilnya:

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

Tapi yang benar - benar Anda inginkan adalah ["A", "B", "C", "D"].

Anda harus mencoba menggunakan perpustakaan saya Rearmed Ruby yang telah saya tambahkan metodenya Enumerable#select_map. Berikut contohnya:

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

Jika Anda tidak ingin membuat dua larik yang berbeda, Anda dapat menggunakan compact!tetapi berhati-hatilah.

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

Menariknya, compact! melakukan penghapusan di tempat nihil. Nilai kembalian dari compact!array yang sama jika ada perubahan tetapi nihil jika tidak ada nil.

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

Akan menjadi satu kapal.

Versi Anda:

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

Versi saya:

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

Ini akan melakukan 1 iterasi (kecuali pengurutan), dan memiliki bonus tambahan untuk menjaga keunikan (jika Anda tidak peduli tentang unik, maka buat saja hasilnya menjadi array dan results.push(line) if ...

Berikut ini contohnya. Ini tidak sama dengan masalah Anda, tetapi mungkin apa yang Anda inginkan, atau dapat memberi petunjuk untuk solusi Anda:

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