Accepted answer will not account for when hash is nil...

You can rewrite what you have using the safe nav operator before the .try and that will work

hash&.try(:[], :key)

but you can also use:

http://ruby-doc.org/core-2.3.0_preview1/Hash.html#method-i-dig

A way you could do this on a hash is by doing...

hash&.dig(:key1, :key2 ...)

which will return nil if any key fetch isn't present.

{ key1: { key2: 'info' } }

would return 'info'

{ key1: { wrong_key: 'info' } }

would return nil

&. is not equivalent to Rails' try, but you can use &. for hashes. Just use it, nothing special.

hash[:key1]&.[](:key2)&.[](:key3)

Although I would not do that.

Ruby 2.3 and later

There's Hash#dig method now that does just that:

Retrieves the value object corresponding to the each key objects repeatedly.

h = { foo: {bar: {baz: 1}}}


h.dig(:foo, :bar, :baz)           #=> 1
h.dig(:foo, :zot)                 #=> nil

http://ruby-doc.org/core-2.3.0_preview1/Hash.html#method-i-dig

Pre Ruby 2.3

I usually had something like this put into my intializer:

Class Hash
def deep_fetch *args
x = self
args.each do |arg|
x = x[arg]
return nil if x.nil?
end
x
end
end

and then

response.deep_fetch 'PaReqCreationResponse', 'ThreeDSecureVERes', 'Message', 'VERes', 'CH', 'enrolled'

in one wacky case.

The general consensus in the community seems to be to avoid both try and the lonely operator &.

While hash&.[](:key) is elegant to the trained rubyist, I'd just use hash && hash[:key] as it reads better and more intuitively for the programmer coming after me, who may not be as familiar with the intricacies of ruby. Some extra characters in the codebase can sometimes save a whole lot of googling for someone else.

(Given the context you want to use this in is in a conditional statement, of course.)

A rather more legible way to use the safe navigation operator than using hash&.[](:slug) is to use the fetch method:

hash&.fetch(:slug)

If your key may not be defined, you can use the second argument as a default:

hash&.fetch(:slug, nil)