easyhashes literals and fetch
Given `h = { a: 1, b: 2 }`, what does `h.fetch(:c)` do?
h = { a: 1, b: 2 }
h.fetch(:c)Ruby Interview Questions (557 to practise)
Ruby is a dynamic, deeply reflective language best known through Rails. Its metaprogramming is both the draw and the trap.
Method lookup through modules and prepend, blocks versus procs versus lambdas and their return behaviour, method_missing, mutation of frozen objects, and the singleton class.
- Total questions
- 557
- Easy
- 50
- Medium
- 247
- Hard
- 260
Where it shows up: Rails product companies, internal tooling, and startups that value shipping speed.
Sample Ruby questions
Twenty real Ruby questions from the library, code snippet included. Nothing here is paraphrased for search engines. It is the same text a signed-in user sees.
mediummethod_missing and respond_to_missing
A class defines method_missing to handle any call, but does NOT define respond_to_missing?. What does calling obj.method(:anything) return for a name the class handles only via method_missing?
class Ghost
def method_missing(name, *args)
"ghost: #{name}"
end
end
g = Ghost.new
puts g.anything # works
m = g.method(:anything) # ???mediumdefine_method
Methods are generated in a loop with define_method. For `Roles.new(:editor)`, what do `admin?`, `editor?`, and `viewer?` return?
class Roles
%i[admin editor viewer].each do |role|
define_method("#{role}?") { @role == role }
end
def initialize(r) = @role = r
end
u = Roles.new(:editor)
[u.admin?, u.editor?, u.viewer?]hardfrozen string dedup
In CRuby 3.x, both expressions are evaluated repeatedly at runtime. Which statement correctly explains why one form deduplicates equal-content strings into a single shared frozen object and the other does not?
a = "pre#{ENV['X']}".freeze
b = "pre#{ENV['X']}".freeze
c = -"pre#{ENV['X']}"
d = -"pre#{ENV['X']}"
# Assume ENV['X'] is unset, so all four have equal content.easystring interpolation and methods
What does this expression return?
p "ab" * 3mediumEnumerable and custom each
A class includes `Enumerable` and defines `each`. What does calling `map` without a block return?
class Bag
include Enumerable
def initialize(*items); @items = items; end
def each; @items.each { |i| yield i }; end
end
puts Bag.new(1, 2, 3).map.classeasyarrays push map select
What does this code output?
p [1, nil, 2, false, 3].compacteasytimes upto each_with_index
How many times does this loop print "hi"?
0.times do
puts "hi"
endeasytruthiness only nil false falsy
What does this method return when called as describe(nil)?
def describe(x)
if x.nil?
"got nil"
elsif x == false
"got false"
else
"got something"
end
endeasyclasses initialize attr_accessor
What is printed?
class User
attr_accessor :name
def initialize(n)
name = n
end
end
puts "Hi, #{User.new('Sam').name}"easystring interpolation and methods
What does this string interpolation produce?
name = "Sam"
puts "Hi #{name.upcase}!"easyeverything is an object nil true false
What does `true.class.ancestors.include?(Object)` return, and why?
true.class.ancestors.include?(Object)easytruthiness only nil false falsy
What does user&.name return when user is nil?
user = nil
user&.nameeasysymbols vs strings
Why are these two symbols considered the same object while the two strings are not?
:foo.object_id == :foo.object_id # => true
"foo".object_id == "foo".object_id # => falseeasyputs p inspect
What is the difference between `puts` and `p` for this array?
puts [1, 2, 3]
p [1, 2, 3]easyif unless case
What is the value of z?
z = if false then 1 endmediummethod_missing and respond_to_missing
Inside a `method_missing` implementation, you handle some names dynamically and call `super` for the rest. What is the benefit of calling `super` rather than raising your own error?
def method_missing(name, *args)
return "dynamic" if name.to_s.start_with?("get_")
super
endmediumdefine_method
In Ruby 3.x, what is the visibility of a method created by `define_method` that appears right after a bare `private` statement in a class body?
class Vis
private
define_method(:secret) { "s" }
end
Vis.new.respond_to?(:secret) # => falsemediumComparable and spaceship
For two built-in objects of incompatible types, like `1 <=> "a"`, what does the spaceship operator return?
p(1 <=> "a")easyarrays push map select
What is the value of `nums` after this code runs?
nums = [1, 2, 3]
doubled = nums.map { |n| n * 2 }
p numsSign in to answer
Everything above is free to read. Answering needs a free account.
We keep the correct answer, the explanation and the scoring behind sign-in so the platform stays honest, which is why the answer options and the worked explanation for every Ruby question stay behind a free account. Signing in is free and takes a few seconds.
Ruby topics covered
60 distinct Ruby topics are tagged across the library. These are the real topic labels stored on the questions, not a hand-written list.
- method_missing and respond_to_missing (23)
- method lookup and ancestors (23)
- method_missing dispatch internals (20)
- Proc vs lambda return and arity (19)
- mark-sweep and GC.compact (19)
- Comparable and spaceship (18)
- freeze and immutability (17)
- refinements using (17)
- include prepend extend on the chain (17)
- Enumerable and custom each (16)
- Struct and Data (16)
- the GVL global VM lock (16)
- YARV bytecode (15)
- send and public_send (15)
- singleton eigenclass (15)
- Proc vs lambda usage (15)
- dup vs clone (14)
- blocks procs lambdas binding (14)
- fibers and the scheduler (14)
- define_method (13)
- lazy enumerators (13)
- keyword arguments and double splat (12)
- pattern matching case in (12)
- frozen string dedup (11)
- MRI garbage collection (11)
- Binding objects (11)
- module_function and extend self (10)
- prepend vs include (10)
- gems Bundler require (10)
- object memory RVALUE embedded strings (10)
- Threads vs Ractors vs fibers (10)
- C extension boundary (9)
- tap and then (8)
- custom exceptions (8)
- const_missing included inherited hooks (8)
- the object model classes are objects (7)
- symbols vs strings (5)
- arrays push map select (5)
- hashes literals and fetch (5)
- everything is an object nil true false (5)
- classes initialize attr_accessor (4)
- truthiness only nil false falsy (4)
- instance vs class variables (4)
- string interpolation and methods (3)
- object model classes are objects (3)
- each map select reduce (3)
- modules as namespaces include (2)
- blocks do end and braces (2)
- exceptions begin rescue ensure raise (2)
- Mark-sweep (2)
- symbol to proc (2)
- GVL global VM lock (2)
- times upto each_with_index (1)
- puts p inspect (1)
- if unless case (1)
- ranges (1)
- classes are objects (1)
- GC.compact (1)
- include prepend extend (1)
- object model: classes are objects (1)
Search and filter every Ruby question
…
Difficulty