Ruby on Rails Exceptions

Question

I am a junior rails developer and was advised to use Class.find(id) to query the database instead of Class.find_by_id(id) which I previously had. The reason I was told is because the former would raise an exception while the latter would return nil. I realize this happens but I am wondering what the high level conceptual logic is for doing it this way. Why do I want the exception? Is this a rails standard where I would always prefer a method that returns an exception as opposed to nil?

Answer 1

You typically want the exception because you're typically doing Foo.find(id) based on data input coming from the user, such as clicking on a link.

For example, you show the user a list of items. There are links like this:

http://example.com/items/100
http://example.com/items/101
http://example.com/items/102

The user clicks the first link, and expects to see item 100.

Your code does this:

 Item.find(100)

You expect to find the item, because app created the item link. You'd be surprised if the item didn't exist.

(Corner case surprises are possible: perhaps the item was deleted, or perhaps a hacker is sending in missing ids, etc. Using exceptions helps you handle this as an exceptional circumstance.)

Exceptions are preferred to nil for this, because you want the code to fail immediately so you don't accidentally send the nil on to some other method.

Ruby nil objects can be confusing because they evaluate to falsey and also because nil.id == 4 because of how Ruby uses C. Error messages show up like "Warning: Object#id will be deprecated" or "undefined method for 4:Fixnum".

Answer 2

Nils are problematic as a return type in Ruby in general. There's a great (paid) screencast by Gary Bernhardt that explains why you want to avoid returning nil from methods, but in a nutshell: when a method returns nil, and that nil gets passed up through a chain of method calls and something goes wrong somewhere, it can be extremely difficult to figure out where the actual problem occurred.

Say, for example, you have something like this:

foo_model = MyModel.find_by_name('foo')
# some more lines of code
do_something(foo_model)

and a method:

def do_something(model)
  # some stuff stuff
  some_other_method(model)
end

Now, if MyModel.find_by_name('foo') returns nil, that nil will be carried along without any errors until it actually has to do something. Say, in some_other_method, you actually try to call something on model, say model.save, you will get an error:

undefined method 'save' for nil:NilClass (NoMethodError)

The trace will carry you back up the method calls, but it will not mention the line that was actually problematic, where you assign MyModel.find_by_name('foo') (which evaluates to nil) to foo_model.

You can imagine that in a real application, the code can be much more complex, and returning nil can make it much more difficult to figure out the source of an error.

An exception, in contrast, tells you immediately where the problem is, and the trace will go back to the line where it occurred. That's one reason (there are others, I imagine) why in general, returning nil is not a good idea.

Hope that helps.