Dealing with many [...] in Ruby

Question

In a pure ruby script I have this:

result = JSON.parse result.body_str
count = result && result["ke1"] && result["ke1"]["key2"] && result["ke1"]["key2"]["key3"] && result["ke1"]["key2"]["key3"]["key4"] ? 
        result["key1"]["key2"]["key3"]["key4"].to_i : 
        123

Is there any way to simplify this?

Answer 1

count = result["key1"]["key2"]["key3"]["key4"].to_i rescue 123

if you want to make a private method for better readability, you could do

def count(result)
  result["key1"]["key2"]["key3"]["key4"].to_i 
rescue NoMethodError
  123
end

I add the NoMethodError to limit the errors that the rescue can swallow. Despite arguments about using exceptions for flow control, I prefer this for readability. In a small function or one liner, it technically doesn't even change the flow, as it all remains contained in one location.

If it is used inside a tight loop with millions of records, you may want to compare with other solutions using a profiler, but you have to make that call based on the actual usage. If this is used on a bit of code that may run 5 times a day, stick with what's easier to read and maintain.

Answer 2

I would write it like this, and put it in a module to be included as required.

Code

def value_at_deep_key(hash, path)
  path.each_with_index.reduce(hash) do |current, (segment, i) |
    case c = current[segment]
    when Hash then c
    else (i==path.size-1) ? (current.key?(segment) ? c : :NO_MATCH) : {}
    end
  end      
end

Examples

value_at_deep_key({a: {b: {c: "cat"}}}, [:a, :b, :c]) #=> "cat"
value_at_deep_key({a: {b: {c: false}}}, [:a, :b, :c]) #=> false
value_at_deep_key({a: {b: {c: nil}}},   [:a, :b, :c]) #=> nil
value_at_deep_key({z: {b: {c: "cat"}}}, [:a, :b, :c]) #=> :NO_MATCH
value_at_deep_key({a: {z: {c: "cat"}}}, [:a, :b, :c]) #=> :NO_MATCH
value_at_deep_key({a: {b: {z: "cat"}}}, [:a, :b, :c]) #=> :NO_MATCH
value_at_deep_key({a: {b: {c: "cat"}}}, [:a, :b])     #=> {:c=>"cat"}
value_at_deep_key({a: {b: {c: "cat"}}}, [:a])         #=> {:b=>{:c=>"cat"}}
value_at_deep_key({z: {b: {c: "cat"}}}, [])           #=> {:z=>{:b=>{:c=>"cat"}}}
value_at_deep_key({z: {b: {c: "cat"}}}, [:a, :b, :c]) #=> :NO_MATCH
value_at_deep_key({a: {z: {c: "cat"}}}, [:a, :b, :c]) #=> :NO_MATCH
value_at_deep_key({a: {b: {z: "cat"}}}, [:a, :b, :c]) #=> :NO_MATCH
value_at_deep_key({a: {z: {c: "cat"}}}, [:a, :b, :c, :d]) #=> :NO_MATCH

One could then write:

val = value_at_deep_key(hash, path)
(val = 123) if (val == :NO_MATCH)

If the value for the last key could not be nil,

else (i==path.size-1) ? (current.key?(segment) ? c : :NO_MATCH) : {}

could be replaced with:

else (i==path.size-1) ? c : {}

in which case nil would be returned when there is no match.

Answer 3

I occasionally define a method like this

def value_at_deep_key hash, path, default=nil
  path.inject(hash) {|current,segment| current && current[segment]} || default
end

This uses inject to grab each level of the hash in turn. You would use like this

value_at_deep_key(result, %w(key1 key2 key3 key4), 123)

Personally I don't like the use of rescue for this sort of thing - it can mask errors.

Answer 4

The accepted answer doesn't work very well:

Here is the code:

def value_at_deep_key(hash, path, default=nil)
  path.inject(hash) {|current,segment| current && current[segment]} || default
end

Here are some results:

1)--------------------

h = {
  'key1' => {'key2' => {'key3' => {'key4' => 3}}}
}

p value_at_deep_key(h, %w[key1 key2 key3 key4], 123)

--output:--
3

2)--------------------

h = {
  'key1' => 1,
  'key2' => 2,
  'key3' => 3,
  'key4' => 4,
}

p value_at_deep_key(h, %w[key1 key2 key3 key4], 123)

--output:--
1.rb:16:in `[]': no implicit conversion of String into Integer (TypeError)
    from 1.rb:16:in `block in value_at_deep_key'
    from 1.rb:16:in `each'
    from 1.rb:16:in `inject'
    from 1.rb:16:in `value_at_deep_key'
    from 1.rb:19:in `<main>'

3)---------------------

h = {
  'key1' => {'key2' => {'key3' => 4}}
}

p value_at_deep_key(h, %w[key1 key2 key3 key4], 123)

--output:--
1.rb:16:in `[]': no implicit conversion of String into Integer (TypeError)

The following answer seems to work better:

def value_at_deep_key(hash, key_sequence, default=nil)
  return "No keys to lookup!" if key_sequence.empty?

  value = hash

  key_sequence.each do |key|
    case value
    when Hash
      value = value[key]
    else
      value = nil
      break
    end
  end

  value.nil? ? default : Integer(value)   #A found value of nil produces the default, which is
                                          #also the case when one of the keys doesn't exist in the Hash.
                                          #Because to_i() will silently convert a found string with no leading numbers to 0, 
                                          #use Integer() instead, which will throw a descriptive error when trying to convert any String(or Hash or Array) to an int.

end

--output:--
p value_at_deep_key({a: {b: {c: "cat"}}}, [:a, :b, :c], 123)  #=> `Integer': invalid value for Integer(): "cat" (ArgumentError)
p value_at_deep_key({a: {b: {c: false}}}, [:a, :b, :c], 123)  #=> `Integer': can't convert false into Integer (TypeError)
p value_at_deep_key({a: {b: {c: nil}}},   [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({z: {b: {c: "cat"}}}, [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({a: {z: {c: "cat"}}}, [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({a: {b: {z: "cat"}}}, [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({a: {b: {c: "cat"}}}, [:a, :b], 123)      #=> `Integer': can't convert Hash into Integer (TypeError
p value_at_deep_key({a: {b: {c: "cat"}}}, [:a], 123)          #=> `Integer': can't convert Hash into Integer (TypeError)
p value_at_deep_key({z: {b: {c: "cat"}}}, [], 123)            #=> "No keys to lookup!"
p value_at_deep_key({z: {b: {c: "cat"}}}, [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({a: {z: {c: "cat"}}}, [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({a: {b: {z: "cat"}}}, [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({a: {z: {c: "cat"}}}, [:a, :b, :c, :d], 123) #=> 123


p value_at_deep_key( 
  {'key1' => {'key2' => {'key3' => {'key4' => "4"}}}},
  %w[key1 key2 key3 key4],
  default=123,
)  #=> 4

p value_at_deep_key( 
  { 'key1' => {'key2' => {'key3' => "4"}}},
  %w[key1 key2 key3 key4],
  default=123,
)  #=> 123

p value_at_deep_key( 
   {
    'key1' => "1",
    'key2' => "2",
    'key3' => "3",
    'key4' => "4",
  },
  %w[key1 key2 key3 key4],
  default=123,
)  #=> 123

p value_at_deep_key( 
  { 'key1' => {'key2' => {'key3' => {'key4' => nil}}}},
  %w[key1 key2 key3 key4],
  default=123,
)  #=> 123

p value_at_deep_key( 
  {'key1' => {'key2' => {'key3' => {'key4' => 'hello'}}}},
  %w[key1 key2 key3 key4],
  default=123,
)  #=> `Integer': invalid value for Integer(): "hello" (ArgumentError)

But maybe the following answer will suit you better:

If you must have:

1. A found String that looks like a number--converted to an int, or
2. The default

...in other words no errors, you can do this:

def value_at_deep_key(hash, key_sequence, default=nil)
  value = hash

  key_sequence.each do |key|
    case value
    when Hash
      value = value[key]
    else
      value = hash.object_id  #Some unique value to signal that the Hash lookup failed.
      break
    end
  end

  begin
    value == hash.object_id ? default : Integer(value)
  rescue TypeError, ArgumentError #If the Hash lookup succeeded, but the value is: nil, true/false, a String that is not all numbers, Array, Hash, an object that neither responds to to_int() nor to_i()
    default
  end
end

p value_at_deep_key({a: {b: {c: "cat"}}}, [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({a: {b: {c: false}}}, [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({a: {b: {c: nil}}},   [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({z: {b: {c: "cat"}}}, [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({a: {z: {c: "cat"}}}, [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({a: {b: {z: "cat"}}}, [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({a: {b: {c: "cat"}}}, [:a, :b], 123)      #=> 123
p value_at_deep_key({a: {b: {c: "cat"}}}, [:a], 123)          #=> 123
p value_at_deep_key({z: {b: {c: "cat"}}}, [], 123)            #=> 123
p value_at_deep_key({z: {b: {c: "cat"}}}, [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({a: {z: {c: "cat"}}}, [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({a: {b: {z: "cat"}}}, [:a, :b, :c], 123)  #=> 123
p value_at_deep_key({a: {z: {c: "cat"}}}, [:a, :b, :c, :d], 123) #=> 123


p value_at_deep_key( 
  {'key1' => {'key2' => {'key3' => {'key4' => "4"}}}},
  %w[key1 key2 key3 key4],
  default=123,
)  #=> 4

p value_at_deep_key( 
  { 'key1' => {'key2' => {'key3' => "4"}}},
  %w[key1 key2 key3 key4],
  default=123,
)  #=> 123

p value_at_deep_key( 
   {
    'key1' => "1",
    'key2' => "2",
    'key3' => "3",
    'key4' => "4",
  },
  %w[key1 key2 key3 key4],
  default=123,
)  #=> 123

p value_at_deep_key( 
  { 'key1' => {'key2' => {'key3' => {'key4' => nil}}}},
  %w[key1 key2 key3 key4],
  default=123,
)  #=> 123

p value_at_deep_key( 
  {'key1' => {'key2' => {'key3' => {'key4' => [1, 2, 3] }}}},
  %w[key1 key2 key3 key4],
  default=123,
)  #=> 123