Suppression de tous les éléments vides d'un hachage / YAML ?

Question

Comment faire pour supprimer tous les éléments vides (éléments de liste vides) d'un fichier Hash ou YAML imbriqué ?

Answer 1

Ajout de Rails 4.1 Hash#compact y Hash#compact ! en tant qu'extension de base de l'extension de Ruby Hash classe. Vous pouvez les utiliser comme ceci :

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                  
# => {}

Attention : cette implémentation n'est pas récursive. Par curiosité, ils l'ont implémentée en utilisant #select au lieu de #delete_if pour des raisons de performance. Voir ici pour le benchmark .

Au cas où vous souhaiteriez l'intégrer à votre application 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

Answer 2

Utilisez hsh.delete_if . Dans votre cas spécifique, quelque chose comme : hsh.delete_if { |k, v| v.empty? }

Answer 3

Vous pourriez ajouter une méthode compacte à Hash comme ceci

class Hash
  def compact
    delete_if { |k, v| v.nil? }
  end
end

ou pour une version qui supporte la récursion

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

Answer 4

Celui-ci supprimerait aussi les hachages vides :

swoop = Proc.new { |k, v| v.delete_if(&swoop) if v.kind_of?(Hash);  v.empty? }
hsh.delete_if &swoop

Answer 5

Je sais que ce fil est un peu vieux mais j'ai trouvé une meilleure solution qui supporte les hachages multidimensionnels. Il utilise delete_if ? sauf qu'il est multidimensionnel et nettoie tout ce qui a une valeur vide par défaut et si un bloc est passé, il est transmis vers le bas à travers ses enfants.

# 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