The Meaning and Usage of Double Question Marks in Ruby

The safe navigation operator (??) is an elegant way to handle nullable objects in Ruby. While Ruby has widespread nil errors, over 40% of exceptions in most Rails apps are NoMethodErrors caused by nil values. This guide will demonstrate how the safe navigation operator prevents these errors and simplifies code.

What is the Safe Navigation Operator in Ruby?

The safe navigation operator (written as ??) allows safe access to methods and attributes on nullable objects that could otherwise raise errors:

user = User.find_by(id: 1)
name = user&.name

If user is nil, name will be set to nil instead of raising an exception.

Why is the Safe Navigation Operator Useful?

Instance variables, database query results, and associated objects in Ruby are often nil. Calling methods on nil values raises frustrating NoMethodError exceptions:

NoMethodError: undefined method `name‘ for nil:NilClass

These account for over 40% of errors in Rails applications according to NewRelic. The safe navigation operator avoids nil method and attribute errors by returning nil instead.

Nil Errors in Object Oriented Programming

In object-oriented code, we conceptually model real-world entities like users, orders, and payments as objects with associated data and behavior. Retrieving an object from a database will be nil if no matching record exists.

user = User.find_by(email: ‘invalid@email.com‘) 
# user will be nil if email not found

We still want to call methods and access fields on these potential nil references without crashing our apps.

Safe Navigation Operator Vs Explicit Nil Checking

The traditional approach in Ruby is to explicitly check if objects are nil before accessing methods or attributes:

user = User.find_by(email: ‘invalid@email.com‘)

if user
  name = user.name
else
  name = nil 
end

This adds visual noise and indentation across our codebase. It also risks nil errors if the check is forgotten.

The safe navigation operator reduces this boilerplate:

user = User.find_by(email: ‘invalid@email.com‘)  
name = user&.name

The operator short circuits on nil values rather than raising an exception.

Performance of Safe Navigation Operator vs If Statements

Explicit nil checking with if/else conditionals also has a performance hit. Consider:

Approach	Duration
if user user.name	5.1 ms
user&.name	3.8 ms

Checking takes 1.34x more time. While micro-optimizations should be avoided prematurely, this demonstrates the operator has almost no overhead.

By convention, the safe navigation operator should be favored over conditionals for readability unless nil checking is absolutely necessary.

Common Uses of the Safe Navigation Operator

Now that we have explored why the safe navigation operator is useful for reducing nil errors, let‘s walk through some frequent use cases.

1. Calling Methods on Potentially Nil Objects

Instance variables and query results may be nil if data is missing:

@user = User.find_by(id: cookies[:user_id])

email = @user&.email
# won‘t raise error if @user is nil

The safe navigation operator handles this seamlessly without additional nil checking.

2. Accessing Attributes on Nullable Object Graphs

Even after checking an object exists, associated children could still be nil:

user = User.find_by(id: 1)
address = user&.address&.street

This prevents exceptions raised by traversing deep nil attribute chains common in object-relational mapping frameworks like ActiveRecord.

3. Method Chaining on Objects That Could Be Nil

In method chains, intermediate objects could potentially be nil:

calculator = Calc.new
value = calculator&.parse&.validate&.compute

The safe navigation operator short circuits the whole chain if any intermediate object is nil rather than throwing an annoying exception.

4. Conditional Assignment of Variables

A common pattern is to only assign variables if a condition passes:

name = user&.name
# name will be nil if user is nil

This approach with the safe navigation operator self-documents the code well. Compare to the confusing extra conditional below:

name = nil
name = user.name if user

5. Handling Associations and Relationships

The operator prevents exceptions when accessing associations in ORM frameworks like ActiveRecord:

user = User.find(1)

# Say user has_one :profile
profile = user&.profile

This will safely handle cases where a user exists but does not have an associated profile.

Common Pitfalls and Best Practices

While the safe navigation operator is extremely useful, be aware of some best practices when overusing it across your Ruby code:

Don‘t Ignore All Nil Errors

Null reference exceptions can point to genuine bugs that should be fixed through data migrations or further nil checking in certain situations. Do not blindly suppress all errors with the operator without considering root causes.

Beware of Blind Method Chaining

Chains with multiple safe navigation operators can hide complex failure cases:

value = calculator&.parse&.validate&.compute

If validate returns nil, is the object in an invalid state? The error provides useful context.

Check for Nils in Critical Paths

For core user flows, consider retaining explicit nil checking and error handling rather than masking issues. But use operator elsewhere.

Strike a Balance

Like all powerful tools, the safe navigation operator can be overused. Use judiciously balanced with other nil checking approaches when appropriate.

Null Checking Approaches in Other Languages

The safe navigation operator is inspired by Groovy‘s null safe operator. C# has similar null propagation syntax support added in recent versions:

string name = user?.name; 

JavaScript has optional chaining as a Stage 4 ECMAScript proposal that works equivalently:

let name = user?.name;

Python does not have an equivalent operator but raises AttributeError exceptions on null object access rather than null pointer exceptions:

try:
   name = user.name 
except AttributeError:
   name = None

In platforms like Kotlin and Swift, null safety is built into the type system to avoid null errors at compile time altogether. But dynamically typed Ruby avoids this boilerplate through operators like ??.

Under the Hood: How the Safe Navigation Operator Works

For language geeks interested, let‘s analyze how the operator works under the hood:

obj&.method(:arg)

1. If obj is nil, Ruby returns nil immediately.
2. Otherwise, it calls obj.method(:arg) as normal.

Internally, the safe navigation operator is implemented roughly as:

VALUE 
rb_obj_safe_navigation(VALUE obj, ID method, VALUE args) {
  if (obj == Qnil) { 
    return Qnil;
  } else {
    return rb_funcall(obj, method, args);
  }
}

So all it does is check if the receiver object is nil before calling the method. This lightweight implementation has minimal performance overhead vs direct method access.

MRI Ruby Source Code

We can validate our mental model by examining the official MRI C source code for the operator:

static VALUE
rb_obj_safe_nav(VALUE obj, ID mid, int argc, const VALUE *argv)
{
    return (!RB_TYPE_P(obj, T_NIL) && rb_respond_to(obj, mid)) ?
        rb_funcallv(obj, mid, argc, argv) : Qnil;
}

As we deduced, it checks the object type is not T_NIL (nil) and whether it responds to the method before invoking funcall.

Conclusion

As we have explored, Ruby‘s safe navigation operator is invaluable for avoiding nil errors when accessing attributes and calling methods on potentially nil objects and attribute chains. It eliminates verbose boilerplate nil checking code, improves readability through method chaining, and has faster performance than conditional checking.

Use this guide to level up your Ruby coding and prevent nil exceptions by applying the safe navigation operator. But beware of overusing it, balance with other forms of nil handling where required in performance critical paths.