What is the difference between `try` and `&.` (safe navigation operator) in Ruby
Solution 1
&.
works like #try!
, not #try
.
And here is description of #try!
(from documentation):
Same as #try, but will raise a NoMethodError exception if the receiving is not nil and does not implemented the tried method.
So basically it saves you from calling a method on nil
, but if an object is presented it will try to call its method as usual.
The quote is from Rails Documentation, and so it's important to emphasize
that Ruby does not provide #try
; it's provided by Rails, or more accurately ActiveSupport. The safe navigation operator (&.
) however, is a language feature presented in Ruby 2.3.0.
Solution 2
The try
method ignores a lot of things, it just gives it a shot and calls it a day if things don't work out.
The &
conditional navigation option will only block calls on nil
objects. Anything else is considered to be valid and will proceed with full consequences, exceptions included.
Solution 3
I am arriving to the party a bit late here, the other answers have covered how it works, but I wanted to add something that the other answers have not covered.
Your question asks What is the difference between try
and &.
in Ruby. Ruby being the key word here.
The biggest difference is that try
doesn't exist in Ruby, it is a method provided by Rails. you can see this or yourself if you do something like this in the rails console:
[1, 2, 3].try(:join, '-')
#=> "1-2-3"
However if you do the same thing in the irb console, you will get:
[1, 2, 3].try(:join, '-')
NoMethodError: undefined method `try' for [1, 2, 3]:Array
The &.
is part of the Ruby standard library, and is therefore available in any Ruby project, not just Rails.
Solution 4
In addition to the above answers, I am adding some examples.1
account = Account.new(owner: Object.new)
account.try(:owner).try(:address)
# => nil
account&.owner&.address
# => NoMethodError: undefined method `address' for #<Object:0x00559996b5bde8>`
account.try!(:owner).try!(:address)
# => NoMethodError: undefined method `address' for #<Object:0x00559996b5bde8>`
As we can see, try
doesn't check if the receiver responds to the given method or not. Whereas try!
and &.
behaves the same. If the receiver responds to the address
method, all of them will return the same result. I prefer using &.
as it looks more cleaner.
For more information on The Safe Navigation Operator (&.), I have found this blog really helpful https://mitrev.net/ruby/2015/11/13/the-operator-in-ruby/
Comments
-
Adrien almost 2 years
Here is my code:
class Order < Grape::Entity expose :id { |order, options| order.id.obfuscate } expose :time_left_to_review do |order, options| byebug order&.time_left_to_review # ERROR end expose :created_at { |order, options| order.last_transition.created_at } end # NoMethodError Exception: undefined method `time_left_to_review' for #<Order:0x007f83b9efc970>
I thought
&.
is a shortcut for.try
but I guess I was wrong. May someone point me to the right direction regarding what I am missing?I feel like it's not ruby related. Grape maybe? Though I don't get how it could be.
-
mwfearnley over 4 yearsSo in case your code might be running in pure Ruby, you should do
foo.try(:try, ...)
to be on the safe side. -
gasc over 3 yearsSorry @mwfearnley but I don't understand your comment. If the code is in pure Ruby (i.e outside of Rails or not using
ActiveSupport
) then what's the point of doingfoo.try(:try...)
iffoo.try
will raise aNoMethodError
? -
mwfearnley over 3 years@gasc Looking back at my comment now, I have to conclude it was a joke, based on the fact that the advice was "obviously" bad.. Of course, if you are almost certain that
foo.try(:try...)
will fail, then you should dofoo.try(:try, :try...)
to be extra safe.. -
gasc over 3 years...and I ruined the joke =( My bad @mwfearnley
-
Jason Swett about 3 years"So basically it saves you from calling a method on nil" - what does the "it" in this sentence refer to?
-
Edward Anderson almost 3 years@Jason: "it" is the safe navigation operator or try!.
-
Ben MacLeod over 2 yearsIn pure Ruby,
foo
or!foo
, there is no#try