Test for nil, empty or blank
Treat whitespace as empty (Rails)
x.blank?Trap" ".empty? is false, and nil.empty? raises NoMethodError.
Done 0/0
To review 0
An old way, still asked
The usual way today
Newer, Ruby 3.0+ or Rails 8
The model
- A method call is a message to a receiver, the object before the dot. With no receiver, the call goes to
self, the current object. - To find a method, Ruby walks the receiver's ancestors and calls the first match.
include,prependandextendchange where a module sits in that chain. - Only
nilandfalseare falsy.0,""and[]are all truthy. - The GVL lets one thread at a time run Ruby code. Threads suit I/O-bound work, and processes or Ractors suit CPU-bound work.
Strings, symbols & equality
what a value is and how Ruby compares itQuotes, symbols and printing
Insert a value in a string
"Hi #{name}"Keep the text exactly as written
'Hi #{name}'Print
to_s, with or without a newline, return nilputs xprint xPrint
inspect, return the valuep xTipRuby stores each :symbol once, so comparing two is an identity check. Use them for hash keys and fixed labels, and strings for user text.
Naming conventions
Name a method, a class and a constant
user_name, UserAccount, MAX_USERSMark a predicate or a more dangerous method
empty?save!Asked in interviews
AskedWhat are Ruby's naming conventions?Compare with ==, ===, eql? or equal?
Compare strictly, as hash keys do
1.eql?(1.0)Check for the same object
a.equal?(b)Test membership, as
case does(1..10) === 5Tip1 == 1.0 is true, but 1.eql?(1.0) is false. If you define == on a value object, define eql? and hash too.
Trap=== isn't symmetric. String === "hi" is true, but "hi" === String is false.
Freeze, copy and value objects
Freeze one object, or a file's string literals
obj.freeze# frozen_string_literal: trueGet an unfrozen copy
obj.dupCopy with frozen state and singleton class
obj.cloneMake a small mutable record
Struct.new(:x, :y)Make an immutable value, with every field required (3.2+)
Data.define(:x, :y)Trapfreeze, dup and clone are all shallow. For plain data, Marshal. makes a deep copy.
Arrays, hashes & Enumerable
transform, filter and combine collectionsTransform and filter an array
Collect block results in a new array
a.map { |n| n * 2 }Keep the matches, or drop them
a.select(&:even?) a.reject(&:even?) Get matches and the rest in one pass
a.partition(&:even?) Remove nesting, or remove nil
a.flattena.compactTrapeach runs the block for side effects and ignores its result, so a.each { |n| n * 2 } still returns a.
Merge hashes
Combine into a new hash, or change this one
a.merge(b)a.merge!(b)TipWhen a key is in both, the argument's value wins unless a block picks one. update is another name for merge!.
Asked in interviews
AskedExplain the difference between Hash#merge and Hash#merge!Enumerable, sorting and lazy
Get
map and select from your eachinclude EnumerableCompare two values, get -1, 0, 1 or nil
a <=> bCompute only what you ask for
(1..).lazy.map { |n| n * 2 }.first(5)Tipsort, min and max use each element's <=>. Define it and include Comparable to get the comparison operators.
Blocks, procs & lambdas
pass code around as a valueProc or lambda
Make a lenient callable
Proc.new { |x| x }Make a strict callable to store or pass
->(x) { x * 2 }TipA lambda checks its argument count and raises ArgumentError. A proc fills missing arguments with nil and drops extras.
Trapreturn in a proc exits the method that defined it. In a lambda it exits only the lambda.
Asked in interviews
AskedWhat is the difference between a block, proc, and lambda?yield or &block
Run an optional block
yield if block_given?Keep the block as a Proc, then call it
def run(&block)block.callTipPass it on with other(&block). If the value after & isn't a proc, Ruby calls to_proc, which is how &:upcase works.
Trapyield with no block raises LocalJumpError. A &block parameter is just nil.
Short blocks, then and tap
Skip naming the parameter, with
_1, or it in 3.4+a.map { it * 2 }Transform a value inside a chain
5.then { |x| x * 2 }Run a side effect, keep the object
user.tap { |u| u.save }Tipyield_self is another name for then. To chain your own methods, return self from each one.
TrapIf a method returns a number, not self, the next call goes to an Integer and raises NoMethodError.
Arguments & pattern matching
what a method accepts and how data unpacksKeywords and endless methods
Require one keyword, give another a default
def f(name:, age: 18)Pass a hash as keywords (3.0+)
f(**opts)Write a one-expression method, never a setter (3.0+)
def double(x) = x * 2TrapSince Ruby 3.0 a hash stays positional, so foo({key: 1}) raises ArgumentError when foo takes only keywords.
Splat and forward
Collect extras, or spread an array into arguments
def f(*args, **opts)f(*list)Forward everything, block included
def wrap(...)run(...)Traprun(*args, **opts) passes no block. Add &block.
Pattern matching
Match a shape and bind its parts
in {name:, age: 18..}Destructure data, raise if it doesn't match
data => {name:}Test a shape, get true or false
data in {status: 200}TipHash patterns match even with extra keys, and ^x matches an existing variable's value.
TrapWith no matching branch and no else, Ruby raises No.
Classes, self & visibility
how objects hold state and who may call whatClass, module and duck typing
Share methods across unrelated classes
include FlyableCheck what an object can do before you call it
obj.respond_to?(:speak) TipA module has no new and no subclasses. It's a mixin or a namespace, like Billing::Invoice.
TrapDuck typing means code depends on what an object can do, not its class. A wrong object fails only at run time, with NoMethodError.
Accessors, self and variables
Define a getter, a setter or both
attr_reader, attr_writer, attr_accessorStore a value per object
@nameShare a value with subclasses, which can overwrite it
@@countStore a value on one class, in its body
@countTipself is the instance in an instance method, the class in a class body, and main at the top of a file.
TrapInside a class, name = value creates a local variable. Write self.name = value to call the setter.
public, protected and private
Let a class and its subclasses call it on other objects
protectedAllow calls only with no receiver, or
self. (2.7+)privateChange an inherited method's visibility
public :secretTrapsend can still call a private method, so visibility isn't a security boundary.
super and alias
Pass the same arguments up, or none
supersuper()Give a method a second name
alias_method :size, :lengthTrapsuper() raises ArgumentError when the parent method requires an argument.
Mixins & metaprogramming
change method lookup and write methods at run timeinclude, prepend and extend
Add instance methods after the class
include ModAdd them before the class, to wrap its methods
prepend ModAdd singleton methods to one object
extend ModList the lookup order
Child.ancestorsDefine a method on one object
def str.shoutTipClass methods are singleton methods of the class object. class << self opens its singleton class.
Trapancestors leaves out the singleton class, which Ruby checks first.
Asked in interviews
AskedWhat is the difference between include, prepend, and extend?module_function and name clashes
Call it on the module, private when included
module_functionSave the first module's method before the second
includealias greet_a greetTipUse extend self when included methods should stay public.
TrapWhen two modules define a method, the last one included wins, because ancestors lists it first.
Metaprogramming
Create methods from data
define_method(name) { |v| v }Answer calls to undefined methods
method_missingrespond_to_missing? TipPrefer define_method when you know the names in advance. It's faster than method_missing and shows up in methods.
TrapCall super for every name you don't handle, or a typo stops raising NoMethodError.
Asked in interviews
AskedWhat is metaprogramming in Ruby?Eval blocks and refinements
Add an instance method to every string
String.class_eval { def a; end }Add a method to one object
obj.instance_eval { def a; end }Scope a monkey patch, then turn it on
refine String dousing PatchesTipA refinement's scope is lexical, so code in another file doesn't see it.
TrapOn a class the result looks reversed, because String. defines a class method.
Asked in interviews
AskedWhat is the difference between class_eval and instance_eval?Errors, files, shell & gems
handle failure and reach outside the programbegin, rescue, else, ensure
beginrescue => esame as StandardErrorelseno error raisedensurealways runsend
TipA return inside ensure replaces the result and swallows any exception. Inside rescue, retry runs the body again.
Traprescue Exception also catches Interrupt and SystemExit, so Ctrl+C and exit can stop working.
raise, throw and fail fast
Leave nested loops early, with no error
catch(:done) { throw :done }Fail fast on a missing key with
KeyErrorh.fetch(:a)Fail safe with a default
data ||= defaultTrapSubclass StandardError. A class that inherits straight from Exception slips past a bare rescue.
Files and shell commands
Open a file and close it for you
File.open("f") { |f| f.read }Open a file you must close yourself
File.new("f")Run a command, get true, false or nil
system("ls")Capture standard output as a string
`ls`Replace the Ruby process, and never return
exec("ls")TipWith user input, write system("ls", dir), so no shell runs.
TrapA missing file raises a SystemCallError, not an IOError. File.exist? is only a hint, so still rescue.
Gems, require and debugging
Load a gem once per process
require 'json'Run a file again on every call
load 'config.rb'Install locked versions, or move to newer ones
bundle installbundle updateSet a breakpoint (3.1+)
binding.breakSet a breakpoint in an older project
byebugTipThe Gemfile lists accepted version ranges, and Gemfile.lock the exact versions. Commit both. binding.irb opens a console at that line.
Traprequire './x' breaks when the program starts from another directory. Use require_.
Threads, memory & speed
what senior interviews add about the runtimeThe GVL and Ractors
Thread A releases the GVL while it waits on I/O, so thread B runs. A Ractor has its own GVL and runs at the same time.
Run CPU-bound work in parallel
Ractor.new { work }TipMRI calls the lock the GVL, not the GIL. Ruby 4.0 replaced Ractor#take with Ractor#value.
TrapRactors are still experimental, so production CPU work usually runs in several processes.
Asked in interviews
AskedWhat is the Global Interpreter Lock (GIL) in Ruby?Threads, fibers and safety
Run code that hands back control itself
Fiber.new { Fiber.yield }Overlap I/O waits with a scheduler gem (3.0+)
Async { fetch(url) }Let one thread at a time run a block
m.synchronize { n += 1 }Hand work between threads with no explicit lock
Queue.newTipThreads are preemptive, and fibers are cooperative.
TrapThe GVL doesn't prevent race conditions. A thread can switch in the middle of @n += 1.
Asked in interviews
AskedWhat is the difference between Thread and Fiber in Ruby?Memory and speed
Dump the heap to compare over time
ObjectSpace.dump_all Memoize, unless the result can be nil or false
@r ||= computeTurn on the JIT compiler
ruby --yjit app.rbTime a block
Benchmark.measure { work }See where the time goes, at low cost
stackprofvernierTipMark-and-sweep frees cycles too. Minor collections mark only young objects.
TrapA leak is an object that stays reachable, like a cache that only grows. Circular references aren't a cause.
Rails & Active Record
the request path, queries and saving safelyRack, middleware and MVC
Write a Rack app that returns status, headers and body
def call(env)List the middleware stack
bin/rails middlewareTipA request passes down the middleware stack to the router, then a controller action. Keep business rules in models.
render, redirect and strong parameters
Send the browser to a new URL after a save
redirect_to @userShow the form again after a failed save
render :new, status: :unprocessable_entity Block mass assignment, allowing only listed keys
params.require(:user).permit(:name) Require and permit in one call, in Rails 8
params.expect(user: [:name])Traprender :new doesn't run the new action. It keeps this action's instance variables, and a redirect loses them.
N+1 queries and scopes
Eager load and let Rails pick the strategy
User.includes(:posts) Load in one query with a
LEFT OUTER JOINUser.eager_load(:posts) Name a reusable query
scope :active, -> { where(active: true) }TipA scope always returns a relation, so it chains. A class method that returns nil breaks the chain.
Trapcount always runs a SQL COUNT, even on loaded records. Use size on a preloaded association.
Many-to-many and deleting
Link through a join model with its own data
has_many :groups, through: :membershipsLink through a bare join table
has_and_belongs_to_many :groupsDelete with callbacks and
dependent:user.destroySend one SQL
DELETEuser.deleteTrapdelete skips callbacks and associated records, which can leave orphaned rows.
Callbacks, concerns and services
Send an email after the commit
after_create_commit :send_emailShare scopes and callbacks across models
extend ActiveSupport::Concern Wrap one business operation in a plain class
SignUp.new(params).call TipA concern still adds methods to the model. A service object moves the logic out.
TrapWith after_create, the email goes out even if the transaction later rolls back.
Transactions and locking
Commit all writes or none
ActiveRecord::Base.transaction doCatch conflicting saves with an integer column
lock_versionHold a row lock
order.with_lock { ship }Tipraise Active undoes the block quietly.
TrapPlain save returns false without raising, so the other write still commits. Use save! inside the block.
Design, tests & security
patterns, test doubles and common attacksStubs, mocks and test data
Stub a query with a fixed value
allow(u).to receive(:email)Fail the test if a call never happens
expect(m).to receive(:send_email) Make an unsaved or a saved test record
build(:user)create(:user)TipFixtures are YAML records that load once, so they're fast but shared. Factories keep each test's data next to the test.
Composition, injection and Demeter
Take a collaborator from outside, with a default
def initialize(mailer = Mailer.new)Hide a chain like
a.b.c behind one method (Rails)delegate :street, to: :addressTipComposition is the usual choice in Ruby. Use inheritance when the subclass really is a special kind of the parent.
SOLID and the Singleton pattern
Single responsibilityA class has one reason to change.
Open/closedAdd new classes, and don't edit working code.
Liskov substitutionA replacement honors what callers expect.
Interface segregationSmall modules, because Ruby has no interfaces.
Dependency inversionPass collaborators in.
Allow one instance, read with
Config.instanceinclude SingletonTrapA singleton is global state, so one test can affect another.
Attacks and sensitive data
Stop SQL injection
User.where(name: params[:name])Encrypt a column at rest
encrypts :ssnTipRails escapes view output, so XSS risk sits in html_safe and raw. An authenticity token blocks CSRF.
TrapMarshal.load on untrusted data can lead to remote code execution.
Asked in interviews
AskedHow do you securely handle sensitive data in Ruby?Nothing matches. Try a shorter word, or clear the search.
Found this useful? Pass it on.
Pro · $10/mo
This sheet stays free. With Pro, you can:
- Every answer on this sheet. Read the full answer to all 91 questions it links, not just the 13 free ones.
- My sheet. The cards you star and the ones you miss in Quiz me, from every sheet, on one page to quiz and print.
- PDFs. Download this sheet and My sheet, laid out for A4, with every question a link to its answer.
- The rest of Pro. Every answer in the question library, and 1,000 AI credits a month.