Ruby Quick Reference

Analogy categoryAnalogies

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.

ruby

# 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
end

Frequently 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/when supports ranges (90..100) and is a cleaner alternative to long if/elsif chains.
map, select, reject, find, reduce, sort_by, group_by, and tally cover most collection transformations.
Hash#fetch(key, default) is safer than [] because it avoids silently returning nil for missing keys.
String interpolation ("#{}") is idiomatic and generally preferred over + concatenation.
Avoid calling sort repeatedly 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?

Common Ruby Pitfalls

Related Study Notes in Programming

Browse all study notes

Programming

Apache Spark Study Notes

Programming · 30 topics

Programming

Apache Flink Study Notes

Programming · 30 topics

Programming

Hadoop Study Notes

Programming · 30 topics

Programming

Snowflake Study Notes

Programming · 30 topics

Programming

Apache Airflow Study Notes

Programming · 30 topics

Programming

dbt (Data Build Tool) Study Notes

Programming · 30 topics

Topics covered

#Ruby#RubyStudyNotes#Programming#RubyQuickReference#Quick#Reference#Core#Syntax#StudyNotes#SkillVeris

Ruby Quick Reference