Understanding nil?, empty?, and blank? in Ruby and Rails

By the end of this page, you will understand what nil?, empty?, and blank? mean in Ruby and Rails, when each one returns true, and how to choose the right one in real code. You will also see examples, common mistakes, and practical patterns for validation and control flow.

nil?, empty?, and blank? sound similar, but they answer different questions.

• nil? asks: Is this object exactly nil?
• empty? asks: Does this object contain nothing?
• blank? asks: Is this value missing or effectively unusable?

nil?

In Ruby, nil is a special object that represents “no value”.

nil.nil? # => true
5.nil?   # => false
"".nil?  # => false

nil? is part of core Ruby and can be called on any object. Only nil returns true.

empty?

is also a Ruby method, but not every object has it. It is usually defined on collection-like or content-like objects such as:

Think of these three methods as three different inspections on a container.

• nil? asks: Is there no container at all?
• empty? asks: Is there a container, but nothing inside it?
• blank? asks: Is there anything meaningful here, or is it effectively nothing?

Examples:

• nil = no box exists
• [] = the box exists, but it has no items
• " " = the box contains only packing foam, not useful content

So even though nil, [], and " " are different values, Rails may treat all of them as blank? because they do not carry useful information in many app situations.

Core syntax

value.nil?
value.empty?
value.blank?   # Rails / Active Support
value.present? # opposite of blank?

Example 1: nil?

name = nil
name.nil? # => true

Use this when you only want to know whether a variable has the special nil value.

Example 2: empty?

tags = []
tags.empty? # => true

Use this when you know the object is a collection or string and you want to know whether it has zero elements or characters.

Example 3: blank?

comment = "   "
comment.blank? # => true

Use this in Rails when whitespace-only strings should count as missing input.

Side-by-side examples

nil.nil?      
.blank?    

.?       
.empty?     
.blank?     

.empty?  
.blank?  

[].empty?     
[].blank?     

.blank?  
.blank?      

Consider this example:

values = [nil, "", " ", [], [1], false, 0]

values.each do |value|
  print "Value: #{value.inspect} | "
  print "nil?: #{value.nil?} | "
  print "empty?: "

  begin
    print value.empty?
  rescue NoMethodError
    print "NoMethodError"
  end

  print " | blank?: #{value.blank?}"
  puts
end

What happens step by step

1. Ruby creates an array of different values.
2. It loops through each value one by one.
3. For each value:
   • nil? checks whether the value is exactly nil.
   • empty? is attempted. If the object does not support empty?, Ruby raises NoMethodError.
   • blank? checks whether Rails considers the value absent or meaningless.

Form input validation

In Rails forms, users often submit empty strings or spaces.

if params[:username].blank?
  errors << "Username is required"
end

Checking API input

When processing JSON or request params, a field may be missing, empty, or whitespace-only.

token = params[:token]
return render json: { error: "Missing token" }, status: 400 if token.blank?

Working with collections

When you already know a value is an array or hash, empty? is precise and readable.

return if results.empty?

Distinguishing missing from intentionally false

Sometimes false is a meaningful value, not a missing one.

enabled = params[:enabled]

if enabled.nil?
  puts "No value provided"

In real Rails applications, these methods often appear in a few common patterns.

Guard clauses

def process_name(name)
  return "Missing name" if name.blank?

  name.strip.capitalize
end

This exits early when the input is unusable.

Validation logic

validates :email, presence: true

Rails presence validation is closely related to blank?: a value fails presence validation when it is blank.

Optional association or config checks

return default_settings if config[:theme].blank?

Safer collection handling

def render_tags(tags)
  return "No tags" if tags.nil? || tags.empty?

  tags.join(", ")

Mistake 1: Calling empty? on nil

value = nil
value.empty?
# NoMethodError

Fix

Use a nil-safe check:

value.nil? || value.empty?

Or in Rails:

value.blank?

Mistake 2: Thinking empty? and blank? mean the same thing

"   ".empty?  # => false
"   ".blank?  # => true

Fix

Remember:

• empty? checks zero length
• blank? also treats whitespace-only strings as blank

Mistake 3: Using blank? in plain Ruby without Rails

# nil?
value.nil?
# true only when value is nil

# empty?
value.empty?
# true when a collection/string has size 0
# raises NoMethodError on objects like nil, false, 0

# blank? (Rails)
value.blank?
# true for nil, false, "", "   ", [], {}

# present? (Rails)
value.present?
# opposite of blank?

# presence (Rails)
value.presence
# returns value if present, otherwise nil

Quick rules

• Use nil? for exact nil checks.
• Use empty? for strings and collections when you know the object supports it.
• Use blank? in Rails for user input and general “missing value” checks.
• Be careful: false.blank? is true.
• Be careful: 0.blank? is false.
• " ".empty? is false, but " ".blank? is true.

Is blank? part of Ruby itself?

No. blank? comes from Rails' Active Support, not core Ruby.

Why does nil.empty? raise an error?

Because nil does not define an empty? method. empty? only exists on certain classes.

What is the difference between empty? and blank? for strings?

empty? is true only for "". blank? is also true for strings containing only whitespace, such as " ".

Does false.blank? return true?

Yes. In Rails, false is considered blank.

Is 0 blank in Rails?

No. 0.blank? returns false.

Should I always use in Rails?

• present? — the direct opposite of blank?, commonly used in Rails conditions.
• presence — useful for turning blank values into nil.
• truthy and falsy values in Ruby — helps explain why false and nil behave differently from other values.
• NilClass — explains what nil is internally in Ruby.
• string whitespace handling — important for understanding why " " is blank but not empty.
• Rails validations — presence: true relies on the idea of blank values.
• safe navigation operator (&.) — useful when dealing with possible nil values.
• any? and none? — related ways to check collections in Ruby.