So ordnen Sie Nullwerte in Ruby zu und entfernen sie

Ich habe eine, mapdie entweder einen Wert ändert oder auf Null setzt. Ich möchte dann die Null-Einträge aus der Liste entfernen. Die Liste muss nicht aufbewahrt werden.

Folgendes habe ich derzeit:

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

Ich bin mir bewusst, dass ich einfach eine Schleife machen und bedingt in einem anderen Array wie diesem sammeln könnte:

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

Aber es scheint nicht so idiomatisch. Gibt es eine gute Möglichkeit, eine Funktion einer Liste zuzuordnen und dabei die Nullen zu entfernen / auszuschließen?

Ruby 2.7+

Da ist jetzt!

Ruby 2.7 wird filter_mapgenau für diesen Zweck eingeführt. Es ist idiomatisch und performant, und ich würde erwarten, dass es sehr bald zur Norm wird.

Zum Beispiel:

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

In Ihrem Fall, wenn der Block zu Falsey ausgewertet wird, einfach:

items.filter_map { |x| process_x url }

" Ruby 2.7 fügt Enumerable # filter_map hinzu " ist eine gute Lektüre zu diesem Thema, mit einigen Leistungsbenchmarks gegen einige der früheren Ansätze für dieses Problem:

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)

Sie könnten verwenden compact:

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

Ich möchte die Leute daran erinnern, dass wenn Sie ein Array erhalten, das nils als Ausgabe von a enthält map Blocks erhalten und dieser Block versucht, Werte bedingt zurückzugeben, Sie nach Code riechen und Ihre Logik überdenken müssen.

Zum Beispiel, wenn Sie etwas tun, das dies tut:

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

Dann nicht. Stattdessen vor dem map, rejectwas Sie nicht wollen oder selectwas Sie wollen:

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

Ich denke darüber compactnach, ein Chaos als letzten Versuch zu beseitigen, um Dinge loszuwerden, mit denen wir nicht richtig umgegangen sind, normalerweise weil wir nicht wussten, was auf uns zukommt. Wir sollten immer wissen, welche Art von Daten in unserem Programm herumgeworfen werden. Unerwartete / unbekannte Daten sind schlecht. Jedes Mal, wenn ich Nullen in einem Array sehe, an dem ich arbeite, untersuche ich, warum sie existieren, und prüfe, ob ich den Code verbessern kann, der das Array generiert, anstatt Ruby Zeit und Speicher zu verschwenden, um Nullen zu generieren, und dann das Array zu durchsuchen, um sie zu entfernen sie später.

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

Versuchen Sie es mit reduceoder inject.

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

  memo
}

Ich bin mit der Antwort akzeptiert , dass wir nicht mapund compact, aber nicht aus den gleichen Gründen.

Ich fühle mich tief in mir, das ist mapdann compactgleichbedeutend mit selectdann map. Bedenken Sie: mapist eine Eins-zu-Eins-Funktion. Wenn Sie eine Zuordnung von einem Wertesatz und von Ihnen mapvornehmen, möchten Sie einen Wert im Ausgabesatz für jeden Wert im Eingabesatz. Wenn Sie vorher müssen select, dann wollen Sie wahrscheinlich keine mapam Set. Wenn Sie selectdanach (oder compact) müssen, dann möchten Sie wahrscheinlich keine mapam Set. In beiden Fällen iterieren Sie zweimal über den gesamten Satz, wenn ein reducenur einmal ausgeführt werden muss.

Außerdem versuchen Sie auf Englisch, "eine Menge von ganzen Zahlen in eine Menge von geraden ganzen Zahlen zu reduzieren".

In Ihrem Beispiel:

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

Es sieht nicht so aus, als hätten sich die Werte geändert, außer dass sie durch ersetzt wurden nil. Wenn dies der Fall ist, dann:

items.select{|x| process_x url}

wird genügen.

Wenn Sie ein lockereres Ablehnungskriterium wünschen, um beispielsweise leere Zeichenfolgen sowie Null abzulehnen, können Sie Folgendes verwenden:

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

Wenn Sie weiter gehen und Nullwerte ablehnen möchten (oder eine komplexere Logik auf den Prozess anwenden möchten), können Sie einen Block zum Ablehnen übergeben:

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

Auf jeden Fall compactist der beste Ansatz zur Lösung dieser Aufgabe. Wir können jedoch das gleiche Ergebnis nur mit einer einfachen Subtraktion erzielen:

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

each_with_object ist wahrscheinlich der sauberste Weg hierher:

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

Meiner Meinung nach each_with_objectist es besser als inject/ reducein bedingten Fällen, weil Sie sich nicht um den Rückgabewert des Blocks kümmern müssen.

Eine weitere Möglichkeit, dies zu erreichen, ist die unten gezeigte. Hier verwenden wir Enumerable#each_with_object, um Werte zu sammeln und um Object#taptemporäre Variablen zu entfernen, die ansonsten für die nilÜberprüfung des Ergebnisses der process_xMethode benötigt werden.

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

Vollständiges Beispiel zur Veranschaulichung:

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

Alternativer Ansatz:

Wenn Sie sich die Methode ansehen process_x url, die Sie aufrufen , ist nicht klar, welchen Zweck die Eingabe xin diese Methode hat. Wenn ich davon ausgehe, dass Sie den Wert xvon verarbeiten, indem Sie einige übergeben urlund feststellen, welche der xs wirklich zu gültigen Nicht-Null-Ergebnissen verarbeitet werden, ist dies möglicherweise Enumerabble.group_byeine bessere Option als Enumerable#map.

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

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