Cara memetakan dan menghapus nilai nil di Ruby

Saya punya mapyang bisa mengubah nilai atau menyetelnya menjadi nol. Saya kemudian ingin menghapus entri nil dari daftar. Daftar tidak perlu disimpan.

Inilah yang saat ini saya miliki:

# A simple example function, which returns a value or nil
def transform(n)
  rand > 0.5 ? n * 10 : nil }
end

items.map! { |x| transform(x) } # [1, 2, 3, 4, 5] => [10, nil, 30, 40, nil]
items.reject! { |x| x.nil? } # [10, nil, 30, 40, nil] => [10, 30, 40]

Saya sadar saya hanya bisa melakukan loop dan secara kondisional mengumpulkan di array lain seperti ini:

new_items = []
items.each do |x|
    x = transform(x)
    new_items.append(x) unless x.nil?
end
items = new_items

Tapi sepertinya itu tidak idiomatis. Apakah ada cara yang bagus untuk memetakan fungsi pada daftar, menghapus / mengecualikan nil saat Anda pergi?

Ruby 2.7+

Ada sekarang!

Ruby 2.7 memperkenalkan filter_mapuntuk tujuan yang tepat ini. Ini idiomatis dan pemain, dan saya berharap itu akan menjadi norma segera.

Sebagai contoh:

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

Dalam kasus Anda, ketika blok mengevaluasi ke falsey, cukup:

items.filter_map { |x| process_x url }

" Ruby 2.7 menambahkan Enumerable # filter_map " adalah bacaan yang bagus tentang subjek, dengan beberapa tolok ukur kinerja terhadap beberapa pendekatan sebelumnya untuk masalah ini:

N = 1_00_000
enum = 1.upto(1_000)
Benchmark.bmbm do |x|
  x.report("select + map")  { N.times { enum.select { |i| i.even? }.map{|i| i + 1} } }
  x.report("map + compact") { N.times { enum.map { |i| i + 1 if i.even? }.compact } }
  x.report("filter_map")    { N.times { enum.filter_map { |i| i + 1 if i.even? } } }
end

# Rehearsal -------------------------------------------------
# select + map    8.569651   0.051319   8.620970 (  8.632449)
# map + compact   7.392666   0.133964   7.526630 (  7.538013)
# filter_map      6.923772   0.022314   6.946086 (  6.956135)
# --------------------------------------- total: 23.093686sec
# 
#                     user     system      total        real
# select + map    8.550637   0.033190   8.583827 (  8.597627)
# map + compact   7.263667   0.131180   7.394847 (  7.405570)
# filter_map      6.761388   0.018223   6.779611 (  6.790559)

Anda bisa menggunakan compact:

[1, nil, 3, nil, nil].compact
=> [1, 3] 

Saya ingin mengingatkan orang bahwa jika Anda mendapatkan array yang berisi nils sebagai output dari sebuah mapblok, dan blok itu mencoba mengembalikan nilai secara kondisional, maka Anda memiliki kode bau dan perlu memikirkan kembali logika Anda.

Misalnya, jika Anda melakukan sesuatu yang melakukan ini:

[1,2,3].map{ |i|
  if i % 2 == 0
    i
  end
}
# => [nil, 2, nil]

Kalau begitu jangan. Alih-alih, sebelum map, rejecthal-hal yang tidak Anda inginkan atau selectapa yang Anda inginkan:

[1,2,3].select{ |i| i % 2 == 0 }.map{ |i|
  i
}
# => [2]

Saya menganggap menggunakan compactuntuk membersihkan kekacauan sebagai upaya terakhir untuk menyingkirkan hal-hal yang tidak kami tangani dengan benar, biasanya karena kami tidak tahu apa yang akan terjadi pada kami. Kita harus selalu tahu data seperti apa yang dilemparkan ke dalam program kita; Data yang tidak terduga / tidak dikenal buruk. Setiap kali saya melihat nils dalam array yang sedang saya kerjakan, saya menggali mengapa mereka ada, dan melihat apakah saya dapat meningkatkan kode yang menghasilkan array, daripada membiarkan Ruby membuang-buang waktu dan memori yang menghasilkan nil kemudian memilah-milah array untuk menghapus mereka nanti.

'Just my $%0.2f.' % [2.to_f/100]

Coba gunakan reduceatau inject.

[1, 2, 3].reduce([]) { |memo, i|
  if i % 2 == 0
    memo << i
  end

  memo
}

Saya setuju dengan jawaban yang diterima bahwa kita tidak boleh mapdan compact, tetapi tidak untuk alasan yang sama.

Saya merasa jauh di lubuk hati yang mapkemudian compactsetara dengan selectitu map. Pertimbangkan: mapadalah fungsi satu-ke-satu. Jika Anda memetakan dari beberapa set nilai, dan Anda map, maka Anda ingin satu nilai dalam set output untuk setiap nilai dalam set input. Jika Anda harus selectsebelumnya, maka Anda mungkin tidak ingin mapdi set. Jika Anda harus selectsetelah itu (atau compact) maka Anda mungkin tidak ingin mapdi set. Dalam kedua kasus Anda mengulangi dua kali seluruh set, ketika reducehanya perlu pergi sekali.

Juga, dalam bahasa Inggris, Anda mencoba "mengurangi satu set bilangan bulat menjadi satu set bilangan bulat genap".

Dalam contoh Anda:

items.map! { |x| process_x url } # [1, 2, 3, 4, 5] => [1, nil, 3, nil, nil]

itu tidak terlihat seperti nilai telah berubah selain diganti dengan nil. Jika itu masalahnya, maka:

items.select{|x| process_x url}

akan cukup.

Jika Anda ingin kriteria yang lebih longgar untuk penolakan, misalnya, untuk menolak string kosong dan nol, Anda dapat menggunakan:

[1, nil, 3, 0, ''].reject(&:blank?)
 => [1, 3, 0] 

Jika Anda ingin melangkah lebih jauh dan menolak nilai nol (atau menerapkan logika yang lebih kompleks untuk proses tersebut), Anda bisa meneruskan blok untuk menolak:

[1, nil, 3, 0, ''].reject do |value| value.blank? || value==0 end
 => [1, 3]

[1, nil, 3, 0, '', 1000].reject do |value| value.blank? || value==0 || value>10 end
 => [1, 3]

Jelas compactmerupakan pendekatan terbaik untuk menyelesaikan tugas ini. Namun, kami dapat mencapai hasil yang sama hanya dengan pengurangan sederhana:

[1, nil, 3, nil, nil] - [nil]
 => [1, 3]

each_with_object mungkin cara paling bersih untuk pergi ke sini:

new_items = items.each_with_object([]) do |x, memo|
    ret = process_x(x)
    memo << ret unless ret.nil?
end

Menurut pendapat saya, each_with_objectlebih baik daripada inject/ reducedalam kasus bersyarat karena Anda tidak perlu khawatir tentang nilai pengembalian blok.

Satu cara lagi untuk mencapainya adalah seperti yang ditunjukkan di bawah ini. Di sini, kami menggunakan Enumerable#each_with_objectuntuk mengumpulkan nilai-nilai, dan memanfaatkan Object#tapuntuk menyingkirkan variabel sementara yang jika tidak diperlukan untuk nilmemeriksa hasil process_xmetode.

items.each_with_object([]) {|x, obj| (process x).tap {|r| obj << r unless r.nil?}}

Contoh lengkap untuk ilustrasi:

items = [1,2,3,4,5]
def process x
    rand(10) > 5 ? nil : x
end

items.each_with_object([]) {|x, obj| (process x).tap {|r| obj << r unless r.nil?}}

Pendekatan alternatif:

Dengan melihat metode yang Anda panggil process_x url, tidak jelas apa tujuan input xdalam metode itu. Jika saya berasumsi bahwa Anda akan memproses nilai xdengan melewatkannya urldan menentukan mana dari xs yang benar-benar diproses menjadi hasil non-nil yang valid - maka, mungkin Enumerabble.group_bymerupakan opsi yang lebih baik daripada Enumerable#map.

h = items.group_by {|x| (process x).nil? ? "Bad" : "Good"}
#=> {"Bad"=>[1, 2], "Good"=>[3, 4, 5]}

h["Good"]
#=> [3,4,5]