Ruby Cheatsheet

Enumerable and Blocks

Use this Ruby reference while you build software engineering projects, review code for technical interview prep, or polish examples for a software engineer resume.

Blocks

Blocks pass behavior into methods.

[1, 2, 3].each { |n| puts n }

[1, 2, 3].each do |n|
  puts n
end

Use braces for short single-line blocks and do ... end for multi-line blocks.

Core Enumerable Methods

items.each { |x| puts x }              # side effects
items.map { |x| transform(x) }         # array of transformed values
items.flat_map { |x| x.children }      # map then flatten one level
items.select { |x| keep?(x) }          # matching items
items.reject { |x| skip?(x) }          # non-matching items
items.find { |x| wanted?(x) }          # first match or nil
items.any? { |x| x.valid? }
items.all? { |x| x.valid? }
items.none?(&:nil?)
items.count { |x| x.active? }

reduce / inject

[1, 2, 3].reduce(0) { |sum, n| sum + n }   # 6
[1, 2, 3].inject(:+)                       # 6
words.reduce({}) do |hash, word|
  hash[word] = word.length
  hash
end

For hashes and arrays, each_with_object is often clearer than reduce because you do not need to return the accumulator each time.

each_with_object

words = ["ruby", "rails", "ruby"]
counts = words.each_with_object(Hash.new(0)) do |word, hash|
  hash[word] += 1
end

Short Symbol-to-Proc Form

names.map(&:downcase)      # names.map { |name| name.downcase }
nums.select(&:even?)
users.map(&:email)

Use &:method_name only when you call one method with no extra arguments. Use a normal block for anything more complex.

yield

def around(label)
  puts "before #{label}"
  result = yield
  puts "after #{label}"
  result
end

around("work") { 2 + 2 }

Explicit Blocks

def measure(&block)
  start = Time.now
  result = block.call
  [result, Time.now - start]
end

&block converts the passed block into a Proc object. This is useful when you need to store, forward, or call the block more than once.

Procs and Lambdas

square = proc { |n| n * n }
square.call(5)      # 25

strict = ->(n) { n * n }
strict.call(5)

Lambdas check argument count more strictly and return behaves like returning from the lambda. Plain procs are looser and can surprise beginners inside methods.