Overview

Assignment operators in Ruby provide mechanisms for binding values to variables and modifying existing variable values through compound operations. Ruby implements several categories of assignment operators: basic assignment (=), compound assignment operators (+=, -=, *=, /=, %=, **=), logical assignment operators (||=, &&=), and bitwise assignment operators (&=, |=, ^=, <<=, >>=).

The basic assignment operator creates or updates variable bindings, while compound operators combine arithmetic or logical operations with assignment in a single expression. Logical assignment operators provide conditional assignment based on truthiness evaluation, and bitwise operators perform bit-level operations before assignment.

# Basic assignment
name = "Ruby"
count = 42

# Compound assignment
count += 10  # equivalent to count = count + 10

# Logical assignment
result ||= expensive_computation()  # assigns only if result is falsy

Assignment operators in Ruby exhibit specific precedence rules and evaluation patterns. The assignment operators have right-to-left associativity and lower precedence than most other operators, allowing complex expressions on the right side to evaluate fully before assignment occurs.

# Multiple assignment with precedence
a = b = c = 5 + 3  # evaluates 5 + 3 first, then assigns 8 to c, b, then a

# Compound assignment with method calls
hash[:key] += calculate_value()  # calls calculate_value() and adds to existing hash[:key]

Basic Usage

Basic assignment uses the = operator to bind values to variables, instance variables, class variables, constants, and accessor methods. Ruby performs assignment by evaluating the right-hand expression completely before binding the result to the left-hand target.

# Variable assignment
local_var = "hello"
@instance_var = 42
@@class_var = [1, 2, 3]
CONSTANT = "immutable"

# Method assignment (calls setter method)
obj.name = "Ruby"  # equivalent to obj.name=("Ruby")

Compound assignment operators combine arithmetic operations with assignment, modifying the existing value and reassigning the result. Each compound operator corresponds to a specific arithmetic or string operation.

# Arithmetic compound assignment
counter = 10
counter += 5   # counter becomes 15
counter -= 3   # counter becomes 12
counter *= 2   # counter becomes 24
counter /= 4   # counter becomes 6
counter %= 4   # counter becomes 2
counter **= 3  # counter becomes 8

# String compound assignment
message = "Hello"
message += " World"  # message becomes "Hello World"

# Array compound assignment
numbers = [1, 2, 3]
numbers += [4, 5]    # numbers becomes [1, 2, 3, 4, 5]
numbers -= [2, 4]    # numbers becomes [1, 3, 5]

Logical assignment operators perform conditional assignment based on the truthiness of the current value. The ||= operator assigns only when the current value is falsy (nil or false), while &&= assigns only when the current value is truthy.

# Logical OR assignment - assigns if current value is falsy
username ||= "anonymous"  # assigns "anonymous" if username is nil or false
cache ||= {}             # initializes empty hash if cache is falsy

# Logical AND assignment - assigns if current value is truthy
admin_user &&= load_admin_permissions()  # loads permissions only if admin_user exists

Multiple assignment allows assigning multiple variables simultaneously using comma-separated targets and values. Ruby supports parallel assignment, array decomposition, and splat operators in assignment contexts.

# Parallel assignment
a, b = 1, 2           # a becomes 1, b becomes 2
x, y = y, x           # swaps values of x and y

# Array decomposition
first, second, third = [10, 20, 30, 40]  # third becomes 30, 40 is ignored
head, *tail = [1, 2, 3, 4, 5]           # head is 1, tail is [2, 3, 4, 5]

# Nested assignment
(a, b), c = [[1, 2], 3]  # a becomes 1, b becomes 2, c becomes 3

Advanced Usage

Assignment operators integrate with Ruby's method resolution and metaprogramming capabilities, enabling sophisticated patterns for object initialization, caching, and dynamic behavior modification. Advanced assignment patterns involve method chaining, conditional initialization, and complex data structure manipulation.

class ConfigManager
  def initialize
    @settings = {}
    @cache = {}
  end
  
  def get_setting(key)
    @cache[key] ||= begin
      # Complex computation with multiple fallbacks
      @settings[key] || 
      load_from_file(key) || 
      fetch_from_remote(key) || 
      default_value(key)
    end
  end
  
  def update_setting(key, value)
    # Compound assignment with validation
    @settings[key] &&= validate_and_transform(value)
    invalidate_cache(key) if @settings[key]
  end
  
  private
  
  def load_from_file(key)
    # Simulated file loading
    nil
  end
  
  def fetch_from_remote(key)
    # Simulated remote fetch
    nil
  end
  
  def default_value(key)
    "default_#{key}"
  end
  
  def validate_and_transform(value)
    value.to_s.upcase if value.respond_to?(:to_s)
  end
  
  def invalidate_cache(key)
    @cache.delete(key)
  end
end

Bitwise assignment operators perform bit-level operations before assignment, supporting low-level programming and flag manipulation. These operators work with integer values and modify bits according to specific logical operations.

# Bitwise assignment operations
flags = 0b1010  # binary 10 (decimal 10)

flags |= 0b0100   # OR assignment: flags becomes 0b1110 (14)
flags &= 0b1100   # AND assignment: flags becomes 0b1100 (12) 
flags ^= 0b1001   # XOR assignment: flags becomes 0b0101 (5)
flags <<= 2       # Left shift: flags becomes 0b010100 (20)
flags >>= 1       # Right shift: flags becomes 0b1010 (10)

# Flag manipulation pattern
class PermissionManager
  READ    = 0b001
  WRITE   = 0b010  
  EXECUTE = 0b100
  
  def initialize
    @permissions = 0
  end
  
  def grant_permission(permission)
    @permissions |= permission
  end
  
  def revoke_permission(permission) 
    @permissions &= ~permission
  end
  
  def toggle_permission(permission)
    @permissions ^= permission
  end
  
  def has_permission?(permission)
    (@permissions & permission) == permission
  end
end

pm = PermissionManager.new
pm.grant_permission(PermissionManager::READ | PermissionManager::WRITE)
puts pm.has_permission?(PermissionManager::READ)   # true
puts pm.has_permission?(PermissionManager::EXECUTE) # false

Assignment operators support method chaining and fluent interface patterns through careful return value management and operator precedence understanding. Complex assignment chains require consideration of evaluation order and side effects.

class FluentBuilder
  def initialize
    @config = {}
    @validators = []
  end
  
  def set(key, value)
    @config[key] = value
    self
  end
  
  def increment(key, amount = 1)
    @config[key] ||= 0
    @config[key] += amount
    self
  end
  
  def add_validator(&block)
    @validators << block if block
    self
  end
  
  def build
    # Apply all validators with compound assignment
    @validators.each do |validator|
      @config &&= validator.call(@config) ? @config : nil
    end
    @config
  end
end

builder = FluentBuilder.new
result = builder
  .set(:name, "Ruby")
  .increment(:version, 3)
  .increment(:version, 1)  # version becomes 4
  .add_validator { |config| config[:name].length > 2 }
  .add_validator { |config| config[:version] > 0 }
  .build

puts result  # {:name=>"Ruby", :version=>4}

Performance & Memory

Assignment operations in Ruby involve different performance characteristics depending on the operator type, target object complexity, and value being assigned. Basic assignment operations are highly optimized, but compound assignments may create intermediate objects and trigger additional method calls.

require 'benchmark'

# Performance comparison of assignment patterns
def benchmark_assignments(iterations)
  Benchmark.bm(25) do |x|
    # Basic assignment baseline
    x.report("basic assignment:") do
      iterations.times do |i|
        value = i * 2
      end
    end
    
    # Compound assignment
    x.report("compound assignment:") do
      total = 0
      iterations.times do |i|
        total += i
      end
    end
    
    # Logical OR assignment with hit
    x.report("||= with existing value:") do
      cache = "existing"
      iterations.times do
        cache ||= "new value"
      end
    end
    
    # Logical OR assignment with miss
    x.report("||= with nil value:") do
      iterations.times do
        cache = nil
        cache ||= "new value"
      end
    end
  end
end

benchmark_assignments(1_000_000)

String compound assignment creates new string objects rather than modifying existing strings in place, leading to memory allocation and potential performance issues with large strings or frequent operations.

# Memory-inefficient pattern
def build_large_string_bad(parts)
  result = ""
  parts.each do |part|
    result += part  # Creates new string object each time
  end
  result
end

# Memory-efficient alternative using array join
def build_large_string_good(parts)
  parts.join("")  # Single string allocation
end

# Benchmark string building approaches
parts = Array.new(10_000) { |i| "part_#{i}" }

Benchmark.bm(20) do |x|
  x.report("string +=:") do
    build_large_string_bad(parts)
  end
  
  x.report("array join:") do  
    build_large_string_good(parts)
  end
  
  x.report("string << (modify):") do
    result = ""
    parts.each { |part| result << part }
    result
  end
end

Hash and array compound assignment operations involve key lookup and potential memory reallocation, with performance implications for large collections and complex key types.

# Hash assignment performance considerations
large_hash = {}
keys = (1..100_000).to_a.sample(10_000)

Benchmark.bm(20) do |x|
  x.report("hash basic assign:") do
    keys.each { |key| large_hash[key] = rand }
  end
  
  large_hash.clear
  
  x.report("hash ||= assign:") do
    keys.each { |key| large_hash[key] ||= rand }
  end
  
  large_hash.clear
  
  x.report("hash += array:") do
    keys.each { |key| large_hash[key] = (large_hash[key] || []) + [rand] }
  end
  
  large_hash.clear
  
  x.report("hash << modify:") do
    keys.each { |key| (large_hash[key] ||= []) << rand }
  end
end

Logical assignment operators can prevent expensive computations through short-circuit evaluation, providing significant performance benefits when the assigned value involves costly operations.

class ExpensiveComputation
  def self.calculate(input)
    # Simulated expensive operation
    sleep(0.1)
    input * 2
  end
end

# Performance comparison with memoization
class Calculator
  def initialize
    @cache = {}
  end
  
  def compute_with_check(input)
    # Always performs computation
    @cache[input] = ExpensiveComputation.calculate(input)
  end
  
  def compute_with_logical_assignment(input)
    # Only computes if not cached
    @cache[input] ||= ExpensiveComputation.calculate(input)
  end
end

calc = Calculator.new
input = 42

Benchmark.bm(25) do |x|
  x.report("without memoization:") do
    5.times { calc.compute_with_check(input) }
  end
  
  calc = Calculator.new  # Reset cache
  
  x.report("with ||= memoization:") do
    5.times { calc.compute_with_logical_assignment(input) }
  end
end

Common Pitfalls

Logical assignment operators exhibit unexpected behavior when dealing with boolean false values versus nil values, leading to incorrect assumptions about when assignment occurs. The ||= operator assigns when the current value is falsy (nil or false), not just when it's undefined.

# Dangerous assumption about ||= behavior
class UserPreferences  
  def initialize
    @email_notifications = false  # Explicitly set to false
    @theme = nil
  end
  
  def email_notifications
    # This will incorrectly reassign false to true!
    @email_notifications ||= true
  end
  
  def theme
    # This works as expected since nil is falsy
    @theme ||= "default"
  end
  
  # Correct approach for boolean values
  def email_notifications_correct
    return @email_notifications unless @email_notifications.nil?
    @email_notifications = true
  end
end

prefs = UserPreferences.new
puts prefs.email_notifications  # true (incorrect - should remain false)
puts prefs.theme               # "default" (correct)

Compound assignment operators with method calls can produce unexpected results when the method has side effects or when the target method doesn't exist, leading to NoMethodError exceptions or unintended behavior.

class Counter
  attr_reader :value
  
  def initialize
    @value = 0
  end
  
  # Getter method
  def count
    puts "Getting count: #{@value}"
    @value
  end
  
  # Setter method with side effects
  def count=(new_value)
    puts "Setting count to: #{new_value}"
    @value = new_value
    log_change(new_value)
  end
  
  private
  
  def log_change(value)
    puts "Count changed to #{value}"
  end
end

counter = Counter.new
# This calls both count() and count=() methods
counter.count += 5
# Output:
# Getting count: 0
# Setting count to: 5
# Count changed to 5

# Pitfall: Assuming compound assignment is atomic
# If count() method has side effects, they occur even for simple increment

Array compound assignment with subtraction (-=) removes all occurrences of matching elements, not just the first occurrence, which can lead to unintended data loss.

# Unexpected behavior with array subtraction
shopping_list = ["apples", "bread", "apples", "milk", "apples"]

# Intending to remove one apple, but removes all apples
shopping_list -= ["apples"]
puts shopping_list  # ["bread", "milk"] - all apples removed!

# Correct approach to remove single item
shopping_list = ["apples", "bread", "apples", "milk", "apples"]
index = shopping_list.index("apples")
shopping_list.delete_at(index) if index
puts shopping_list  # ["bread", "apples", "milk", "apples"] - only first removed

# Alternative using slice assignment
shopping_list = ["apples", "bread", "apples", "milk", "apples"]
shopping_list.slice!(shopping_list.index("apples"))
puts shopping_list  # ["bread", "apples", "milk", "apples"]

Assignment operator precedence can cause unexpected evaluation order in complex expressions, particularly when mixing assignment with other operators or method calls.

# Precedence pitfall with assignment and other operators
a = 1
b = 2

# This might look like it assigns (a + b) to c, but assignment has lowest precedence
c = a + b * 2  # c gets 5, not 6 (b * 2 evaluated first)

# Compound assignment precedence issues
hash = { x: 10 }
key = :x

# This works as expected
hash[key] += 5  # hash[:x] becomes 15

# But this can be confusing
result = hash[key] += 5  # result is 20, hash[:x] is 20

# Method call with assignment precedence
class Calculator
  def self.add(a, b)
    puts "Adding #{a} + #{b}"
    a + b
  end
end

x = 3
# Assignment happens after method call completes
y = Calculator.add(x, x = 5)  # Prints "Adding 3 + 5", y becomes 8

# Multiple assignment with method calls can be tricky
def get_values
  puts "Called get_values"
  [1, 2, 3]
end

a = b = get_values()  # get_values called once, both a and b get [1, 2, 3]
# vs
c, d, e = get_values()  # get_values called once, c=1, d=2, e=3

Hash default values interact unexpectedly with assignment operators, particularly when the default value is a mutable object that gets shared across all keys.

# Dangerous default value sharing
hash_with_array_default = Hash.new([])

# These all modify the SAME array object
hash_with_array_default[:a] << 1
hash_with_array_default[:b] << 2  
hash_with_array_default[:c] << 3

puts hash_with_array_default[:a]  # [1, 2, 3] - unexpected!
puts hash_with_array_default[:b]  # [1, 2, 3] - all keys share same array

# Correct approach using block initialization
hash_with_unique_arrays = Hash.new { |h, k| h[k] = [] }

hash_with_unique_arrays[:a] << 1
hash_with_unique_arrays[:b] << 2
hash_with_unique_arrays[:c] << 3

puts hash_with_unique_arrays[:a]  # [1] - correct
puts hash_with_unique_arrays[:b]  # [2] - each key has unique array

# ||= with shared defaults still problematic
shared_default = []
hash = {}

hash[:key1] ||= shared_default
hash[:key2] ||= shared_default

hash[:key1] << "value1"
puts hash[:key2]  # ["value1"] - shared mutation!

# Safe approach
hash[:key1] ||= []
hash[:key2] ||= []

Reference

Basic Assignment Operators

Compound Assignment Operators

Logical Assignment Operators

Bitwise Assignment Operators

Assignment Precedence

Multiple Assignment Patterns

Error Conditions

Method Resolution for Assignment

Performance Characteristics