Difference Between `and` and `&&` in Ruby

By the end of this page, you will understand that && and and both perform logical AND in Ruby, but they do not behave the same in every expression. The key difference is operator precedence: && has higher precedence, while and has lower precedence. This affects how Ruby groups expressions, especially when assignment is involved. You will also learn when each form is typically used and how to avoid subtle bugs.

In Ruby, both && and and are logical operators that return a truthy or falsy result based on two expressions.

At first glance, they seem interchangeable:

true && true   # => true
true and true  # => true

However, the important difference is precedence.

What is operator precedence?

Operator precedence determines which parts of an expression Ruby evaluates first.

• && has higher precedence
• and has lower precedence

That means Ruby binds && more tightly than and.

This matters a lot in expressions like assignment:

result = true && false
# interpreted as: result = (true && false)
# result => false

But:

result = true and false
# interpreted as: (result = true) and false
# result => true

Think of && and and as two words that mean the same thing, but with different "stickiness."

• && is tightly glued to the expressions around it
• and is loosely attached and lets other operations happen first

Imagine this expression:

result = true && false

With &&, the AND operation sticks together first, then gets assigned.

Now compare:

result = true and false

With and, the assignment happens first, and only then Ruby continues with and false.

So a useful mental model is:

• && is for building expressions
• and is for connecting statements

If you are calculating a value, prefer &&. If you are writing a flow-like sentence, may read nicely, but use it carefully.

Core syntax

left && right
left and right

Both return:

• the first falsey value they encounter, or
• the last value if all parts are truthy

Simple example

puts true && true    # true
puts true && false   # false
puts true and true   # true
puts true and false  # false

In simple boolean checks, they often appear to behave the same.

Example with assignment

This is where the difference becomes important:

a = true && false
b = true and false

puts a  # false
puts b  # true

Why?

Ruby reads these as:

a = (true && )
b =   

Consider this example:

x = true && false
y = true and false

puts x
puts y

Step-by-step for x

x = true && false

1. Ruby sees &&, which has high precedence.
2. It evaluates true && false first.
3. That result is false.
4. Ruby assigns false to x.

So:

x # => false

Step-by-step for y

y = true and false

1. Ruby sees = and and.

1. Checking multiple conditions

if user_logged_in && user.admin?
  show_admin_panel
end

This is the most common use of &&.

2. Guarding method calls

config && config[:timeout]

This avoids using the second part if config is nil or false.

3. Short control-flow statements

save(record) and puts("Saved")

This style can be readable in small scripts, but it is less common in production code for important logic.

4. Conditional task execution

file_exists && process_file

Only process the file if the first value is truthy.

5. CLI scripts and automation

In small Ruby scripts, developers sometimes write:

valid_input? and run_program

This reads like English, but is usually clearer when expressions become more complex.

In real Ruby codebases, developers usually prefer && for boolean logic because it behaves predictably in expressions.

Common patterns

Guard clauses

def publish(post)
  return unless post && post.valid?

  post.publish!
end

&& is preferred because it works well inside expressions.

Validation checks

if params[:email] && params[:password]
  create_user
end

Early returns

def find_name(user)
  return nil unless user && user.profile

  user.profile.name
end

Chaining conditions

if logged_in? && account_active? && !banned?
  allow_access
end

Where sometimes appears

1. Using and with assignment

This is the most common mistake.

Broken example

success = true and false
puts success  # true

A beginner may expect false, but success becomes true.

Better

success = true && false
puts success  # false

2. Assuming and and && are always interchangeable

Misleading example

value = condition and other_condition

This does not behave the same as:

value = condition && other_condition

Always think about precedence.

3. Writing complex expressions with and

&& vs and

Example comparison

a =  &&    
b =     

Quick rules

• && and and both mean logical AND
• Both short-circuit
• && has higher precedence
• and has lower precedence
• Prefer && in most boolean expressions
• Avoid and with assignment

Safe default

if a && b
  do_something
end

Risky pattern

result = a and b

Ruby reads it like:

(result = a) and b

Better pattern

result = a && b

Return behavior

Ruby returns actual values, not forced booleans:

"hi" && 5    # => 5
 &&       
 &&     

Is and the same as && in Ruby?

They both perform logical AND, but they are not the same in precedence. && binds more tightly than and, so expressions can produce different results.

Why does a = true and false assign true?

Because and has low precedence. Ruby evaluates the assignment first, so a becomes true, and only then evaluates and false.

Should I always use && instead of and?

For most conditions and expressions, yes. && is the safer and more common choice. Use and only when you intentionally want low-precedence control flow.

Do && and and both short-circuit?

Yes. If the left side is falsey, Ruby does not evaluate the right side.

Does && return only or ?

• Operator precedence — This is the key idea behind why && and and behave differently.
• Short-circuit evaluation — Both operators stop early when the left side is falsey.
• Truthiness and falsiness in Ruby — Understanding which values Ruby treats as true or false helps explain logical expressions.
• || vs or in Ruby — Ruby's OR operators have the same precedence distinction.
• Conditional statements in Ruby — if, unless, and guard clauses often use &&.
• Assignment in Ruby — Assignment interacts with low-precedence operators in important ways.