Styl Ruby: jak sprawdzić, czy zagnieżdżony element hash istnieje

W Ruby 2.3 będziemy mieli wsparcie dla operatora bezpiecznej nawigacji: https://www.ruby-lang.org/en/news/2015/11/11/ruby-2-3-0-preview1-released/

has_children teraz Można zapisać jako:

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

dig dodaje się również:

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

Inna alternatywa:

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

Możesz użyć andand gem:

require 'andand'

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

Można użyć hash z domyślną wartością {} - empty hash. Na przykład,

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

To działa również z już utworzonym Hashem:

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

Lub można zdefiniować metodę [] dla klasy nil

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

nil[:a] #=> nil

Tradycyjnie, naprawdę trzeba było zrobić coś takiego:

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

Jednak Ruby 2.3 dodał funkcję, która czyni ten sposób bardziej wdzięcznym:

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

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

Zauważ, że w rails możesz również zrobić:

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

Oto sposób, w jaki możesz zrobić głębokie sprawdzenie wszelkich fałszywych wartości w hash i zagnieżdżonych hashach bez Małpiego łatania klasy Ruby Hash (proszę nie małpuj łatania klas Ruby, czegoś takiego nigdy nie powinieneś robić).

(zakładając Rails, chociaż można łatwo zmodyfikować to tak, aby działało poza 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

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

Upraszczając powyższe odpowiedzi tutaj:

Utwórz rekurencyjną metodę Hash, której wartość nie może być zerowa, jak poniżej.

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

Jeśli nie masz nic przeciwko stworzeniu pustych hashów, jeśli wartość nie istnieje dla klucza:)

Możesz spróbować grać z

dino.default = {}

Lub na przykład:

empty_hash = {}
empty_hash.default = empty_hash

dino.default = empty_hash

W ten sposób możesz zadzwonić

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

Given

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

Możesz sprawdzić x i y TAK:

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

Thks @ tadman za odpowiedź.

Dla tych, którzy chcą perfs (i utknęli z Rubim

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

A jeśli używasz RubyInline , ta metoda jest 16X szybsza:

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

Możesz również zdefiniować moduł do aliasów metod nawiasów i użyć składni Ruby do odczytu/zapisu zagnieżdżonych elementów.

UPDATE: zamiast nadpisywać Accesory wsporników, Zażądaj wystąpienia skrótu, aby rozszerzyć moduł.

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

Wtedy możesz zrobić:

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