Overview

Ruby arrays provide multiple methods for sorting and ordering elements. The primary sorting method sort creates a new array with elements arranged in ascending order, while sort! modifies the original array in place. Ruby uses the spaceship operator <=> for default comparisons and accepts custom comparison blocks for complex sorting logic.

The sort method relies on Ruby's comparison protocol where objects implement the <=> operator. This operator returns -1, 0, or 1 based on whether the left operand is less than, equal to, or greater than the right operand. When objects don't implement <=> or comparison fails, Ruby raises an ArgumentError.

numbers = [3, 1, 4, 1, 5]
sorted = numbers.sort
# => [1, 1, 3, 4, 5]

words = ['zebra', 'apple', 'banana']
words.sort!
# => ['apple', 'banana', 'zebra']

Ruby also provides sort_by for sorting based on computed values, which evaluates a block for each element and sorts by the results. This method proves more efficient than sort with blocks when the comparison logic involves expensive computations.

people = [
  { name: 'Alice', age: 30 },
  { name: 'Bob', age: 25 },
  { name: 'Carol', age: 35 }
]

sorted_by_age = people.sort_by { |person| person[:age] }
# => [{:name=>"Bob", :age=>25}, {:name=>"Alice", :age=>30}, {:name=>"Carol", :age=>35}]

The reverse method creates a new array with elements in opposite order, while reverse! modifies the original array. These methods work independently of comparison logic and simply flip element positions.

Basic Usage

The sort method without arguments arranges elements using their natural comparison order. Ruby compares strings lexicographically, numbers numerically, and uses the <=> operator for custom objects that implement it.

# Numeric sorting
integers = [42, 7, 13, 1, 99]
integers.sort
# => [1, 7, 13, 42, 99]

# String sorting (case-sensitive)
names = ['Charlie', 'alice', 'Bob']
names.sort
# => ['Bob', 'Charlie', 'alice']

# Float sorting
prices = [19.99, 5.50, 100.00, 2.25]
prices.sort
# => [2.25, 5.50, 19.99, 100.0]

Custom sorting requires a comparison block that receives two elements and returns -1, 0, or 1. The block should return -1 when the first element should come before the second, 0 when they're equal, and 1 when the first should come after the second.

# Descending numeric order
numbers = [5, 2, 8, 1, 9]
descending = numbers.sort { |a, b| b <=> a }
# => [9, 8, 5, 2, 1]

# Case-insensitive string sorting
words = ['Banana', 'apple', 'Cherry']
case_insensitive = words.sort { |a, b| a.downcase <=> b.downcase }
# => ['apple', 'Banana', 'Cherry']

# Length-based string sorting
phrases = ['hello', 'hi', 'goodbye', 'hey']
by_length = phrases.sort { |a, b| a.length <=> b.length }
# => ['hi', 'hey', 'hello', 'goodbye']

The sort_by method accepts a block that computes a comparison key for each element. Ruby sorts elements based on these computed keys rather than the original values. This approach provides better performance when the key computation involves expensive operations.

# Sort by string length
words = ['elephant', 'cat', 'dog', 'butterfly']
by_length = words.sort_by { |word| word.length }
# => ['cat', 'dog', 'elephant', 'butterfly']

# Sort by last character
words = ['hello', 'world', 'ruby', 'code']
by_last_char = words.sort_by { |word| word[-1] }
# => ['code', 'hello', 'ruby', 'world']

# Sort by computed numeric value
dates = ['2023-12-01', '2023-01-15', '2023-06-30']
by_month = dates.sort_by { |date| Date.parse(date).month }
# => ['2023-01-15', '2023-06-30', '2023-12-01']

The destructive variants sort! and reverse! modify arrays in place and return the modified array. These methods save memory by avoiding array duplication but change the original data structure.

original = [3, 1, 4, 1, 5]
original.sort!
puts original
# => [1, 1, 3, 4, 5]

reversed = [1, 2, 3, 4, 5]
reversed.reverse!
puts reversed
# => [5, 4, 3, 2, 1]

Advanced Usage

Multi-level sorting requires comparison logic that handles multiple criteria in priority order. When the primary comparison yields equality, the comparison block evaluates secondary criteria to determine final ordering.

students = [
  { name: 'Alice', grade: 85, age: 20 },
  { name: 'Bob', grade: 85, age: 19 },
  { name: 'Carol', grade: 92, age: 21 },
  { name: 'David', grade: 78, age: 20 }
]

# Sort by grade (descending), then age (ascending)
multi_sort = students.sort do |a, b|
  grade_comparison = b[:grade] <=> a[:grade]
  if grade_comparison == 0
    a[:age] <=> b[:age]
  else
    grade_comparison
  end
end
# => [{:name=>"Carol", :grade=>92, :age=>21}, 
#     {:name=>"Bob", :grade=>85, :age=>19}, 
#     {:name=>"Alice", :grade=>85, :age=>20}, 
#     {:name=>"David", :grade=>78, :age=>20}]

Complex sorting patterns often combine multiple array methods in chains. The sort_by method works with enumerable methods like group_by and partition to create sophisticated ordering logic.

# Group by category, sort within groups, flatten
products = [
  { name: 'Laptop', category: 'Electronics', price: 999 },
  { name: 'Book', category: 'Education', price: 25 },
  { name: 'Phone', category: 'Electronics', price: 699 },
  { name: 'Notebook', category: 'Education', price: 5 }
]

grouped_sorted = products
  .group_by { |product| product[:category] }
  .map { |category, items| items.sort_by { |item| item[:price] } }
  .flatten
# => Electronics items first (sorted by price), then Education items (sorted by price)

Custom comparison objects provide reusable sorting logic through classes that implement comparison operators. These objects encapsulate complex comparison rules and maintain consistency across different sorting operations.

class PriorityComparator
  def initialize(priorities)
    @priorities = priorities
  end
  
  def compare(a, b)
    priority_a = @priorities[a] || Float::INFINITY
    priority_b = @priorities[b] || Float::INFINITY
    priority_a <=> priority_b
  end
end

tasks = ['email', 'meeting', 'code', 'lunch']
priorities = { 'meeting' => 1, 'code' => 2, 'email' => 3 }
comparator = PriorityComparator.new(priorities)

sorted_tasks = tasks.sort { |a, b| comparator.compare(a, b) }
# => ['meeting', 'code', 'email', 'lunch']

The sort_by method with complex transformations handles scenarios where sorting depends on computed or derived values. This approach separates key computation from comparison logic and improves code readability.

# Sort file paths by directory depth then filename
file_paths = [
  '/home/user/documents/file1.txt',
  '/home/user/file2.txt',
  '/home/user/documents/subfolder/file3.txt',
  '/root/file4.txt'
]

by_depth_then_name = file_paths.sort_by do |path|
  parts = path.split('/')
  [parts.length, File.basename(path)]
end
# => Sorted by directory depth first, then filename within same depth

Performance & Memory

Ruby's default sorting algorithm is stable and performs with O(n log n) time complexity in average cases. The sort method uses a hybrid approach combining quicksort and insertion sort optimizations. For large datasets, sort_by often outperforms sort with blocks because it evaluates the sort key only once per element.

# Performance comparison for expensive key computation
require 'benchmark'

large_array = (1..10000).to_a.shuffle

# Using sort with block (recomputes expensive operation)
Benchmark.measure do
  large_array.sort { |a, b| Math.sqrt(a) <=> Math.sqrt(b) }
end
# => Slower due to repeated Math.sqrt calls

# Using sort_by (computes expensive operation once per element)
Benchmark.measure do
  large_array.sort_by { |x| Math.sqrt(x) }
end
# => Faster due to single computation per element

Memory usage differs significantly between sort and sort! methods. The non-destructive sort creates a new array containing all elements, effectively doubling memory usage temporarily. The destructive sort! modifies elements in place but still requires additional memory for comparison operations.

# Memory-efficient sorting for large datasets
large_dataset = (1..1_000_000).to_a.shuffle

# Creates new array - high memory usage
sorted_copy = large_dataset.sort

# Modifies in place - lower memory usage
large_dataset.sort!

String sorting performance depends heavily on comparison operations and string length. Ruby optimizes string comparisons but complex transformations in sort blocks can create performance bottlenecks. Using sort_by with string transformations avoids repeated computation.

# Inefficient: repeated string transformations
words = ['HELLO', 'world', 'Ruby', 'PROGRAMMING']
slow_sort = words.sort { |a, b| a.downcase <=> b.downcase }

# Efficient: single transformation per element
fast_sort = words.sort_by { |word| word.downcase }

Large array sorting benefits from understanding Ruby's garbage collection behavior. Frequent sorting operations can trigger garbage collection cycles, affecting performance. Reusing arrays and using in-place operations reduces memory allocation overhead.

# Reuse arrays to minimize garbage collection
results = []
data_batches = [batch1, batch2, batch3]

data_batches.each do |batch|
  results.clear
  results.concat(batch.sort)
  # Process results
end

Common Pitfalls

Mixed-type arrays cause comparison failures when elements don't share compatible comparison methods. Ruby raises ArgumentError when attempting to compare incompatible types like strings and integers during sorting operations.

mixed_array = [1, 'hello', 3.14, 'world']

# This raises ArgumentError: comparison of String with Integer failed
begin
  mixed_array.sort
rescue ArgumentError => e
  puts "Sorting failed: #{e.message}"
end

# Solution: convert to comparable types or provide custom comparison
safe_sort = mixed_array.sort_by { |element| element.to_s }
# => ['1', '3.14', 'hello', 'world'] (string comparison)

Nil values in arrays create comparison issues because nil doesn't implement meaningful comparison operators with other types. Sorting arrays containing nil requires explicit handling through custom comparison logic.

array_with_nils = [3, nil, 1, nil, 5]

# This raises ArgumentError: comparison of NilClass with Integer failed
begin
  array_with_nils.sort
rescue ArgumentError => e
  puts "Cannot sort: #{e.message}"
end

# Solution: handle nils explicitly
sorted_with_nils = array_with_nils.sort do |a, b|
  if a.nil? && b.nil?
    0
  elsif a.nil?
    1  # nil goes to end
  elsif b.nil?
    -1 # nil goes to end
  else
    a <=> b
  end
end
# => [1, 3, 5, nil, nil]

Comparison blocks that don't return proper comparison values (-1, 0, 1) can produce inconsistent sorting results. Ruby expects comparison blocks to implement the comparison contract correctly for stable sorting behavior.

numbers = [5, 2, 8, 1, 9]

# Incorrect: returns boolean instead of comparison integer
bad_sort = numbers.sort { |a, b| a < b }  # Wrong!
# This may work sometimes but is unreliable

# Correct: returns proper comparison values
good_sort = numbers.sort { |a, b| a <=> b }
# => [1, 2, 5, 8, 9]

String case sensitivity creates unexpected sorting results when mixed-case strings don't sort in expected alphabetical order. Ruby's default string comparison is case-sensitive with uppercase letters sorting before lowercase letters.

names = ['alice', 'Bob', 'Charlie', 'david']
default_sort = names.sort
# => ['Bob', 'Charlie', 'alice', 'david'] (not alphabetical!)

# Correct: case-insensitive sorting
alphabetical_sort = names.sort { |a, b| a.downcase <=> b.downcase }
# => ['alice', 'Bob', 'Charlie', 'david']

Floating-point precision issues can affect numeric sorting when dealing with computed values or values from different sources. Small precision differences can cause unexpected ordering in sorted results.

# Precision issues with computed floats
computed_values = [0.1 + 0.2, 0.3, 0.15 + 0.15]
puts computed_values.sort
# => [0.3, 0.30000000000000004, 0.3] (unexpected ordering!)

# Solution: round or use rational numbers for exact precision
precise_sort = computed_values.sort_by { |val| val.round(10) }
# => [0.3, 0.30000000000000004, 0.3] (consistent ordering)

Reference

Core Sorting Methods

Comparison Protocol

Sort Block Return Values

Performance Characteristics

Common Sort Patterns

Error Conditions

Stability Guarantee

Ruby's sort is stable, meaning elements with equal comparison values maintain their relative order from the original array. This property ensures predictable results when sorting by multiple criteria or when equal elements have different secondary characteristics.