Ruby Quick Reference
This reference distills the syntax and idioms covered across the rest of the course into a single scannable page. It's meant for the moment mid-project when you remember a method exists but not its exact name or signature — a companion to the deeper topic pages rather than a replacement for them. Keep it open in a second tab while working through exercises.
Cricket analogy: This reference is like a pocket-sized fielding cheat sheet a captain glances at mid-match to recall a rule, not a full coaching manual — meant to sit beside the field while the deeper strategy sessions happen elsewhere.
Core syntax at a glance
Ruby has no statement terminators, uses end to close blocks (or { } for one-liners), and treats almost everything as an expression that returns a value, including if/case. Method names ending in ? conventionally return a boolean (empty?, nil?), and method names ending in ! conventionally mutate the receiver or raise on failure (sort!, save!). Parentheses on method calls are usually optional but recommended when arguments could be ambiguous.
Cricket analogy: Ruby ending method names with ? for booleans (empty?) is like a scorer's shorthand notation asking 'is he out?', while ! methods that mutate or raise (sort!) are like a bold declaration such as 'retired hurt!' signaling a forceful state change.
# Variables & types
name = "Ada" # String
age = 32 # Integer
height = 1.7 # Float
active = true # true/false
nothing = nil # absence of value
tags = [:ruby, :rails] # Array of Symbols
person = { name: "Ada", age: 32 } # Hash with symbol keys
# Control flow
if age >= 18
puts "adult"
elsif age >= 13
puts "teen"
else
puts "child"
end
grade = case score
when 90..100 then "A"
when 80...90 then "B"
else "F"
end
# Loops & iteration
3.times { |i| puts i }
(1..5).each { |n| puts n * n }
tags.map(&:to_s) # ["ruby", "rails"]
tags.select { |t| t == :ruby } # [:ruby]
[1, 2, 3].reduce(:+) # => 6
# Methods
def greet(name, greeting: "Hello")
"#{greeting}, #{name}!"
end
greet("Ada") # => "Hello, Ada!"
greet("Ada", greeting: "Hi") # => "Hi, Ada!"
# Classes
class Person
attr_accessor :name, :age
def initialize(name, age)
@name, @age = name, age
end
def to_s
"#{name} (#{age})"
end
endFrequently used Enumerable methods
map transforms each element and returns a new array of the same length. select (alias filter) keeps elements matching a condition; reject keeps elements that don't. find (alias detect) returns the first matching element or nil. reduce/inject folds a collection into a single value using an accumulator. sort_by orders elements by a computed key, which is usually clearer than a manual sort { |a, b| ... } comparator block. group_by partitions elements into a hash keyed by the block's return value, and tally counts occurrences of each unique element in one call.
Cricket analogy: map transforms every ball into a run tally, select keeps only the boundaries, reduce totals the whole innings score, sort_by orders batters by average, group_by partitions players by role, and tally counts how many times each shot type was played.
String and hash idioms
String interpolation ("#{expr}") is preferred over concatenation for readability. .strip, .downcase, .split, and .gsub cover most text-cleaning needs. For hashes, .fetch(key, default) is safer than [] because it raises (or falls back to a default) on a missing key instead of silently returning nil, and .each_with_object({}) is a common pattern for building up a new hash while iterating.
Cricket analogy: String interpolation like "#{runs} runs" reads cleaner than concatenation for a live commentary feed, while .fetch(key, default) on a stats hash is like an analyst safely defaulting to zero instead of crashing when a rookie has no recorded average yet.
Unlike JavaScript's Array.prototype.reduce, which requires the initial value as the second argument, Ruby's reduce/inject can take a symbol shorthand like numbers.reduce(:+) for common operators, which is more concise but only works when no per-element transformation is needed.
sort mutates nothing but allocates a new array every call — calling it inside a hot loop on a large collection is a common performance mistake. Sort once, outside the loop, or use sort! deliberately when you own the array and want to sort it in place.
?-suffixed methods return booleans;!-suffixed methods mutate the receiver or raise on failure.case/whensupports ranges (90..100) and is a cleaner alternative to longif/elsifchains.map,select,reject,find,reduce,sort_by,group_by, andtallycover most collection transformations.Hash#fetch(key, default)is safer than[]because it avoids silently returningnilfor missing keys.- String interpolation (
"#{}") is idiomatic and generally preferred over+concatenation. - Avoid calling
sortrepeatedly inside loops — sort once and reuse the result.
Practice what you learned
1. What does a method name ending in `!` conventionally signal in Ruby?
2. Which Enumerable method returns the first element matching a condition?
3. Why is `Hash#fetch(key, default)` often safer than `hash[key]`?
4. What does `numbers.reduce(:+)` compute?
5. What is a good practice regarding `sort` inside loops?
Was this page helpful?
You May Also Like
Enumerable Deep Dive
Go beyond map and select to explore Enumerable's full toolkit — sort_by, group_by, partition, each_with_object, lazy enumerators, and more — for expressive collection processing.
each, map, and select
Master the three most commonly used Enumerable methods — each for side effects, map for transformation, and select for filtering — and when to reach for which.
Common Ruby Pitfalls
A tour of frequent Ruby mistakes — mutable defaults, frozen string surprises, nil handling, and block/proc return semantics — with fixes for each.
Hashes in Ruby
How Ruby's Hash class stores key-value pairs, including modern literal syntax, symbol keys, default values, and the Enumerable methods it inherits.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics