Come farei per rimuovere tutti gli elementi vuoti (voci di elenco vuote) da un file Hash o YAML nidificato?
Come farei per rimuovere tutti gli elementi vuoti (voci di elenco vuote) da un file Hash o YAML nidificato?
Risposte:
È possibile aggiungere un metodo compatto a Hash in questo modo
class Hash
def compact
delete_if { |k, v| v.nil? }
end
end
o per una versione che supporta la ricorsione
class Hash
def compact(opts={})
inject({}) do |new_hash, (k,v)|
if !v.nil?
new_hash[k] = opts[:recurse] && v.class == Hash ? v.compact(opts) : v
end
new_hash
end
end
end
Hash#delete_if
è un'operazione distruttiva, mentre i compact
metodi non modificano l'oggetto. È possibile utilizzare Hash#reject
. O chiama il metodo Hash#compact!
.
compact
e compact!
diventare standard in Ruby => 2.4.0 e Rails => 4.1. Sono però non ricorsivi.
HashWithIndifferentAccess
.. Verificare la mia versione a stackoverflow.com/a/53958201/1519240
Rails 4.1 ha aggiunto Hash # compact e Hash # compact! come estensioni principali della Hash
classe di Ruby . Puoi usarli in questo modo:
hash = { a: true, b: false, c: nil }
hash.compact
# => { a: true, b: false }
hash
# => { a: true, b: false, c: nil }
hash.compact!
# => { a: true, b: false }
hash
# => { a: true, b: false }
{ c: nil }.compact
# => {}
Heads up: questa implementazione non è ricorsiva. Per curiosità, lo hanno implementato usando #select
invece che #delete_if
per motivi di performance. Vedi qui per il benchmark .
Nel caso in cui si desideri eseguire il backport sull'app Rails 3:
# config/initializers/rails4_backports.rb
class Hash
# as implemented in Rails 4
# File activesupport/lib/active_support/core_ext/hash/compact.rb, line 8
def compact
self.select { |_, value| !value.nil? }
end
end
Usa hsh.delete_if . Nel tuo caso specifico, qualcosa come:hsh.delete_if { |k, v| v.empty? }
proc = Proc.new { |k, v| v.kind_of?(Hash) ? (v.delete_if(&l); nil) : v.empty? }; hsh.delete_if(&proc)
NoMethodError
if v
is nil.
Se stai usando Ruby 2.4+, puoi chiamare compact
ecompact!
h = { a: 1, b: false, c: nil }
h.compact! #=> { a: 1, b: false }
https://ruby-doc.org/core-2.4.0/Hash.html#method-i-compact-21
Questo eliminerebbe anche gli hash vuoti:
swoop = Proc.new { |k, v| v.delete_if(&swoop) if v.kind_of?(Hash); v.empty? }
hsh.delete_if &swoop
swoop = Proc.new { |k, v| v.delete_if(&swoop) if v.kind_of?(Hash); v.blank? }
È possibile utilizzare Hash # rifiutare per rimuovere coppie chiave / valore vuote da un hash rubino.
# Remove empty strings
{ a: 'first', b: '', c: 'third' }.reject { |key,value| value.empty? }
#=> {:a=>"first", :c=>"third"}
# Remove nil
{a: 'first', b: nil, c: 'third'}.reject { |k,v| v.nil? }
# => {:a=>"first", :c=>"third"}
# Remove nil & empty strings
{a: '', b: nil, c: 'third'}.reject { |k,v| v.nil? || v.empty? }
# => {:c=>"third"}
.empty?
genera un errore per i numeri, quindi è possibile utilizzare .blank?
inRails
funziona sia per hash che per array
module Helpers
module RecursiveCompact
extend self
def recursive_compact(hash_or_array)
p = proc do |*args|
v = args.last
v.delete_if(&p) if v.respond_to? :delete_if
v.nil? || v.respond_to?(:"empty?") && v.empty?
end
hash_or_array.delete_if(&p)
end
end
end
PS basato sulla risposta di qualcuno, non riesco a trovare
utilizzo - Helpers::RecursiveCompact.recursive_compact(something)
So che questo thread è un po 'vecchio ma ho trovato una soluzione migliore che supporta gli hash multidimensionali. Usa delete_if? tranne che è multidimensionale e pulisce di default qualsiasi cosa con un valore vuoto e se un blocco viene passato viene passato attraverso i suoi figli.
# Hash cleaner
class Hash
def clean!
self.delete_if do |key, val|
if block_given?
yield(key,val)
else
# Prepeare the tests
test1 = val.nil?
test2 = val === 0
test3 = val === false
test4 = val.empty? if val.respond_to?('empty?')
test5 = val.strip.empty? if val.is_a?(String) && val.respond_to?('empty?')
# Were any of the tests true
test1 || test2 || test3 || test4 || test5
end
end
self.each do |key, val|
if self[key].is_a?(Hash) && self[key].respond_to?('clean!')
if block_given?
self[key] = self[key].clean!(&Proc.new)
else
self[key] = self[key].clean!
end
end
end
return self
end
end
Ho creato un metodo deep_compact per questo che filtra in modo ricorsivo zero record (e, facoltativamente, anche record vuoti):
class Hash
# Recursively filters out nil (or blank - e.g. "" if exclude_blank: true is passed as an option) records from a Hash
def deep_compact(options = {})
inject({}) do |new_hash, (k,v)|
result = options[:exclude_blank] ? v.blank? : v.nil?
if !result
new_value = v.is_a?(Hash) ? v.deep_compact(options).presence : v
new_hash[k] = new_value if new_value
end
new_hash
end
end
end
Ruby Hash#compact
, Hash#compact!
e Hash#delete_if!
senza fare il lavoro su nidificato nil
, empty?
e / o blank?
valori. Si noti che i ultimi due metodi sono distruttivi, e che tutti nil
, ""
, false
, []
e {}
valori vengono contati come blank?
.
Hash#compact
e Hash#compact!
sono disponibili solo in Rails o Ruby versione 2.4.0 e successive.
Ecco una soluzione non distruttiva che rimuove tutti gli array, hash, stringhe e nil
valori vuoti , mantenendo tutti i false
valori:
( blank?
può essere sostituito con nil?
o empty?
secondo necessità.)
def remove_blank_values(hash)
hash.each_with_object({}) do |(k, v), new_hash|
unless v.blank? && v != false
v.is_a?(Hash) ? new_hash[k] = remove_blank_values(v) : new_hash[k] = v
end
end
end
Una versione distruttiva:
def remove_blank_values!(hash)
hash.each do |k, v|
if v.blank? && v != false
hash.delete(k)
elsif v.is_a?(Hash)
hash[k] = remove_blank_values!(v)
end
end
end
Oppure, se si desidera aggiungere entrambe le versioni come metodi di istanza sulla Hash
classe:
class Hash
def remove_blank_values
self.each_with_object({}) do |(k, v), new_hash|
unless v.blank? && v != false
v.is_a?(Hash) ? new_hash[k] = v.remove_blank_values : new_hash[k] = v
end
end
end
def remove_blank_values!
self.each_pair do |k, v|
if v.blank? && v != false
self.delete(k)
elsif v.is_a?(Hash)
v.remove_blank_values!
end
end
end
end
Altre opzioni:
v.blank? && v != false
con v.nil? || v == ""
per rimuovere rigorosamente stringhe e nil
valori vuotiv.blank? && v != false
con v.nil?
per rimuovere rigorosamente i nil
valoriEDITED 2017/03/15 per mantenere i false
valori e presentare altre opzioni
In Simple one liner per l'eliminazione di valori null in Hash,
rec_hash.each {|key,value| rec_hash.delete(key) if value.blank? }
blank?
vale anche per stringhe vuote
Potrebbe essere fatto con la libreria di sfaccettature (caratteristiche mancanti dalla libreria standard), in questo modo:
require 'hash/compact'
require 'enumerable/recursively'
hash.recursively { |v| v.compact! }
Funziona con qualsiasi Enumerabile (compresi Array, Hash).
Guarda come viene implementato il metodo ricorsivo .
Credo che sarebbe meglio usare un metodo ricorsivo. In questo modo si arriva alla profondità necessaria. Ciò eliminerà la coppia di valori chiave se il valore è zero o un hash vuoto.
class Hash
def compact
delete_if {|k,v| v.is_a?(Hash) ? v.compact.empty? : v.nil? }
end
end
Quindi usandolo sarà simile a questo:
x = {:a=>{:b=>2, :c=>3}, :d=>nil, :e=>{:f=>nil}, :g=>{}}
# => {:a=>{:b=>2, :c=>3}, :d=>nil, :e=>{:f=>nil}, :g=>{}}
x.compact
# => {:a=>{:b=>2, :c=>3}}
Per mantenere gli hash vuoti puoi semplificare questo.
class Hash
def compact
delete_if {|k,v| v.compact if v.is_a?(Hash); v.nil? }
end
end
class Hash
def compact
def _empty?(val)
case val
when Hash then val.compact.empty?
when Array then val.all? { |v| _empty?(v) }
when String then val.empty?
when NilClass then true
# ... custom checking
end
end
delete_if { |_key, val| _empty?(val) }
end
end
Prova questo per rimuovere lo zero
hash = { a: true, b: false, c: nil }
=> {:a=>true, :b=>false, :c=>nil}
hash.inject({}){|c, (k, v)| c[k] = v unless v.nil?; c}
=> {:a=>true, :b=>false}
hash.compact!
La versione ricorsiva di https://stackoverflow.com/a/14773555/1519240 funziona, ma non con HashWithIndifferentAccess
o altre classi che sono tipo di Hash ..
Ecco la versione che sto usando:
def recursive_compact
inject({}) do |new_hash, (k,v)|
if !v.nil?
new_hash[k] = v.kind_of?(Hash) ? v.recursive_compact : v
end
new_hash
end
end
kind_of?(Hash)
accetterà più classi che sono come un hash.
Puoi anche sostituirlo inject({})
con inject(HashWithIndifferentAccess.new)
se vuoi accedere al nuovo hash usando sia il simbolo che la stringa.
Ecco qualcosa che ho:
# recursively remove empty keys (hashes), values (array), hashes and arrays from hash or array
def sanitize data
case data
when Array
data.delete_if { |value| res = sanitize(value); res.blank? }
when Hash
data.delete_if { |_, value| res = sanitize(value); res.blank? }
end
data.blank? ? nil : data
end
Cancellazione profonda valori nulli da un hash.
# returns new instance of hash with deleted nil values
def self.deep_remove_nil_values(hash)
hash.each_with_object({}) do |(k, v), new_hash|
new_hash[k] = deep_remove_nil_values(v) if v.is_a?(Hash)
new_hash[k] = v unless v.nil?
end
end
# rewrite current hash
def self.deep_remove_nil_values!(hash)
hash.each do |k, v|
deep_remove_nil_values(v) if v.is_a?(Hash)
hash.delete(k) if v.nil?
end
end
Se si sta utilizzando Rails
(o uno standalone ActiveSupport
), a partire dalla versione 6.1
, esiste un compact_blank
metodo che rimuove i blank
valori dagli hash.
Usa Object#blank?
sotto il cofano per determinare se un oggetto è vuoto.
{ a: "", b: 1, c: nil, d: [], e: false, f: true }.compact_blank
# => { b: 1, f: true }
Ecco un link ai documenti e un link al relativo PR .
È disponibile anche una variante distruttiva. Vedere Hash#compact_blank!
.
Se è necessario rimuovere solo i nil
valori,
per favore, considera di usare il build-in Hash#compact
e i Hash#compact!
metodi di Ruby .
{ a: 1, b: false, c: nil }.compact
# => { a: 1, b: false }