How to avoid NoMethodError for missing elements in

问题:

I\'m looking for a good way to avoid checking for nil at each level in deeply nested hashes. For example:

name = params[:company][:owner][:name] if params[:company] && params[:company][:owner] && params[:company][:owner][:name]

This requires three checks, and makes for very ugly code. Any way to get around this?

回答1:

Ruby 2.3.0 introduced a new method called dig on both Hash and Array that solves this problem entirely.

name = params.dig(:company, :owner, :name)

It returns nil if the key is missing at any level.

If you are using a version of Ruby older than 2.3, you can use the ruby_dig gem or implement it yourself:

module RubyDig
  def dig(key, *rest)
    if value = (self[key] rescue nil)
      if rest.empty?
        value
      elsif value.respond_to?(:dig)
        value.dig(*rest)
      end
    end
  end
end

if RUBY_VERSION < \'2.3\'
  Array.send(:include, RubyDig)
  Hash.send(:include, RubyDig)
end

回答2:

The best compromise between functionality and clarity IMO is Raganwald\'s andand. With that, you would do:

params[:company].andand[:owner].andand[:name]

It\'s similar to try, but reads a lot better in this case since you\'re still sending messages like normal, but with a delimiter between that calls attention to the fact that you\'re treating nils specially.

回答3:

I don\'t know if that\'s what you want, but maybe you could do this?

name = params[:company][:owner][:name] rescue nil

回答4:

Equivalent to the second solution that user mpd suggested, only more idiomatic Ruby:

class Hash
  def deep_fetch *path
    path.inject(self){|acc, e| acc[e] if acc}
  end
end

hash = {a: {b: {c: 3, d: 4}}}

p hash.deep_fetch :a, :b, :c
#=> 3
p hash.deep_fetch :a, :b
#=> {:c=>3, :d=>4}
p hash.deep_fetch :a, :b, :e
#=> nil
p hash.deep_fetch :a, :b, :e, :f
#=> nil

回答5:

If it\'s rails, use

params.try(:[], :company).try(:[], :owner).try(:[], :name)

Oh wait, that\'s even uglier. ;-)

回答6:

If you wanna get into monkeypatching you could do something like this

class NilClass
  def [](anything)
    nil
  end
end

Then a call to params[:company][:owner][:name] will yield nil if at any point one of the nested hashes is nil.

EDIT: If you want a safer route that also provides clean code you could do something like

class Hash
  def chain(*args)
    x = 0
    current = self[args[x]]
    while current && x < args.size - 1
      x += 1
      current = current[args[x]]
    end
    current
  end
end

The code would look like this: params.chain(:company, :owner, :name)

回答7:

You may want to look into one of the ways to add auto-vivification to ruby hashes. There are a number of approaches mentioned in the following stackoverflow threads:

• Ruby Autovivification
• ruby hash autovivification (facets)

回答8:

I would write this as:

name = params[:company] && params[:company][:owner] && params[:company][:owner][:name]

It\'s not as clean as the ? operator in Io, but Ruby doesn\'t have that. The answer by @ThiagoSilveira is also good, though it will be slower.

回答9:

Are you able to avoid using a multi-dimensional hash, and use

params[[:company, :owner, :name]]

or

params[[:company, :owner, :name]] if params.has_key?([:company, :owner, :name])

instead?

回答10:

Write the ugliness once, then hide it

def check_all_present(hash, keys)
  current_hash = hash
  keys.each do |key|
    return false unless current_hash[key]
    current_hash = current_hash[key]
  end
  true
end

回答11:

(Even though it\'s a really old question maybe this answer will be useful for some stackoverflow people like me that did not think of the \"begin rescue\" control structure expression.)

I would do it with a try catch statement (begin rescue in ruby language):

begin
    name = params[:company][:owner][:name]
rescue
    #if it raises errors maybe:
    name = \'John Doe\'
end

回答12:

Do:

params.fetch(\'company\', {}).fetch(\'owner\', {})[\'name\']

Also at each step, you can use an appropriate method built in NilClass to escape from nil, if it were array, string, or numeric. Just add to_hash to the inventory of this list and use it.

class NilClass; def to_hash; {} end end
params[\'company\'].to_hash[\'owner\'].to_hash[\'name\']

回答13:

You don\'t need access to the original hash definition -- you can override the [] method on the fly after you get it using h.instance_eval, e.g.

h = {1 => \'one\'}
h.instance_eval %q{
  alias :brackets :[]
  def [] key
    if self.has_key? key
      return self.brackets(key)
    else
      h = Hash.new
      h.default = {}
      return h
    end
  end
}

But that\'s not going to help you with the code you have, because you\'re relying on an unfound value to return a false value (e.g., nil) and if you do any of the \"normal\" auto-vivification stuff linked to above you\'re going to end up with an empty hash for unfound values, which evaluates as \"true\".

You could do something like this -- it only checks for defined values and returns them. You can\'t set them this way, because we\'ve got no way of knowing if the call is on the LHS of an assignment.

module AVHash
  def deep(*args)
    first = args.shift
    if args.size == 0
      return self[first]
    else
      if self.has_key? first and self[first].is_a? Hash
        self[first].send(:extend, AVHash)
        return self[first].deep(*args)
      else
        return nil
      end
    end
  end
end      

h = {1=>2, 3=>{4=>5, 6=>{7=>8}}}
h.send(:extend, AVHash)
h.deep(0) #=> nil
h.deep(1) #=> 2
h.deep(3) #=> {4=>5, 6=>{7=>8}}
h.deep(3,4) #=> 5
h.deep(3,10) #=> nil
h.deep(3,6,7) #=> 8

Again, though, you can only check values with it -- not assign them. So it\'s not real auto-vivification as we all know and love it in Perl.

回答14:

require \'xkeys\' # on rubygems.org

params.extend XKeys::Hash # No problem that we got params from somebody else!
name = params[:company, :owner, :name] # or maybe...
name = params[:company, :owner, :name, :else => \'Unknown\']
# Note: never any side effects for looking

# But you can assign too...
params[:company, :reviewed] = true

回答15:

Dangerous but works:

class Object
        def h_try(key)
            self[key] if self.respond_to?(\'[]\')
        end    
end

We can new do

   user = { 
     :first_name => \'My First Name\', 
     :last_name => \'my Last Name\', 
     :details => { 
        :age => 3, 
        :birthday => \'June 1, 2017\' 
      } 
   }

   user.h_try(:first_name) # \'My First Name\'
   user.h_try(:something) # nil
   user.h_try(:details).h_try(:age) # 3
   user.h_try(:details).h_try(:nothing).h_try(:doesnt_exist) #nil

The \"h_try\" chain follows similar style to a \"try\" chain.

回答16:

TLDR; params&.dig(:company, :owner, :name)

As of Ruby 2.3.0:

You can also use &. called the \"safe navigation operator\" as: params&.[](:company)&.[](:owner)&.[](:name). This one is perfectly safe.

Using dig on params is not actually safe as params.dig will fail if params is nil.

However you may combine the two as: params&.dig(:company, :owner, :name).

So either of the following is safe to use:

params&.[](:company)&.[](:owner)&.[](:name)

params&.dig(:company, :owner, :name)