我如何从嵌套的Hash或YAML文件中删除所有空元素（空列表项）？
您可以像这样向Hash添加一个紧凑的方法
class Hash
def compact
delete_if { |k, v| v.nil? }
end
end
或者支持递归的版本
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
在Simple one liner中，用于删除Hash中的空值，
rec_hash.each {|key,value| rec_hash.delete(key) if value.blank? }
我们的版本：它还清除空字符串和空值
class Hash
def compact
delete_if{|k, v|
(v.is_a?(Hash) and v.respond_to?('empty?') and v.compact.empty?) or
(v.nil?) or
(v.is_a?(String) and v.empty?)
}
end
end
可以使用facets库（标准库中缺少的功能），如下所示：
require 'hash/compact'
require 'enumerable/recursively'
hash.recursively { |v| v.compact! }
适用于任何Enumerable（包括Array，Hash）。
看看recursively method是如何实现的。
我相信最好使用自递归方法。这样就可以根据需要进行深入研究。如果值为nil或空哈希，则将删除键值对。
class Hash
def compact
delete_if {|k,v| v.is_a?(Hash) ? v.compact.empty? : v.nil? }
end
end
然后使用它将如下所示：
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}}
要保留空哈希，您可以将其简化为。
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
试试这个删除零
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}
https://stackoverflow.com/a/14773555/1519240的递归版本有效，但不适用于HashWithIndifferentAccess或其他类似Hash的类。
这是我正在使用的版本：
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)将接受更多类似哈希的课程。
如果要使用符号和字符串访问新哈希，也可以用inject({})替换inject(HashWithIndifferentAccess.new)。
这是我有的东西：
# 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
使用hsh.delete_if。在您的具体情况下，像：hsh.delete_if { |k, v| v.empty? }
Rails 4.1添加了Hash#compact和Hash#compact!作为Ruby的Hash类的核心扩展。您可以像这样使用它们：
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
# => {}
抬头：这个实现不是递归的。出于好奇心，他们出于性能原因使用#select而不是#delete_if来实现它。见here for the benchmark。
如果你想将它反向移植到你的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
这个也会删除空哈希：
swoop = Proc.new { |k, v| v.delete_if(&swoop) if v.kind_of?(Hash); v.empty? }
hsh.delete_if &swoop
我知道这个线程有点旧，但我想出了一个更好的解决方案，它支持多维哈希。它使用delete_if？除了它的多维并且默认情况下清除任何具有空值的内容，如果传递了一个块，它将通过它的子项向下传递。
# 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
您可以使用Hash#reject从ruby Hash中删除空键/值对。
# 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"}
我为此创建了一个deep_compact方法，以递归方式过滤掉nil记录（以及可选的空白记录）：
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!和Hash#delete_if!不适用于嵌套的nil，empty?和/或blank?值。请注意，后两种方法具有破坏性，所有nil，""，false，[]和{}值均计为blank?。
Hash#compact和Hash#compact!仅适用于Rails或Ruby版本2.4.0及更高版本。
这是一个非破坏性的解决方案，删除所有空数组，哈希，字符串和nil值，同时保留所有false值：
（blank?可以根据需要用nil?或empty?替换。）
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
破坏性版本：
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
或者，如果要在Hash类上添加两个版本作为实例方法：
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
其他选择：
v.blank? && v != false替换v.nil? || v == ""以严格删除空字符串和nil值v.blank? && v != false替换v.nil?以严格删除nil值编辑2017/03/15以保持false价值并提供其他选择
适用于哈希和数组
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
附：根据某人的回答，无法找到
用法 - Helpers::RecursiveCompact.recursive_compact(something)