Difference between "or" and || in Ruby?

Ruby's 'or' vs. '||': Understanding Logical Operators

Explore the subtle yet significant differences between Ruby's or and || logical operators, including their precedence, short-circuiting behavior, and common use cases.

In Ruby, both or and || serve as logical OR operators, evaluating to true if either of their operands is truthy. However, they are not interchangeable. The key distinction lies in their operator precedence, which dictates how expressions are parsed and evaluated. Understanding this difference is crucial for writing correct and predictable Ruby code, especially when dealing with complex conditional statements or assignment operations.

Operator Precedence: The Core Difference

The most fundamental difference between or and || is their operator precedence. || has a much higher precedence than or. This means that in an expression containing both, || operations will be evaluated before or operations. This difference can lead to vastly different outcomes if not understood.

a = false
b = true
c = false

# Using || (higher precedence)
result_high = a || b && c # Equivalent to a || (b && c)
puts "Result with ||: #{result_high}" # Output: true (because a is false, but (b && c) is false, so false || false is false. Wait, no. a is false, b is true, c is false. b && c is false. a || (b && c) is false || false which is false. This example is wrong. Let's fix it.

# Corrected example for ||
# Let's use assignment to demonstrate precedence

# Example 1: Assignment with ||
# This assigns 'default_value' to 'x' if 'user_input' is nil or false
user_input = nil
x = user_input || "default_value"
puts "x with ||: #{x}" # Output: default_value

# Example 2: Assignment with or (lower precedence)
# This assigns 'user_input' to 'y', then evaluates 'user_input or "default_value"'
# The assignment happens first due to 'or's low precedence
user_input = nil
y = user_input or "default_value"
puts "y with or: #{y}" # Output: nil (because y = user_input is evaluated first)

# To make 'or' behave like '||' for assignment, you'd need parentheses:
z = (user_input or "default_value")
puts "z with (or): #{z}" # Output: default_value

Demonstrating precedence differences in assignment with || and or.

As seen in the example, when or is used in an assignment context without parentheses, the assignment (y = user_input) happens before the or operation. This is because the assignment operator (=) has higher precedence than or. Conversely, || has higher precedence than =, so x = user_input || "default_value" evaluates user_input || "default_value" first, then assigns the result to x.

flowchart TD
    A["Expression: `x = a || b`"]
    B["Expression: `y = a or b`"]

    subgraph High Precedence (||)
        A1["Evaluate `a || b`"]
        A2["Assign result to `x`"]
    end

    subgraph Low Precedence (or)
        B1["Assign `a` to `y`"]
        B2["Evaluate `y or b` (which is `a or b`)"]
    end

    A --> A1 --> A2
    B --> B1 --> B2

Flowchart illustrating the evaluation order for || vs. or in assignment.

Short-Circuiting Behavior

Both or and || exhibit short-circuiting behavior. This means that if the left-hand operand evaluates to a truthy value, the right-hand operand is not evaluated at all. This can be important for performance or when the right-hand operand has side effects.

def expensive_operation
  puts "Expensive operation called!"
  false
end

true || expensive_operation # "Expensive operation called!" is NOT printed
false or expensive_operation # "Expensive operation called!" IS printed (because false is not truthy, so it proceeds to evaluate expensive_operation)

# Wait, this example is also wrong. Both should short-circuit if the left is true.
# Let's correct it.

def expensive_operation_corrected
  puts "Expensive operation called!"
  false
end

puts "--- Testing || ---"
true || expensive_operation_corrected # Output: (nothing from expensive_operation_corrected)
puts "false || expensive_operation_corrected: #{false || expensive_operation_corrected}" # Output: Expensive operation called!

puts "\n--- Testing or ---"
true or expensive_operation_corrected # Output: (nothing from expensive_operation_corrected)
puts "false or expensive_operation_corrected: #{false or expensive_operation_corrected}" # Output: Expensive operation called!

Both || and or short-circuit when the left operand is truthy.

As demonstrated, both operators correctly short-circuit. The key difference remains precedence, not short-circuiting itself. The short-circuiting behavior is a characteristic of logical OR operations in Ruby, regardless of the specific operator used.

When to Use Which?

A common convention in Ruby is to use || for control flow and default value assignments, and or for boolean logic where its lower precedence might be intentionally leveraged, though this is less common and can be confusing. Generally, || is preferred for its higher precedence, which often aligns better with intuitive expectations for conditional logic and assignment.

# Preferred: Default value assignment
options = {} # Imagine this comes from user input or a method
page_size = options[:page_size] || 25 # Assigns 25 if options[:page_size] is nil or false
puts "Page size: #{page_size}"

# Preferred: Conditional logic
if user_logged_in || admin_user
  puts "Access granted!"
end

# Less common, potentially confusing use of 'or' (avoid if possible)
def process_data(data)
  return false if data.nil? or data.empty?
  # ... process data
  true
end

puts "Processing nil: #{process_data(nil)}"
puts "Processing empty: #{process_data([])}"
puts "Processing valid: #{process_data([1,2])}"

Practical examples of || for default values and or in a less common conditional.