Removendo todos os elementos vazios de um hash / YAML?

133

Como eu removeria todos os elementos vazios (itens de lista vazios) de um arquivo Hash ou YAML aninhado?

Brian Jordan
fonte

Respostas:

70

Você pode adicionar um método compacto ao Hash assim

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

ou para uma versão que suporte recursão

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
opsb
fonte
2
O compact deve remover apenas nada. Não é falso valores
Ismael Abreu
1
Isso tem um problema: Hash#delete_ifé uma operação destrutiva, enquanto os compactmétodos não modificam o objeto. Você pode usar Hash#reject. Ou chamar o método Hash#compact!.
tokland
5
Por favor, note que compacte compact!é padrão no Ruby => 2.4.0 e Rails => 4.1. Eles não são recursivos.
Aidan
A versão recursiva não funciona com HashWithIndifferentAccess.. Verifique minha versão em stackoverflow.com/a/53958201/1519240
user1519240
157

O Rails 4.1 adicionou o Hash # compact e o Hash # compact! como extensões principais da Hashclasse Ruby . Você pode usá-los assim:

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

Atenção: essa implementação não é recursiva. Como curiosidade, eles o implementaram usando em #selectvez de #delete_ifpor razões de desempenho. Veja aqui o benchmark .

Caso você queira fazer o backport para seu aplicativo 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
dgilperez
fonte
3
Bonito e arrumado, mas provavelmente vale a pena notar que, ao contrário da resposta aceita, a extensão Rails não é recursiva?
SirRawlins
2
Omite hashes vazios.
23138 Sebastian Palma
142

Use hsh.delete_if . No seu caso específico, algo como:hsh.delete_if { |k, v| v.empty? }

jpemberthy
fonte
6
Recursivo:proc = Proc.new { |k, v| v.kind_of?(Hash) ? (v.delete_if(&l); nil) : v.empty? }; hsh.delete_if(&proc)
Daniel O'Hara
3
Acredito que haja um erro de digitação na sua resposta correta: proc = Proc.new {| k, v | v.kind_of? (Hash)? (v.delete_if (& proc); nulo): v.vazio? }; hsh.delete_if (& proc)
acw
3
@BSeven parece que eles ouviram você! api.rubyonrails.org/classes/Hash.html#method-i-compact (Rails 4.1)
#
2
Isso lançará um NoMethodErrorif vé nulo.
precisa
6
Você pode usar .delete_if {| k, v | v.blank? }
Serhii Nadolynskyi 16/02
7

Este também excluiria hashes vazios:

swoop = Proc.new { |k, v| v.delete_if(&swoop) if v.kind_of?(Hash);  v.empty? }
hsh.delete_if &swoop
punund
fonte
1
trilhos versão, que também trabalha com valores de outros tipos que Array, Hash ou String (como Fixnum):swoop = Proc.new { |k, v| v.delete_if(&swoop) if v.kind_of?(Hash); v.blank? }
wdspkr
6

Você pode usar o Hash # rejeitar para remover pares de chave / valor vazios de um Hash ruby.

# 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"}
smd1000
fonte
4
FYI: .empty?lança erro para números, para que você possa usar .blank?emRails
ilusionista
5

funciona para hashes e matrizes

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 com base na resposta de alguém, não consigo encontrar

uso - Helpers::RecursiveCompact.recursive_compact(something)

srghma
fonte
4

Eu sei que esta discussão é um pouco antiga, mas eu vim com uma solução melhor que suporta hashes multidimensionais. Ele usa delete_if? exceto sua multidimensional e limpa qualquer coisa com um valor vazio por padrão e se um bloco é passado, ele é passado através de seus filhos.

# 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
Kelly Becker
fonte
4

Eu criei um método deep_compact para isso que filtra recursivamente os registros nulos (e, opcionalmente, os registros em branco):

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
mwalsher
fonte
4

Ruby Hash#compact, Hash#compact!e Hash#delete_if!não funcionam em nested nil, empty?e / ou blank?valores. Note-se que os dois últimos métodos são destrutivos, e que todas nil, "", false, []e {}os valores são contados quantoblank? .

Hash#compacte Hash#compact!estão disponíveis apenas no Rails ou Ruby versão 2.4.0 e superior.

Aqui está uma solução não destrutiva que remove todas as matrizes, hashes, strings e nilvalores vazios , mantendo todos os falsevalores:

( blank?pode ser substituído por nil?ou empty?conforme necessário.)

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

Uma versão destrutiva:

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

Ou, se você deseja adicionar ambas as versões como métodos de instância na Hashclasse:

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

Outras opções:

  • Substitua v.blank? && v != falsepor v.nil? || v == ""para remover estritamente as cordas vazias enil valores
  • Substitua v.blank? && v != falsepor v.nil?para remover estritamente os nilvalores
  • Etc.

EDITADO 2017/03/15 para manter falsevalores e apresentar outras opções

Sebastian Jay
fonte
3

nossa versão: também limpa as strings vazias e os valores nulos

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
sahin
fonte
3

Em Um liner simples para excluir valores nulos no Hash,

rec_hash.each {|key,value| rec_hash.delete(key) if value.blank? } 
ramya
fonte
cuidadoso, blank?vai para cadeias vazias bem
Hertzel Guinness
2

Pode ser feito com a biblioteca de facetas (faltam recursos da biblioteca padrão), assim:

require 'hash/compact'
require 'enumerable/recursively'
hash.recursively { |v| v.compact! }

Funciona com qualquer enumerável (incluindo matriz, hash).

Veja como o método recursivamente é implementado.

Dmitry Polushkin
fonte
0

Eu acredito que seria melhor usar um método auto recursivo. Dessa forma, vai tão fundo quanto é necessário. Isso excluirá o par de valores-chave se o valor for nulo ou um Hash vazio.

class Hash
  def compact
    delete_if {|k,v| v.is_a?(Hash) ? v.compact.empty? : v.nil? }
  end
end

Em seguida, usá-lo ficará assim:

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

Para manter hashes vazios, você pode simplificar isso para.

class Hash
  def compact
    delete_if {|k,v| v.compact if v.is_a?(Hash); v.nil? }
  end
end
6ft Dan
fonte
Hmm. referências circulares podem levar a loop infinito IIUC.
Hertzel Guinness
0
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
Chix
fonte
Observe que "quando o Hash então compacta (val) .empty?" deve ser "quando Hash então val.compact.empty?"
AlexITC
0

Tente fazer isso para remover nada

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}
Rahul Patel
fonte
ou simplesmentehash.compact!
courtsimas
0

A versão recursiva de https://stackoverflow.com/a/14773555/1519240 funciona, mas não com HashWithIndifferentAccessou outras classes que são do tipo Hash ..

Aqui está a versão que estou 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) aceitará mais classes que são como um Hash.

Você também pode substituir inject({})por inject(HashWithIndifferentAccess.new)se desejar acessar o novo hash usando o símbolo e a sequência.

user1519240
fonte
0

Aqui está algo que eu tenho:

# 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
Varun Garg
fonte
0

Exclusão profunda de zero valores de um 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
Miro Mudrik
fonte
0

Se você estiver usando Rails(ou autônomo ActiveSupport), a partir da versão 6.1, existe um compact_blankmétodo que remove os blankvalores dos hashes.

Ele é usado Object#blank?sob o capô para determinar se um item está em branco.

{ a: "", b: 1, c: nil, d: [], e: false, f: true }.compact_blank
# => { b: 1, f: true }

Aqui está um link para os documentos e um link para o PR relativo .

Uma variante destrutiva também está disponível. Veja Hash#compact_blank!.


Se você precisar remover apenas nilvalores,

por favor, considere o uso de métodos Hash#compacte build de Ruby Hash#compact!.

{ a: 1, b: false, c: nil }.compact
# => { a: 1, b: false }
Marian13
fonte