rails - Ruby Style: cómo verificar si existe un elemento hash anidado

ruby rubocop

Question

Considere una "persona" almacenada en un hash. Dos ejemplos son:

fred = {:person => {:name => "Fred", :spouse => "Wilma", :children => {:child => {:name => "Pebbles"}}}}
slate = {:person => {:name => "Mr. Slate", :spouse => "Mrs. Slate"}} 

Si la "persona" no tiene hijos, el elemento "secundarios" no está presente. Entonces, para el Sr. Slate, podemos verificar si tiene padres:

slate_has_children = !slate[:person][:children].nil?

Entonces, ¿qué pasa si no sabemos que "pizarra" es una "persona" hash? Considerar:

dino = {:pet => {:name => "Dino"}}

No podemos verificar fácilmente para los niños más:

dino_has_children = !dino[:person][:children].nil?
NoMethodError: undefined method `[]'' for nil:NilClass

Entonces, ¿cómo verificaría la estructura de un hash, especialmente si está anidado profundamente (incluso más profundo que los ejemplos proporcionados aquí)? Tal vez una mejor pregunta es: ¿cuál es la "forma de Ruby" para hacer esto?

Answer 1

Aquí hay una manera de hacer un chequeo profundo de cualquier valor falso en el hash y cualquier hash anidado sin parche de monos en la clase Ruby Hash (POR FAVOR, no pongas parches en las clases de Ruby, es algo que no debes hacer, NUNCA) .

(Asumiendo Rails, aunque podrías modificar esto fácilmente para trabajar fuera de Rails)

def deep_all_present?(hash)
  fail ArgumentError, ''deep_all_present? only accepts Hashes'' unless hash.is_a? Hash

  hash.each do |key, value|
    return false if key.blank? || value.blank?
    return deep_all_present?(value) if value.is_a? Hash
  end

  true
end

Answer 2

Con Ruby 2.3, tendremos soporte para el operador de navegación segura: ruby-lang.org/en/news/2015/11/11/ruby-2-3-0-preview1-released

has_children ahora podría escribirse como:

has_children = slate[:person]&.[](:children)

dig se está agregando también:

has_children = slate.dig(:person, :children)

Answer 3

Dado

x = {:a => {:b => ''c''}}
y = {}

puedes verificar xey de esta manera:

(x[:a] || {})[:b] # ''c''
(y[:a] || {})[:b] # nil

Answer 4

La forma más obvia de hacerlo es simplemente verificar cada paso del camino:

has_children = slate[:person] && slate[:person][:children]

Uso de .nil? en realidad solo se requiere cuando usa falso como valor de marcador de posición, y en la práctica esto es raro. En general, puedes simplemente probar que existe.

Actualización : si está usando Ruby 2.3 o posterior, hay un método de dig integrado que hace lo que se describe en esta respuesta.

De lo contrario, también puede definir su propio método Hash "dig" que puede simplificar esto de manera sustancial:

class Hash
  def dig(*path)
    path.inject(self) do |location, key|
      location.respond_to?(:keys) ? location[key] : nil
    end
  end
end

Este método comprobará cada paso del camino y evitará tropezar con llamadas a cero. Para las estructuras poco profundas, la utilidad es algo limitada, pero para las estructuras profundamente anidadas, me parece invaluable:

has_children = slate.dig(:person, :children)

También puede hacer esto más robusto, por ejemplo, probando si la entrada: children está realmente poblada:

children = slate.dig(:person, :children)
has_children = children && !children.empty?

Answer 5

Otra alternativa:

dino.fetch(:person, {})[:children]

Answer 6

Puedes intentar jugar con

dino.default = {}

O por ejemplo:

empty_hash = {}
empty_hash.default = empty_hash

dino.default = empty_hash

De esa forma puedes llamar

empty_hash[:a][:b][:c][:d][:e] # and so on...
dino[:person][:children] # at worst it returns {}

Answer 7

Puedes usar el andand gem:

require ''andand''

fred[:person].andand[:children].nil? #=> false
dino[:person].andand[:children].nil? #=> true

Puede encontrar más explicaciones en http://andand.rubyforge.org/ .

Answer 8

Simplificando las respuestas anteriores aquí:

Cree un método Recursive Hash cuyo valor no puede ser nil, como el siguiente.

def recursive_hash
  Hash.new {|key, value| key[value] = recursive_hash}
end

> slate = recursive_hash 
> slate[:person][:name] = "Mr. Slate"
> slate[:person][:spouse] = "Mrs. Slate"

> slate
=> {:person=>{:name=>"Mr. Slate", :spouse=>"Mrs. Slate"}}
slate[:person][:state][:city]
=> {}

Si no te importa crear hashes vacíos si no existe :)

Answer 9

También puede definir un módulo para aliar los métodos de paréntesis y usar la sintaxis de Ruby para leer / escribir elementos anidados.

ACTUALIZACIÓN: en lugar de anular los accesos al soporte, solicite la instancia de Hash para extender el módulo.

module Nesty
  def []=(*keys,value)
    key = keys.pop
    if keys.empty? 
      super(key, value) 
    else
      if self[*keys].is_a? Hash
        self[*keys][key] = value
      else
        self[*keys] = { key => value}
      end
    end
  end

  def [](*keys)
    self.dig(*keys)
  end
end

class Hash
  def nesty
    self.extend Nesty
    self
  end
end

Entonces puedes hacer:

irb> a = {}.nesty
=> {}
irb> a[:a, :b, :c] = "value"
=> "value"
irb> a
=> {:a=>{:b=>{:c=>"value"}}}
irb> a[:a,:b,:c]
=> "value"
irb> a[:a,:b]
=> {:c=>"value"}
irb> a[:a,:d] = "another value"
=> "another value"
irb> a
=> {:a=>{:b=>{:c=>"value"}, :d=>"another value"}}

Answer 10

Thks @tadman por la respuesta.

Para aquellos que quieren perfs (y están atrapados con ruby ​​<2.3), este método es 2.5 veces más rápido:

unless Hash.method_defined? :dig
  class Hash
    def dig(*path)
      val, index, len = self, 0, path.length
      index += 1 while(index < len && val = val[path[index]])
      val
    end
  end
end

y si usas RubyInline , este método es 16 veces más rápido:

unless Hash.method_defined? :dig
  require ''inline''

  class Hash
    inline do |builder|
      builder.c_raw ''
      VALUE dig(int argc, VALUE *argv, VALUE self) {
        rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
        self = rb_hash_aref(self, *argv);
        if (NIL_P(self) || !--argc) return self;
        ++argv;
        return dig(argc, argv, self);
      }''
    end
  end
end

Answer 11

Tradicionalmente, realmente tenías que hacer algo como esto:

structure[:a] && structure[:a][:b]

Sin embargo, Ruby 2.3 agregó una característica que hace de esta manera más elegante:

structure.dig :a, :b # nil if it misses anywhere along the way

Hay una gema llamada ruby_dig que hará un parche de respaldo para usted.

Answer 12

Uno podría usar hash con el valor predeterminado de {} - hash vacío. Por ejemplo,

dino = Hash.new({})
dino[:pet] = {:name => "Dino"}
dino_has_children = !dino[:person][:children].nil? #=> false

Eso también funciona con Hash ya creado:

dino = {:pet=>{:name=>"Dino"}}
dino.default = {}
dino_has_children = !dino[:person][:children].nil? #=> false

O puede definir el método [] para la clase nula

class NilClass
  def [](* args)
     nil
   end
end

nil[:a] #=> nil

Answer 13

def flatten_hash(hash)
  hash.each_with_object({}) do |(k, v), h|
    if v.is_a? Hash
      flatten_hash(v).map do |h_k, h_v|
        h["#{k}_#{h_k}"] = h_v
      end
    else
      h[k] = v
    end
  end
end

irb(main):012:0> fred = {:person => {:name => "Fred", :spouse => "Wilma", :children => {:child => {:name => "Pebbles"}}}}
=> {:person=>{:name=>"Fred", :spouse=>"Wilma", :children=>{:child=>{:name=>"Pebbles"}}}}

irb(main):013:0> slate = {:person => {:name => "Mr. Slate", :spouse => "Mrs. Slate"}}
=> {:person=>{:name=>"Mr. Slate", :spouse=>"Mrs. Slate"}}

irb(main):014:0> flatten_hash(fred).keys.any? { |k| k.include?("children") }
=> true

irb(main):015:0> flatten_hash(slate).keys.any? { |k| k.include?("children") }
=> false

Esto aplanará todos los hashes en uno y luego en alguno? devuelve verdadero si existe alguna clave que coincida con la subcadena "hijos". Esto también podría ayudar.

Answer 14

dino_has_children = !dino.fetch(person, {})[:children].nil?

Tenga en cuenta que en los rieles también puede hacer:

dino_has_children = !dino[person].try(:[], :children).nil?   #