ITMy statistics
Ruby Quiz
414 Ruby questions in 42 topics (Junior — 159, Middle — 174, Senior — 81). Pick topics, a level and how many questions you want; every answer comes with an explanation.
Strings, arrays and hashes, blocks and iterators, OOP, modules and mixins, exceptions, metaprogramming and Ruby 3 gotchas.
All Ruby questions 414
Tap an option to check yourself, or "Show answer".
Learn step by step: Ruby: from Zero to Pro150 lessons · theory, examples and exercisesStudy a topic with the course lessons (41)
- Gems и Bundler: 7. Гемы и Bundler: основы, 111. Свой гем: структура и публикация, 112. Bundler и Gemfile глубже
- Идиомы Ruby: 8. Комментарии и стиль кода, 10. Философия Ruby и принцип наименьшего удивления, 69. freeze и неизменяемость, 114. Rubocop и стиль
- Переменные и видимость: 11. Переменные и именование, 50. Область видимости
- Типы и числа: 12. Числа: Integer, Float, Rational, 19. Приведение типов
- Строки: 13. Строки и интерполяция, 51. Методы строк, 52. Кодировки и UTF-8, 56. Heredoc и многострочные строки
- Символы: 14. Символы
- nil и истинность: 15. nil, true и false, 28. Truthy и falsy значения
- Операторы: 16. Арифметика и приоритет операций, 17. Сравнения и оператор <=>, 29. Логические операторы: &&, ||, and, or, not
- Вывод и форматирование: 18. Ввод и вывод: gets, puts, p, pp, 53. Форматирование: format и %
- Объектная модель: 20. Всё в Ruby — объект, 68. ==, eql?, equal? и hash, 74. Цепочка предков и поиск методов, 94. Рефлексия
- Условия и циклы: 21. if, elsif, else и unless, 22. Тернарный оператор и модификаторы, 23. case / when, 24. Циклы while и until
- Диапазоны: 27. Диапазоны (Range)
- Массивы: 31. Массивы: создание и доступ, 32. Методы массивов, 39. Деструктуризация и splat
- Хеши: 33. Хэши, 40. Практикум: частотный словарь
- Enumerable: 34. Итерация: each и each_with_index, 35. map, select, reject, 36. reduce, sum, min и max, 37. sort_by, group_by, partition
- Итераторы: 34. Итерация: each и each_with_index, 103. Ленивые перечисления, 104. Enumerator
- Стандартная библиотека: 38. Set: множества, 57. Чтение и запись файлов, 58. Dir и Pathname, 59. CSV и JSON
- Методы и аргументы: 41. Определение методов, 42. Аргументы по умолчанию и именованные, 43. *args и **opts, 44. Возвращаемое значение
- Блоки: 45. Блоки и yield, 48. Приём &:symbol
- Proc и lambda: 46. Proc и lambda, 47. Замыкания
- Строки и регулярные выражения: 54. Регулярные выражения: основы, 55. Регулярные выражения: группы и lookaround, 60. Практикум: парсер логов
- Классы и объекты: 61. Классы и экземпляры, 62. Конструктор initialize, 63. attr_reader, attr_writer, attr_accessor, 64. Переменные экземпляра и класса
- self и контекст: 65. Методы класса и self
- Видимость методов: 66. public, private, protected
- Наследование: 71. Наследование и super, 80. Композиция против наследования
- Модули и миксины: 72. Модули и миксины, 73. include, extend, prepend, 75. Comparable, 77. Пространства имён
- Паттерны и SOLID: 79. Утиная типизация, 80. Композиция против наследования, 141. Архитектура: service objects и паттерны
- Исключения: 81. Исключения: begin / rescue / ensure, 82. raise и собственные классы ошибок, 83. retry и повторные попытки, 84. catch и throw
- Найдите ошибку: 85. Отладка: debug и binding, 148. Код-ревью
- Память и производительность: 87. Профилирование, 109. Сборщик мусора и память, 110. YJIT, 142. Производительность и бенчмарки
- Тестирование: 88. Minitest, 90. TDD на примере
- RSpec и тестирование: 89. RSpec, 90. TDD на примере
- Метапрограммирование: 91. send и public_send, 92. define_method, 93. method_missing и respond_to_missing?, 94. Рефлексия
- Pattern matching: 101. Pattern matching: case / in
- Новое в Ruby 3: 102. Современный синтаксис: endless methods, it, except, 110. YJIT
- Многопоточность: 105. Ractor, 106. Fiber и scheduler, 107. Потоки и Mutex, 108. concurrent-ruby
- ActiveRecord: 124. ActiveRecord отдельно от Rails, 125. Миграции, 126. Связи между таблицами, 127. N+1 и индексы
- Rails: фоновые задачи и кэш: 129. Redis, 130. Кэширование, 138. Фоновые задачи: Sidekiq, 139. WebSocket и ActionCable
- Ruby on Rails: 131. Rack, 132. Sinatra, 136. Обзор Rails: MVC и конвенции
- Rails: контроллеры и роутинг: 133. Роутинг и шаблоны ERB, 134. Формы и сессии, 137. REST API
- Безопасность в Rails: 135. Аутентификация, 140. Безопасность: CSRF, XSS, SQL-инъекции
Типы и числа10
Чему равно
7 / 2 в Ruby?- 3.5
- 3
- 4
- 3.0
Оба операнда —
Integer, поэтому / выполняет целочисленное деление и отбрасывает дробную часть (округляет вниз). Чтобы получить 3.5, хотя бы один операнд должен быть Float (7 / 2.0) или используйте 7.fdiv(2).Что вернут выражения
-7 / 2 и -7 % 3 в Ruby?- -3 и -1
- -4 и -1
- -4 и 2
- -3 и 2
В Ruby целочисленное деление округляет к минус бесконечности:
-3.5 → -4. Остаток % (modulo) имеет знак делителя: -7 - 3 * (-3) = 2. Ответ -3 и -1 — это поведение C, Java и JavaScript, где деление усекается к нулю.Что вернут выражения
-7.remainder(2) и -7 % 2?- 1 и 1
- -1 и -1
- 1 и -1
- -1 и 1
remainder возвращает остаток со знаком делимого (как % в C): -1. Оператор % (он же modulo) возвращает результат со знаком делителя: 1. Поэтому для проверки нечётности отрицательных чисел n % 2 == 1 работает в Ruby корректно, а remainder — нет.Чему равно
1/3r + 1/6r (в том виде, как его покажет p)?- 0.5
- (1/2)
- 0
- (3/6)
Суффикс
r создаёт литерал Rational, поэтому 1/3r — это точная дробь (1/3). Арифметика с Rational точная и результат автоматически сокращается: (1/2), а p выводит его как (1/2). Без суффикса 1/3 дало бы 0 из-за целочисленного деления.Что вернёт выражение
2 ** -1 в Ruby 3.3?- (1/2)
- 0
- 0.5
- ZeroDivisionError
Integer#** с отрицательным целым показателем возвращает Rational: 2 ** -1 → (1/2), 2 ** -3 → (1/8). Это не целочисленное деление, поэтому не 0; 0.5 получилось бы только при Float в выражении, например 2 ** -1.0.Что вернут
"12abc".to_i и "abc".to_i?- 12 и nil
- 12 и 0
- ArgumentError для "12abc"
- nil и nil
String#to_i «мягкий»: читает цифры с начала строки до первого неподходящего символа и никогда не бросает исключение. Если цифр в начале нет, возвращается 0, а не nil. Строгое преобразование — Integer("12abc"), оно бросит ArgumentError.Что вернёт выражение
Integer("12abc")?- 12
- 0
- Будет выброшено ArgumentError
- nil
Kernel#Integer — строгое преобразование: вся строка должна быть корректным числом, иначе ArgumentError (invalid value for Integer(): "12abc"). Значения 12/0 — это поведение мягкого "12abc".to_i. Чтобы получить nil вместо исключения, используют Integer("12abc", exception: false).Что выведет этот код (Ruby 3.3)?
p 1234.digits
p 1234.digits.sum[1, 2, 3, 4],10["1", "2", "3", "4"],NoMethodError— строки нельзя сложить черезsum[4, 3, 2, 1],104,4—digitsвозвращает количество цифр
Integer#digits возвращает массив цифр-чисел, начиная с *младшего* разряда, поэтому порядок обратный записи: [4, 3, 2, 1]; сумма от порядка не зависит — 10. Можно передать основание: 255.digits(16) → [15, 15]. Для отрицательного числа digits бросает Math::DomainError, а чтобы получить цифры в привычном порядке, добавляют .reverse или пишут 1234.to_s.chars.map(&:to_i).Что выведет этот код (Ruby 3.3)?
p 2.5.round
p 3.5.round
x = -2.5
p x.round
p 2.5.round(half: :even)2,4,-2,2— по умолчанию банковское округление3,4,-3,23,4,-2,2— половина всегда округляется вверх, к большему числу3,4,-3,3— опцияhalf:поддерживается только уInteger#round
Float#round по умолчанию округляет половину *от нуля*: 2.5 → 3, 3.5 → 4, -2.5 → -3. Опция half: меняет правило: :even — банковское округление к ближайшему чётному (2.5 → 2, 3.5 → 4), :down — половина к нулю, :up — поведение по умолчанию. Банковское округление по умолчанию — это, например, Python 3 и Math.Round в .NET, но не Ruby.Что выведет этот код?
p "ff".hex
p "0x1A".hex
p "777".oct
p "zz".hex255,26,777,nil255,0,511,0— префикс0xне поддерживается255,26,511,0255,26,511, затемArgumentError
String#hex разбирает строку как шестнадцатеричное число (необязательные знак и префикс 0x допускаются), String#oct — как восьмеричное: "777".oct → 7·64 + 7·8 + 7 = 511. Как и to_i, эти методы не бросают исключений: разбор останавливается на первом недопустимом символе, а если подходящих цифр нет совсем — возвращается 0. Для строгой проверки используйте Integer("zz", 16) — он бросит ArgumentError.Строки11
Что выведет этот код (Ruby 3.3)?
s = "abc"
s.upcase
puts s- ABC
- abc
- nil
- "abc"
upcase без восклицательного знака не меняет исходную строку, а возвращает новую — и здесь её результат просто выброшен. Чтобы изменить s, нужно s = s.upcase или s.upcase!. Кавычек нет, потому что puts выводит строку без inspect.Что выведет этот код (Ruby 3.3)?
s = "ABC"
p s.upcase!
p s- "ABC" и "ABC"
- nil и nil
- false и "ABC"
- nil и "ABC"
Bang-методы вроде
upcase! изменяют строку на месте и возвращают nil, если изменений не было (строка уже в верхнем регистре). Сама s остаётся "ABC". Поэтому цепочки вида s.upcase!.strip опасны — можно получить NoMethodError на nil.Что выведет этот код (Ruby 3.3)?
name = "Ruby"
puts 'Hi, #{name}'- Hi, Ruby
- Hi, #{name}
- Hi, 'Ruby'
- SyntaxError
Интерполяция
#{...} и escape-последовательности вроде \n работают только в строках в двойных кавычках (и в %Q, heredoc без кавычек). В одинарных кавычках текст берётся буквально, экранируются лишь \\ и \'.Что выведет этот код (Ruby 3.3)?
a = "hi"
b = a
a += "!"
c = "yo"
d = c
c << "!"
p b, d- "hi" и "yo!"
- "hi!" и "yo!"
- "hi" и "yo"
- "hi!" и "yo"
a += "!" — это a = a + "!": создаётся новая строка, и a начинает ссылаться на неё, а b по-прежнему указывает на старую "hi". << дописывает в тот же объект на месте, поэтому изменение видно и через d. Отсюда же правило: в циклах << быстрее, чем +=.Что выведет этот код (Ruby 3.3)?
# frozen_string_literal: true
s = "abc"
s << "d"
p s- "abcd"
- "abc"
- FrozenError (can't modify frozen String)
- NoMethodError (undefined method '<<')
Магический комментарий
# frozen_string_literal: true делает все строковые литералы файла замороженными, и попытка изменить строку на месте бросает FrozenError. Метод << у строки есть, так что NoMethodError здесь не возникнет. В Ruby 3.3 без этого комментария литералы изменяемые и результат был бы "abcd".Файл начинается с
# frozen_string_literal: true. Какое присваивание даст изменяемую строку, чтобы следующий s << "d" сработал?- s = "abc".itself
- s = -"abc"
- s = "abc".freeze
- s = +"abc"
Унарный
+ (String#+@) возвращает незамороженную копию, если строка заморожена (то же дадут "abc".dup и String.new("abc")). Унарный - наоборот возвращает замороженную (дедуплицированную) строку, а itself и freeze возвращают тот же замороженный литерал.Что выведет этот код (Ruby 3.3)?
s = "hello"
p s[1..3]
p s[-3..]
p s[10]- "ell", "llo", nil
- "el", "llo", nil
- "ell", "llo", затем IndexError
- "ell", "lo", ""
Диапазон
1..3 включает оба конца — символы с индексами 1, 2, 3, то есть "ell" (1...3 дал бы "el"). -3.. — бесконечный диапазон от третьего символа с конца до конца строки. Индекс за пределами строки возвращает nil, а не бросает исключение (IndexError бросает fetch у массива).Что вернёт выражение
"ab" * 3?- ["ab", "ab", "ab"]
- "ab3"
- TypeError
- "ababab"
String#* повторяет строку указанное число раз. Обратный порядок 3 * "ab" вызовет TypeError, потому что это уже Integer#*, который не умеет умножать на строку. Массив получился бы при ["ab"] * 3.Что выведет этот код (Ruby 3.3)?
text = <<~EOS
Hello
World
EOS
p text- "Hello\nWorld\n"
- " Hello\n World\n"
- "Hello\n World\n"
- "Hello\n World"
Squiggly heredoc
<<~ убирает наименьший общий отступ (здесь 4 пробела) и сохраняет относительный, поэтому у World остаются 2 пробела. Завершающий перевод строки сохраняется. Отступы целиком остались бы при <<-, который лишь позволяет сдвинуть закрывающий маркер.Что выведет этот код?
p "az".succ
p "zz".succ
p "a9".succ"a{","z{","a:"— последний символ заменяется следующим по коду ASCII"ba","za","a10""ba","aaa","b0"NoMethodError—succопределён только для целых чисел
String#succ (он же next) увеличивает самый правый буквенно-цифровой символ в пределах его «класса» — строчные буквы, прописные, цифры — с переносом влево, как у одометра: z → a и перенос, 9 → 0 и перенос. Если перенос выходит за левый край, добавляется новый символ того же класса: "zz" → "aaa", "99" → "100". Именно succ порождает элементы строковых диапазонов, поэтому ("az".."bc").to_a → ["az", "ba", "bb", "bc"].Что выведет этот код?
p "aaabbb cc".squeeze
p "mississippi".squeeze("sp")
p "book".squeeze("a")"abc","mississippi","bok""ab c","msp","book""ab c","misisipi","bok""ab c","misisipi","book"
String#squeeze без аргументов схлопывает любую серию одинаковых подряд идущих символов в один — включая пробелы: "aaabbb cc" → "ab c". С аргументом сжимаются только перечисленные символы (набор задаётся как в count/delete, можно диапазоном "a-z"): в "mississippi" схлопываются ss и pp, а "book" с squeeze("a") не меняется — двойное o не входит в набор. Метод возвращает новую строку; squeeze! меняет строку на месте.Символы5
Что выведет этот код (Ruby 3.3, без магического комментария
frozen_string_literal)?p :a.object_id == :a.object_id
p "a".object_id == "a".object_id- true и true
- true и false
- false и false
- false и true
Символ с одним именем — всегда один и тот же объект, поэтому
object_id совпадают. Каждый строковый литерал без магического комментария создаёт новый объект String, и их object_id различаются, хотя == для них вернул бы true. Именно поэтому символы удобны как ключи и идентификаторы.Что вернёт
%w[apple kiwi].map(&:upcase)?- ["APPLE", "KIWI"]
- [:APPLE, :KIWI]
- ["apple", "kiwi"]
- NoMethodError
&:upcase вызывает Symbol#to_proc, получая блок { |x| x.upcase }, который применяется к каждой строке. Результат — строки, а не символы: символ здесь лишь задаёт имя вызываемого метода. %w[...] создаёт массив строк.Что выведет этот код (Ruby 3.3)?
h = { "name" => "Ann" }
p h[:name]- "Ann"
- KeyError
- nil
- :name
Ключ
"name" (строка) и :name (символ) — разные ключи, поэтому поиск по символу ничего не находит и [] возвращает nil. KeyError бросил бы h.fetch(:name). Это частая ошибка при работе с JSON, где ключи приходят строками.Что выведет этот код (Ruby 3.3)?
h = { a: 1, "b": 2, "c" => 3 }
p h.keys- [:a, "b", "c"]
- [:a, :b, "c"]
- ["a", "b", "c"]
- [:a, :b, :c]
Синтаксис
ключ: всегда создаёт символ, даже если ключ записан в кавычках: "b": 2 — это :b => 2 (удобно для символов с пробелами или дефисами). Строковым ключ становится только при записи через =>, как у "c".Что выведет этот код (без магического комментария
frozen_string_literal)?p :name.equal?(:name)
p "name".equal?("name")
p "name".to_sym.equal?(:name)
p :name.frozen?true,false,true,truetrue,true,true,falsefalse,false,true,truetrue,false,false,false
Символ с данным именем существует в программе в единственном экземпляре: каждое упоминание
:name и результат "name".to_sym — один и тот же объект, поэтому equal? (сравнение по идентичности) даёт true. Строковые литералы без frozen_string_literal: true создают новый объект при каждом вычислении, отсюда false во второй строке. Символы неизменяемы и всегда заморожены — frozen? возвращает true. Отсюда их роль ключей хешей и имён методов: сравнение по идентичности быстрее, а памяти уходит меньше, чем на множество одинаковых строк.nil и истинность5
Какие значения считаются ложными в условиях Ruby?
- nil, false, 0 и ""
- Только nil и false
- nil, false и пустой массив []
- Только false
В Ruby ложны только
nil и false; всё остальное, включая 0, пустую строку "" и пустой массив [], истинно. Проверять «пустоту» нужно явно: n.zero?, str.empty?. Привычка из JavaScript/PHP/Python, где 0 и "" ложны, здесь подводит.Что вернут
nil.to_a, nil.to_s и nil.to_i?- nil, nil, nil
- [nil], "nil", 0
- NoMethodError: у nil нет таких методов
- [], "", 0
NilClass определяет методы преобразования, возвращающие «пустые» значения: to_a → [], to_s → "", to_i → 0. Строка "nil" — это результат nil.inspect, а не to_s. Благодаря этому "#{nil}" даёт пустую строку.Что выведет этот код (Ruby 3.3)?
user = nil
p user&.name
p user.name- nil и nil
- nil, затем NoMethodError
- NoMethodError уже на второй строке
- "" и NoMethodError
Оператор безопасной навигации
&. возвращает nil, если получатель nil, и не вызывает метод. Обычный вызов user.name на nil бросает NoMethodError (undefined method 'name' for nil). Учтите: &. защищает только от nil, на false метод всё равно будет вызван.Что выведет этот код (Ruby 3.3)?
a = false
a ||= 5
b = 0
b ||= 5
p a, b- 5 и 0
- false и 0
- 5 и 5
- false и 5
a ||= 5 работает примерно как a || a = 5: присваивание происходит, если текущее значение ложно, то есть nil или false. Поэтому false заменяется на 5, а 0 истинен и сохраняется. Если false — допустимое значение, ||= для «значения по умолчанию» не подходит.Что вернут выражения
nil || "default", 1 && 2 и nil && 2?- true, true, false
- "default", 2, nil
- "default", true, false
- true, 2, nil
|| и && возвращают не true/false, а один из операндов: || — первый истинный (или последний), && — первый ложный (или последний). Поэтому nil || "default" даёт "default", 1 && 2 — 2, а nil && 2 — nil. На этом построена идиома значений по умолчанию.Операторы5
Что выведет этот код (Ruby 3.3)?
x = true and false
y = true && false
p x, y- false и false
- true и true
- true и false
- false и true
У
and приоритет ниже, чем у присваивания, поэтому первая строка разбирается как (x = true) and false и x получает true. У && приоритет выше, чем у =, и y = (true && false) — это false. Поэтому and/or используют только для управления потоком (save or raise), а не в выражениях.Что вернут выражения
1 <=> 2, "b" <=> "a" и 1 <=> "a"?- -1, 1, nil
- -1, 1, ArgumentError
- false, true, nil
- -1, 1, -1
«Космический корабль»
<=> возвращает -1, 0 или 1, а для несравнимых объектов — nil, без исключения. ArgumentError (comparison of Integer with String failed) возникнет позже, например в sort, который получил nil от <=>. На <=> основан модуль Comparable.Что вернут
1 == 1.0, 1.eql?(1.0) и "a".equal?("a") (Ruby 3.3, без магического комментария frozen_string_literal)?- true, true, false
- true, false, true
- true, false, false
- false, false, false
== сравнивает значения с приведением числовых типов: 1 == 1.0 — true. eql? дополнительно требует совпадения типов, поэтому Integer и Float не равны. equal? проверяет идентичность объекта, а два строковых литерала — разные объекты, поэтому false.Что выведет этот код (Ruby 3.3)?
h = { 1 => "int" }
p h[1.0]- "int"
- nil
- KeyError
- TypeError
Hash ищет ключи по
hash и eql?, а не по ==. 1.eql?(1.0) — false (и хеши разные), поэтому ключ 1.0 не найден и [] возвращает nil. Многие ошибочно ожидают "int", потому что 1 == 1.0.Чему равно выражение
1 + 2 * 3 ** 2?- 81
- 49
- 19
- 37
Сначала выполняется возведение в степень
3 ** 2 = 9, затем умножение 2 * 9 = 18, затем сложение 1 + 18 = 19. У ** приоритет выше, чем у * и /, а у них — выше, чем у + и -. Прочие варианты получаются при неправильном порядке операций.Условия и циклы9
Что выведет этот код (Ruby 3.3)?
age = 15
group = case age
when 0..12 then "child"
when 13..17 then "teen"
else "adult"
end
puts group- child
- adult
- teen
- Пустая строка (case вернёт nil)
case/when сравнивает через === ветки по порядку: (13..17) === 15 проверяет вхождение в диапазон, это true. case — выражение, поэтому его значение можно присвоить переменной. nil получился бы, только если ни одна ветка не подошла и нет else.Что вернут выражения
Integer === 5 и 5 === Integer?- true и true
- false и true
- true и false
- false и false
=== не симметричен: Integer === 5 вызывает Module#===, который проверяет 5.is_a?(Integer) — true. 5 === Integer вызывает Integer#===, то есть обычное сравнение числа с классом — false. Именно поэтому в case x объект x стоит справа: when Integer означает Integer === x.Что выведет этот код (Ruby 3.3)?
case "order42"
when /\A\d+\z/ then puts "только цифры"
when /\d/ then puts "есть цифры"
else puts "нет цифр"
end- только цифры
- есть цифры
- нет цифр
- Ничего не выведет
Для регулярного выражения
Regexp#=== проверяет совпадение со строкой. Первый шаблон требует, чтобы строка целиком (\A...\z) состояла из цифр — не подходит. Второй находит цифру где угодно, и срабатывает первая подходящая ветка.Что выведет этот код (Ruby 3.3)?
i = 0
i += 1 while i < 5
puts "готово" unless i < 5
p i- готово, затем 5
- только 5
- готово, затем 4
- только 4
Модификатор
while проверяет условие перед каждой итерацией: цикл завершится, когда i станет 5. unless — это if с отрицанием: строка выполнится, потому что i < 5 ложно. Модификаторы удобны для коротких однострочных условий и циклов.Что выведет этот код (Ruby 3.3)?
i = 10
begin
i += 1
end while i < 5
p i- 10
- 5
- 11
- Бесконечный цикл
Конструкция
begin ... end while условие — особый случай: тело выполняется хотя бы один раз до проверки (аналог do-while). Поэтому i станет 11, после чего условие окажется ложным. Обычный модификатор i += 1 while i < 5 не выполнился бы ни разу. Сам Matz советует вместо этого писать loop с break.Что выведет этот код (Ruby 3.3)?
i = 0
result = loop do
i += 1
break i * 10 if i == 3
end
p result- nil
- 3
- 30
- 20
break с аргументом прерывает loop и делает этот аргумент значением всего выражения loop, поэтому result равен 30. Без аргумента break вернул бы nil. То же работает в while и в итераторах вроде each.Что вернёт
[1, 2, 3].map { |x| next 0 if x == 2; x * 10 }?- [10, nil, 30]
- [10, 30]
- [10, 20, 30]
- [10, 0, 30]
next в блоке завершает текущую итерацию, и его аргумент становится значением блока для этого элемента: map кладёт 0 на место второго элемента. Без аргумента next дал бы nil. Элементы map не пропускает — для этого есть filter_map или select.Что выведет этот код (Ruby 3.3)?
r = 3.times { |i| print i }
puts
s = 1.upto(3) { |i| print i }
puts
p [r, s]- 012, 123, затем [3, 1]
- 012, 123, затем [nil, nil]
- 123, 123, затем [3, 3]
- 012, 123, затем [[0, 1, 2], [1, 2, 3]]
n.times перебирает числа от 0 до n - 1, а upto — от получателя до аргумента включительно. Оба метода с блоком возвращают свой получатель (3 и 1), а не массив и не nil. Массив значений дало бы, например, 3.times.map { ... }.Что выведет этот код?
result = catch(:found) do
[[1, 2], [3, 4]].each do |row|
row.each { |x| throw :found, x * 10 if x > 2 }
end
:none
end
p result30—throwвыходит сразу из обоих циклов, и его аргумент становится значениемcatch:none—throwпрерывает только внутреннийeach40—catchвозвращает значение последнего выполненногоthrowUncaughtThrowError—throwперехватывается только черезrescue
catch(:tag) выполняет блок, а throw :tag, value мгновенно раскручивает стек до соответствующего catch — сквозь любые вложенные блоки и вызовы методов, — и catch возвращает value (без второго аргумента — nil). Первым условию x > 2 удовлетворяет 3, поэтому результат 30, а до 4 дело не доходит. Если блок завершился без throw, catch вернул бы значение блока (:none). Это не исключения: throw без подходящего catch вызывает UncaughtThrowError; приём удобен для выхода из глубоко вложенных циклов, где break прервал бы лишь один уровень.Переменные и видимость6
Что выведет этот код (Ruby 3.3)?
for i in 1..3
end
p i
[1, 2].each { |j| }
p defined?(j)- NameError на строке p i
- nil и nil
- 3 и "local-variable"
- 3 и nil
Цикл
for не создаёт новой области видимости: переменная i остаётся доступна после цикла со значением последней итерации 3. Параметр блока j локален для блока, снаружи его нет, и defined?(j) возвращает nil. Это одна из причин, почему в Ruby предпочитают each вместо for.Что выведет этот код (Ruby 3.3)?
x = 10
def show
puts x
end
show- 10
- nil (пустая строка)
- NameError (undefined local variable or method x)
- 0
def открывает новую область видимости и не видит локальные переменные снаружи — в отличие от блоков. Внутри show имя x не определено ни как переменная, ни как метод, поэтому бросается NameError. Нужно передать значение аргументом или использовать константу.Что выведет этот код (Ruby 3.3)?
total = 0
[1, 2, 3].each { |n| total += n }
p total- 0
- 6
- NameError
- nil
Блок — это замыкание: он видит и может изменять локальные переменные области, в которой создан. Поэтому
total накапливает сумму 1 + 2 + 3 = 6. В отличие от блока, тело метода def внешних локальных переменных не видит.Что выведет этот код (Ruby 3.3)?
$count = 0
def inc
$count += 1
end
inc
inc
p $count- 0
- 1
- 2
- NameError
Переменные с
$ — глобальные, они видны везде, в том числе внутри методов, поэтому два вызова inc дают 2. Без $ (count) внутри метода была бы новая локальная переменная и NoMethodError на nil. На практике глобальных переменных избегают.Что выведет этот код (Ruby 3.3)?
x = 5
p defined?(x)
p defined?(y)
p defined?(puts)- "local-variable", nil, "method"
- true, false, true
- "local-variable", затем NameError
- 5, nil, nil
defined? — ключевое слово, а не метод: оно не вычисляет выражение и не бросает NameError для неизвестного имени. Оно возвращает строку с описанием ("local-variable", "method", "expression" и т. п.) или nil, если имя не определено, а не true/false.Что выведет этот код (Ruby 3.3)?
LIMIT = 10
LIMIT = 20
puts LIMIT- NameError: константу нельзя переприсвоить
- Предупреждение already initialized constant, затем 20
- 10 — повторное присваивание игнорируется
- 20 без каких-либо предупреждений
Константы в Ruby можно переприсвоить, но интерпретатор выводит warning
already initialized constant LIMIT, и значение меняется на 20. Изменение самого объекта (NAMES << "x" для массива) не даст даже предупреждения — для защиты нужен freeze. А присваивание константы внутри def — это уже SyntaxError (dynamic constant assignment).Вывод и форматирование5
Что выведет этот код (Ruby 3.3)?
x = puts "hi"
p x- hi, затем "hi"
- "hi", затем nil
- hi, затем nil
- hi, затем true
puts выводит строку без кавычек и всегда возвращает nil. А p и pp возвращают свой аргумент, поэтому их можно вставлять в выражения для отладки. "hi" в кавычках выводит p, так как использует inspect.Что выведет этот код (Ruby 3.3)?
puts [1, [2, 3]]- [1, [2, 3]]
- 1, 2 и 3 — каждое на своей строке
- 1 [2, 3]
- 123
puts с массивом рекурсивно разворачивает его и выводит каждый элемент на отдельной строке, в том числе элементы вложенных массивов. Чтобы увидеть структуру [1, [2, 3]], используют p или puts arr.inspect. Слитный 123 вывел бы print с элементами по отдельности.Что выведет этот код (Ruby 3.3)?
x = p(1, 2)
p x- 1, 2, затем [1, 2]
- 1, 2, затем nil
- [1, 2], затем [1, 2]
- 1, 2, затем 1
p с несколькими аргументами выводит каждый на отдельной строке и возвращает их в виде массива [1, 2]. С одним аргументом p возвращает сам аргумент, без аргументов — nil. puts в любом случае вернул бы nil.Какую строку вернёт
format("%05.1f", 3.14159)?- 3.14159
- 03.14
- 003.1
- 3.1000
В
%05.1f число .1 задаёт один знак после точки (3.1), 5 — минимальную ширину всего поля с учётом точки, а ведущий 0 — заполнение нулями. Строка 3.1 из 3 символов дополняется до 5: 003.1. Ширина не означает «5 знаков после запятой».Какую строку вернёт
"%s: %d шт., %.2f руб." % ["Яблоки", 7, 2.5]?- Яблоки: 7 шт., 2.5 руб.
- Яблоки: 7 шт., 2.50 руб.
- ArgumentError
- %s: %d шт., %.2f руб.
Оператор
String#% работает как format: подставляет элементы массива в спецификаторы по порядку. %s — строка, %d — целое, %.2f — число с ровно двумя знаками после точки, поэтому 2.5 выводится как 2.50. Несколько значений передаются массивом.Основы синтаксиса1
Что выведет этот код (Ruby 3.3)?
a, b = 1, 2
a, b = b, a
p [a, b]- [2, 2]
- [1, 1]
- SyntaxError
- [2, 1]
Параллельное присваивание сначала вычисляет все значения справа (
[2, 1]), а затем присваивает их переменным слева. Поэтому обмен значений не требует временной переменной. Ответ [2, 2] получился бы при последовательных присваиваниях a = b; b = a.Массивы11
Что вернёт выражение
[1, 2, 3, 4, 5][-2..]?- [4]
- [4, 5]
- [5, 4]
- [2, 3, 4, 5]
a[-2..] — бесконечный диапазон от предпоследнего элемента до конца массива, порядок элементов сохраняется. Отрицательный индекс считается с конца (-1 — последний), поэтому -2 — это 4, а не «два элемента с начала».Что выведет этот код?
a = [1, 2, 3]
a.unshift(0)
a << 4
a.shift
p a- [1, 2, 3, 4]
- [0, 1, 2, 3]
- [0, 1, 2, 3, 4]
- [1, 2, 3]
unshift добавляет в начало, << (как и push) — в конец, а shift удаляет и возвращает ПЕРВЫЙ элемент (0). Удаление с конца делает pop — их часто путают.Что выведет этот код?
a = Array.new(3, [])
a[0] << 1
p a- [[1], [], []]
- [1, [], []]
- [[], [], []]
- [[1], [1], [1]]
Array.new(3, []) кладёт в массив три ссылки на ОДИН и тот же объект-массив, поэтому << в «первый» элемент виден во всех трёх. Чтобы получить независимые объекты, используют блочную форму Array.new(3) { [] }.Какой вариант создаёт массив из трёх НЕЗАВИСИМЫХ пустых массивов (изменение одного не затрагивает остальные)?
- Array.new(3, [])
- [[]] * 3
- Array.new(3) { [] }
- Array.new(3, [].dup)
Блок выполняется для каждого элемента и каждый раз создаёт новый
[]. Во всех остальных вариантах объект создаётся один раз (в том числе [].dup — дублируется лишь однажды, до вызова), а потом в массив кладутся три ссылки на него.Что вернёт выражение
[1, [2, nil, [3]], nil].flatten.compact?- [1, 2, nil, 3]
- [1, 2, 3]
- [1, [2, 3]]
- [1, [2, nil, [3]]]
flatten без аргумента раскрывает вложенность на всю глубину: [1, 2, nil, 3, nil], а compact затем удаляет все nil. Если бы compact вызвали до flatten, вложенный nil остался бы — compact не заглядывает внутрь вложенных массивов.Что вернёт выражение
[1, 2, 3].zip([:a, :b])?- [[1, :a], [2, :b], [3, nil]]
- [[1, :a], [2, :b]]
- [1, :a, 2, :b, 3]
- Исключение ArgumentError
Длину результата
zip определяет получатель ([1, 2, 3]); недостающие элементы аргумента заменяются на nil. Обрезания до более короткой длины и ошибки нет, а результат — массив пар, а не «плоский» массив.Что выведет этот код?
a, *b, c = 1, 2
p [a, b, c]- [1, [2], nil]
- [1, nil, 2]
- [1, [], nil]
- [1, [], 2]
При множественном присваивании переменные без звёздочки слева и справа заполняются в первую очередь:
a = 1, c = 2, а splat-переменной b достаются оставшиеся элементы — их нет, поэтому []. Splat-переменная никогда не бывает nil, только массивом (возможно пустым).Что вернёт выражение
[1, 2].product([:a, :b])?- [[1, :a], [2, :b]]
- [[1, :a], [2, :a], [1, :b], [2, :b]]
- [[1, :a], [1, :b], [2, :a], [2, :b]]
- [[1, 2], [:a, :b]]
product строит декартово произведение: каждый элемент получателя с каждым элементом аргумента, причём «внешний цикл» идёт по получателю. Попарное соединение по индексу [[1, :a], [2, :b]] — это zip, а не product.Что вернут выражения
[].first и [].first(2)?- nil и nil
- nil и []
- [] и []
- Исключение IndexError и []
first без аргумента возвращает элемент (у пустого массива — nil), а first(n) всегда возвращает массив, даже пустой. Это удобно: результат first(n) можно сразу перебирать без проверки на nil.Что выведет этот код?
a = [1, 1, 2, 3, 1]
p a - [1]
p a - [1, 1][1, 2, 3, 1]и[2, 3, 1]— вычитается по одному вхождению на каждый элемент аргумента[1, 2, 3]и[2, 3]—-сначала убирает дубликаты, как у множеств[2, 3]иArgumentError— элементы аргумента не должны повторяться[2, 3]и[2, 3]— удаляются все вхождения
Array#- возвращает новый массив без *всех* элементов, которые встречаются в аргументе (сравнение через hash/eql?), сколько бы раз они ни повторялись; повторы в самом аргументе ничего не меняют. Порядок и дубликаты оставшихся элементов сохраняются: [2, 2, 3] - [3] → [2, 2]. Чтобы убрать только одно вхождение, используют a.delete_at(a.index(1)) (изменяет a).Что выведет этот код?
a = [1, 2, 3, 4]
p a.rotate
p a.rotate(-1)
p a[4, 1, 2, 3],[2, 3, 4, 1],[1, 2, 3, 4][2, 3, 4, 1],[4, 1, 2, 3],[1, 2, 3, 4][2, 3, 4, 1],[1, 2, 3, 4],[1, 2, 3, 4]— второй вызов отменяет первый[2, 3, 4, 1],[4, 1, 2, 3],[4, 1, 2, 3]—rotateизменяет массив на месте
Array#rotate возвращает новый массив, сдвинутый влево на n позиций (по умолчанию на одну): первый элемент уходит в конец. Отрицательный аргумент сдвигает вправо — rotate(-1) переносит последний элемент в начало. Оба вызова работают с исходным a, который не меняется; для сдвига на месте есть rotate!.Хеши11
Что выведет этот код (Ruby 3.3)?
h = Hash.new([])
h[:a] << 1
h[:b] << 2
p h
p h[:c]- {}, затем [1, 2]
- {:a=>[1], :b=>[2]}, затем []
- {:a=>[1, 2], :b=>[1, 2]}, затем [1, 2]
- {}, затем []
Значение по умолчанию
Hash.new([]) — один общий объект, который возвращается для отсутствующих ключей, но НЕ записывается в хеш. h[:a] << 1 мутирует этот общий массив, поэтому хеш остаётся пустым, а любой отсутствующий ключ возвращает уже [1, 2].Нужен хеш, в котором
h[key] << value накапливает значения по ключу. Какая инициализация работает правильно?- Hash.new([])
- Hash.new { [] }
- Hash.new([].freeze)
- Hash.new { |hash, key| hash[key] = [] }
Блок вызывается для каждого отсутствующего ключа, создаёт новый массив и сохраняет его в хеш.
Hash.new([]) делит один массив между всеми ключами и ничего не сохраняет; Hash.new { [] } возвращает новый массив, но не записывает его — << уходит «в никуда»; с freeze получим FrozenError.Дано
h = { a: 1 }. Что произойдёт при вызове h.fetch(:b)?- Вернётся nil
- Вернётся 0
- Исключение KeyError
- Исключение NoMethodError
fetch для отсутствующего ключа без значения по умолчанию и без блока бросает KeyError. Именно этим он отличается от h[:b], который тихо вернёт nil. Значение по умолчанию задают так: h.fetch(:b, 0) или h.fetch(:b) { |k| ... }.Что выведет этот код?
data = { user: { name: "Ann" } }
p data.dig(:user, :address, :city)- Исключение NoMethodError (undefined method for nil)
- nil
- Исключение KeyError
- {}
dig останавливается и возвращает nil, как только очередной шаг дал nil (data[:user][:address] — nil), поэтому цепочка безопасна. Цепочка data[:user][:address][:city] упала бы с NoMethodError на nil.Что выведет этот код (Ruby 3.3)?
h = { a: 1, b: 2 }
h2 = h.transform_values { |v| v * 10 }
p h- {:a=>1, :b=>2}
- {:a=>10, :b=>20}
- [10, 20]
- nil
transform_values возвращает НОВЫЙ хеш с теми же ключами, исходный h не меняется. Изменить хеш на месте можно с помощью transform_values!.Что вернёт выражение
%w[a b a c a].tally (вывод в формате p Ruby 3.3)?- {"a"=>3}
- [["a", 3], ["b", 1], ["c", 1]]
- {:a=>3, :b=>1, :c=>1}
- {"a"=>3, "b"=>1, "c"=>1}
tally считает количество вхождений каждого элемента и возвращает хеш «элемент => количество». Ключи — сами элементы (здесь строки, не символы), порядок — по первому появлению.Что выведет этот код?
h = { b: 1, a: 2 }
h[:c] = 3
h[:b] = 4
p h.keys- [:a, :b, :c]
- [:a, :c, :b]
- [:b, :a, :c]
- [:c, :b, :a]
Хеши в Ruby сохраняют порядок вставки ключей, сортировки нет. Перезапись значения у существующего ключа (
h[:b] = 4) не перемещает его в конец — ключ остаётся на своём месте.Дано
h = { "name" => "Ann" }. Что вернёт h[:name]?- "Ann"
- nil
- Исключение KeyError
- :name
Строка
"name" и символ :name — разные ключи, автоматического приведения нет. [] для отсутствующего ключа возвращает nil (KeyError бросил бы только fetch). Запись { name: "Ann" } создала бы ключ-символ.Что выведет этот код (Ruby 3.3)?
a = { x: 1, y: 2 }
b = { y: 10, z: 3 }
p a.merge(b) { |key, old, new| old + new }- {:x=>1, :y=>12, :z=>3}
- {:x=>1, :y=>10, :z=>3}
- {:x=>1, :y=>2, :z=>3}
- {:y=>12}
Блок
merge вызывается только для ключей, которые есть в обоих хешах, и его результат становится значением: 2 + 10 = 12. Без блока победило бы значение из аргумента (10). Остальные ключи просто переносятся.Что выведет этот код (Ruby 3.3, без magic comment
frozen_string_literal)?k = "a"
h = {}
h[k] = 1
k << "b"
p h- {"ab"=>1}
- Исключение FrozenError на строке k << "b"
- {"a"=>1, "ab"=>1}
- {"a"=>1}
При использовании незамороженной строки как ключа хеш сохраняет её замороженную копию, поэтому последующее изменение
k на ключ не влияет. Сама k не замораживается — << работает без ошибки. Так Ruby защищает хеш от «испорченных» ключей с изменившимся hash.Что выведет этот код?
h = { a: 1, b: 2 }
p h.values_at(:a, :c)
p h.fetch_values(:a, :c) { |k| k.to_s }
p h.fetch_values(:a, :c)[1, nil],[1, "c"],[1, nil][1],[1, "c"],[1]— отсутствующие ключи пропускаются[1, nil],[1, "c"], затем исключениеKeyError[1, nil], затемKeyError— блок уfetch_valuesигнорируется
values_at возвращает значения в порядке переданных ключей, подставляя для отсутствующих значение по умолчанию хеша — здесь nil. fetch_values — строгая версия, как fetch для одного ключа: если передан блок, значение для пропущенного ключа вычисляется им (блок получает ключ, отсюда "c"), а без блока бросается KeyError (key not found: :c). Это удобно, когда отсутствие ключа — ошибка в данных, которую нельзя молча превращать в nil.Диапазоны6
Что вернёт выражение
(1...5).to_a?- [1, 2, 3, 4, 5]
- [2, 3, 4]
- [1, 2, 3, 4]
- [1, 5]
Три точки
... — диапазон, исключающий конец, две точки .. — включающий. Поэтому 1...5 — это числа от 1 до 4.Что выведет этот код?
r = (1..)
p r.first(3)- Бесконечный цикл
- [1, 2, 3]
- Исключение RangeError
- [1]
(1..) — бесконечный (endless) диапазон. first(3) перебирает элементы и останавливается после трёх, поэтому работает. А вот r.to_a действительно бросил бы RangeError (cannot convert endless range to an array).Что вернёт выражение
(1..10).step(3).to_a?- [1, 4, 7, 10]
- [1, 4, 7]
- [3, 6, 9]
- [1, 3, 5, 7, 9]
step(3) начинает с начала диапазона и прибавляет по 3: 1, 4, 7, 10. Конец 10 входит в диапазон .., поэтому включён. Шаг не означает «числа, кратные 3».Что выведет этот код?
r = "a".."z"
p r.include?("bb")
p r.cover?("bb")- true и true
- false и false
- true и false
- false и true
cover? лишь сравнивает границы: "a" <= "bb" <= "z" — истина. include? для строковых диапазонов проверяет, является ли значение одним из элементов перебора "a", "b", ..., "z", а "bb" среди них нет. Для числовых диапазонов оба метода ведут себя одинаково.Что выведет этот код?
age = 15
res = case age
when 0..12 then "child"
when 13...18 then "teen"
else "adult"
end
puts res- child
- adult
- teen
- Пустую строку (res равен nil)
case/when сравнивает через ===, а Range#=== проверяет попадание значения в диапазон. 15 попадает в 13...18 (13..17), поэтому результат — "teen".Что выведет этот код?
r = ("a".."d")
p r.include?("bb")
p r.cover?("bb")
p r.to_atrue,true,["a", "b", "c", "d"]— для строкinclude?иcover?работают одинаковоfalse,true,["a", "b", "c", "d"]—include?перебирает элементы диапазона (a,b,c,d), аcover?сравнивает по<=>:"a" <= "bb" <= "d"false,false,["a", "b", "c", "d"]—"bb"длиннее одного символа и не попадает в диапазон ни по одному методуTypeError—cover?работает только с числовыми диапазонами
cover? проверяет только порядок через <=>: "bb" лексикографически между "a" и "d", поэтому true. include? (и member?) для строковых диапазонов проходит по элементам, которые порождает String#succ: a, b, c, d — "bb" среди них нет, поэтому false. Для числовых диапазонов include? ведёт себя как cover? (не перебирает), а для Time или бесконечных диапазонов перебор невозможен, и выручает именно cover?. Оператор ===, который используется в case, с Ruby 2.6 для всех диапазонов работает как cover?: case "bb" when "a".."d" сработает.Enumerable12
Что выведет этот код?
r = [1, 2, 3].each { |x| x * 2 }
p r- [2, 4, 6]
- [1, 2, 3]
- nil
- 6
each используется ради побочных эффектов и возвращает сам получатель, результаты блока отбрасываются. Чтобы собрать результаты блока в новый массив, нужен map.Что вернут выражения
[].reduce(:+) и [].sum?- nil и 0
- 0 и 0
- nil и nil
- Исключение TypeError и 0
reduce(:+) без начального значения берёт первым аккумулятором первый элемент; у пустого массива его нет, поэтому результат nil. sum по умолчанию начинает с 0. Безопасный вариант — reduce(0, :+).Что выведет этот код?
even, odd = (1..5).partition(&:even?)
p even
p odd- [1, 3, 5] и [2, 4]
- {true=>[2, 4], false=>[1, 3, 5]} и nil
- [2, 4] и nil
- [2, 4] и [1, 3, 5]
partition возвращает массив из двух массивов: сначала элементы, для которых блок истинен, затем остальные; деструктуризация раскладывает их по переменным. Хеш с ключами true/false вернул бы group_by.Что вернёт выражение
[1, 2, 3, 4, 5].each_slice(2).to_a?- [[1, 2], [3, 4]]
- [[1, 2], [2, 3], [3, 4], [4, 5]]
- [[1, 2], [3, 4], [5]]
- [[1, 3, 5], [2, 4]]
each_slice(n) режет коллекцию на непересекающиеся куски по n элементов; последний кусок может быть короче, он не отбрасывается. Перекрывающееся «скользящее окно» [[1, 2], [2, 3], ...] даёт each_cons(2).Что вернёт выражение
[1, 4, 9, 16].each_cons(2).map { |a, b| b - a }?- [3, 7]
- [3, 5, 7]
- [[1, 4], [9, 16]]
- [3, 5, 7, -16]
each_cons(2) даёт скользящее окно соседних пар [1, 4], [4, 9], [9, 16], и блок с двумя параметрами распаковывает каждую пару. Непересекающиеся пары [1, 4], [9, 16] (и результат [3, 7]) дал бы each_slice(2).Что вернёт выражение
[1, 2, 4, 5, 6, 9].chunk_while { |a, b| b == a + 1 }.to_a?- [[1, 2], [4, 5, 6], [9]]
- [[1, 2, 4, 5, 6], [9]]
- [[1, 2], [4, 5, 6]]
- [[2], [5, 6]]
chunk_while проходит по соседним парам и начинает новую группу, когда блок вернул ложь. Так получаются серии подряд идущих чисел; одиночный элемент 9 образует собственную группу и не теряется.Что выведет этот код?
r = [[1, 2], [3]].flat_map { |a| a.map { |x| x * 10 } }
p r- [[10, 20], [30]]
- [[10], [20], [30]]
- Исключение NoMethodError (undefined method map for Integer)
- [10, 20, 30]
flat_map сначала применяет блок к каждому элементу (здесь — к подмассивам [1, 2] и [3]), а затем «сплющивает» результаты на один уровень. Обычный map вернул бы [[10, 20], [30]].Что выведет этот код?
r = (1..Float::INFINITY).lazy
.map { |x| x * 2 }
.select { |x| x % 3 == 0 }
.first(3)
p r- Бесконечный цикл
- [2, 4, 6]
- [6, 12, 18]
- #<Enumerator::Lazy: ...>
lazy обрабатывает элементы по одному через всю цепочку, а first(3) — энергичный метод: он забирает три подходящих элемента, возвращает массив и прекращает перебор. Без lazy map попытался бы обработать бесконечный диапазон целиком и не завершился бы.Что вернёт выражение
%w[apple avocado banana].group_by { |w| w[0] } (вывод в формате p Ruby 3.3)?- {"a"=>2, "b"=>1}
- {"a"=>["apple", "avocado"], "b"=>["banana"]}
- [["apple", "avocado"], ["banana"]]
- {"apple"=>"a", "avocado"=>"a", "banana"=>"b"}
group_by возвращает хеш: ключ — результат блока, значение — массив исходных элементов с этим ключом. Подсчёт количества ({"a"=>2, ...}) — это tally или group_by + transform_values(&:size).Найдите ошибку: что произойдёт при выполнении этого кода?
counts = %w[a b a].each_with_object(Hash.new(0)) do |h, w|
h[w] += 1
end
p counts- Исключение TypeError: параметры блока перепутаны местами
- {"a"=>2, "b"=>1}
- {}
- ["a", "b", "a"]
В
each_with_object блок получает сначала элемент, потом объект-мемо (|w, h|), — в отличие от inject, где сначала аккумулятор. Здесь h — строка "a", а w — хеш, и "a"[{}] падает с TypeError (no implicit conversion of Hash into Integer).Что напечатает этот код?
[1, 2, 3].lazy
.map { |x| print "m#{x} "; x }
.select { |x| print "s#{x} "; x.odd? }
.first(1)- m1 m2 m3 s1 s2 s3
- m1 m2 m3 s1
- Ничего: без force ленивая цепочка не выполняется
- m1 s1
Ленивый перечислитель проводит каждый элемент через всю цепочку
map → select, прежде чем взять следующий. Первый же элемент проходит фильтр, first(1) получает результат и останавливает перебор. Без lazy сначала отработал бы весь map, затем весь select. first сам запускает вычисление, отдельный force не нужен.Что выведет этот код?
a = [1, 2, 5, 1, 6]
p a.take_while { |x| x < 3 }
p a.drop_while { |x| x < 3 }
p a.select { |x| x < 3 }[1, 2],[5, 1, 6],[1, 2, 1][1, 2, 1],[5, 6],[1, 2, 1][1, 2],[5, 6],[1, 2, 1][1, 2, 1],[5, 1, 6],[1, 2]
take_while берёт элементы с начала, пока блок возвращает истину, и останавливается на первом ложном — на 5; дальше ничего не проверяется, поэтому вторая 1 не попадает в результат. drop_while — зеркальная операция: отбрасывает тот же префикс и возвращает весь остаток, включая 1. select проверяет каждый элемент независимо. Из-за раннего выхода (1..).take_while { |x| x < 3 } на бесконечном диапазоне вернёт [1, 2], а select зациклится.Блоки5
Что выведет этот код?
def twice
yield
yield
end
n = 0
twice { n += 1 }
p n- 1
- 0
- 2
- Исключение NameError: n не видна в блоке
yield вызывает переданный блок — здесь дважды. Блок является замыканием и видит локальную переменную n из места, где он написан, поэтому изменяет именно её.Что выведет этот код?
def greet
return "no block" unless block_given?
yield("Ann")
end
p greet
p greet { |n| "Hi, #{n}" }- Исключение LocalJumpError на первом вызове
- "no block" и "Hi, Ann"
- nil и "Hi, Ann"
- "no block" и "no block"
block_given? возвращает true, только если методу передан блок. Проверка спасает от LocalJumpError (no block given), который бросил бы yield без блока. yield возвращает значение блока, оно же становится результатом метода.Что выведет этот код?
def run(&block)
block.call(2) + block.(3)
end
p run { |x| x * 10 }- 50
- 20
- 30
- Исключение NoMethodError на block.(3)
Параметр
&block превращает переданный блок в объект Proc. .call(2) и .(3) — равноценные способы его вызова (.() — синтаксический сахар для call): 20 + 30 = 50.Что выведет этот код?
r = [1, 2, 3, 4].map do |x|
next 0 if x.even?
x * 10
end
p r- [10, 30]
- [10, nil, 30, nil]
- [10]
- [10, 0, 30, 0]
next внутри блока завершает текущую итерацию, и его аргумент становится значением блока для этого элемента. map не выкидывает элементы, поэтому на месте чётных стоит 0. Без аргумента next дал бы nil; прекратить весь перебор можно с помощью break.Что вернёт вызов
first_big([3, 8, 12, 20])?def first_big(nums)
nums.each { |n| break n * 10 if n > 5 }
end
p first_big([3, 8, 12, 20])80—breakс аргументом прерываетeachи делает это значение результатом вызоваeach, а он — последнее выражение метода[3, 8, 12, 20]—eachвсегда возвращает исходный массивnil—breakвнутри блока не возвращает значенийLocalJumpError— из блока нельзя выйти черезbreak
break в блоке завершает не блок, а *метод, которому блок передан*: each прекращает перебор, и его результатом становится аргумент break (80); без аргумента вернулся бы nil. Именно поэтому each вернёт исходный массив только при полном проходе. next же завершает лишь текущую итерацию и задаёт значение блока для этой итерации (важно для map), а return в блоке выходит из метода first_big целиком. LocalJumpError возникает для break внутри proc, вызванного после того, как создавший его метод уже завершился.Proc и lambda8
Что выведет этот код?
pr = proc { |a, b| [a, b] }
la = lambda { |a, b| [a, b] }
p pr.call(1)
p la.call(1)- Исключение ArgumentError уже на pr.call(1)
- [1, nil] и [1, nil]
- [1, nil], затем исключение ArgumentError
- [1] и [1]
Proc нестрог к количеству аргументов: недостающие становятся
nil, лишние отбрасываются. Lambda проверяет арность как обычный метод, поэтому вызов с одним аргументом вместо двух даёт ArgumentError.Что выведет этот код?
def test_proc
pr = Proc.new { return 1 }
pr.call
2
end
def test_lambda
la = -> { return 1 }
la.call
2
end
p test_proc
p test_lambda- 2 и 2
- 1 и 2
- 1 и 1
- 2 и 1
return в proc выходит из метода, в котором proc был создан, поэтому test_proc возвращает 1, и строка 2 не выполняется. return в lambda выходит только из самой lambda, как из метода, и test_lambda продолжает работу и возвращает 2.Что произойдёт при выполнении этого кода?
def make
Proc.new { return 42 }
end
pr = make
p pr.call- Исключение LocalJumpError
- Выведет 42
- Выведет nil
- Исключение ArgumentError
return в proc пытается выйти из метода make, где proc был создан, но этот метод уже завершился — возвращаться некуда, отсюда LocalJumpError (unexpected return). С lambda (-> { return 42 }) вызов вернул бы 42.Дано
sq = ->(x) { x * x }. Какой вызов НЕ сработает?- sq.call(4)
- sq.(4)
- sq[4]
- sq(4)
sq — локальная переменная с объектом Proc, а не метод, поэтому sq(4) ищет метод sq и падает с NoMethodError. Proc/lambda вызываются через call, .(), [] (или yield, если передан как блок).Что выведет этот код?
add = ->(a, b, c) { a + b + c }
add5 = add.curry[2][3]
p add5[10]- 10
- Исключение ArgumentError
- 15
- #<Proc:0x... (lambda)>
curry превращает lambda от трёх аргументов в цепочку функций от одного: пока аргументов меньше трёх, возвращается новая каррированная lambda. После [2][3] остаётся ждать c, и add5[10] вычисляет 2 + 3 + 10 = 15.Что выведет этот код?
x = 1
add_x = ->(n) { n + x }
x = 100
p add_x.(1)- 2
- 101
- 1
- Исключение NameError
Замыкание захватывает саму переменную (привязку), а не её значение на момент создания lambda. К моменту вызова
x уже равен 100, поэтому результат — 101.Что выведет этот код?
def double(x)
x * 2
end
p [1, 2, 3].map(&method(:double))- [2, 4, 6]
- [1, 2, 3]
- Исключение NoMethodError
- Исключение ArgumentError
method(:double) возвращает объект Method, а & превращает его в блок через to_proc, поэтому каждый элемент передаётся в double. Это аналог map { |x| double(x) }.Чему эквивалентна запись
%w[a b].map(&:upcase)?- map { |s| upcase(s) }
- map { |s| s.upcase! }
- map(:upcase)
- map { |s| s.upcase }
&:upcase вызывает Symbol#to_proc: получается блок, который вызывает метод upcase у каждого элемента. Это не вызов функции upcase(s) и не bang-версия; а map(:upcase) вообще упадёт с ArgumentError, так как map не принимает аргументов.Итераторы3
Что выведет этот код?
r = %w[a b].map.with_index(1) { |s, i| "#{i}. #{s}" }
p r- ["0. a", "1. b"]
- ["a", "b"]
- ["1. a", "2. b"]
- Исключение ArgumentError
map без блока возвращает перечислитель, а with_index(1) задаёт начальное значение индекса, поэтому нумерация начинается с 1. each_with_index начальный индекс не принимает (его аргументы уходят в each) — для нумерации с единицы используют each.with_index(1) или map.with_index(1).Что выведет этот код?
e = [10, 20].each
loop do
puts e.next
end
puts "done"- 10, 20, затем исключение StopIteration
- 10, 20, done (каждое с новой строки)
- Бесконечно печатает 10
- Бесконечно печатает 10 и 20 по кругу
Внешний перечислитель отдаёт значения по одному через
next, а после последнего бросает StopIteration. loop перехватывает именно это исключение и тихо завершает цикл, поэтому выполнение доходит до puts "done".Что вернёт выражение
3.times.map { |i| i * 2 }?- [0, 2, 4]
- [2, 4, 6]
- [0, 1, 2]
- 3
times без блока возвращает перечислитель значений 0, 1, 2 (счёт с нуля), а map удваивает каждое. Вызов 3.times { ... } с блоком вернул бы само число 3.Классы и объекты15
Какие методы создаёт
attr_accessor :name?- Только геттер
name - Геттер
nameи сеттерname= - Только сеттер
name= - Константу
NAMEи геттерname
attr_accessor = attr_reader + attr_writer: создаёт метод чтения name (возвращает @name) и метод записи name=. Только геттер создаёт attr_reader, только сеттер — attr_writer.Что произойдёт при выполнении кода?
class Point
def initialize(x, y)
@x = x
@y = y
end
end
p Point.new(1)- Выведет
#<Point @x=1, @y=nil> - Выведет
nil - Ошибка NoMethodError
- Ошибка ArgumentError (given 1, expected 2)
Point.new передаёт аргументы в initialize, а обязательные позиционные параметры в Ruby строго проверяются: при нехватке аргумента выбрасывается ArgumentError. Недостающие параметры не заполняются nil автоматически — для этого нужно значение по умолчанию (y = nil).Что выведет этот код (Ruby 3.3)?
class User
def name
@name
end
end
p User.new.name- Ошибка NameError
- ""
- nil
- Ошибка NoMethodError
Обращение к неинициализированной переменной экземпляра возвращает
nil без ошибки (в Ruby 3.0+ даже без предупреждения). NameError возникает для неизвестных локальных переменных/методов, а не для @-переменных — из-за этого опечатки в имени @-переменной легко пропустить.Что выведет этот код?
class Animal
@@count = 0
def self.inc; @@count += 1; end
def self.count; @@count; end
end
class Dog < Animal; end
class Cat < Animal; end
Dog.inc
Cat.inc
p Animal.count- 0
- 2
- 1
- Ошибка NameError
Переменная класса
@@count одна на всю иерархию: Animal, Dog и Cat разделяют одно и то же значение. Оба вызова увеличивают общий счётчик, поэтому 2. Это классическая ловушка @@ — если нужен отдельный счётчик на каждый подкласс, используют переменные экземпляра класса (@count в теле класса).Что выведет этот код?
class Animal
@count = 0
class << self
attr_accessor :count
end
end
class Dog < Animal; end
p Dog.count- nil
- 0
- Ошибка NoMethodError
- Ошибка NameError
@count в теле класса — переменная экземпляра объекта Animal (class instance variable), она не наследуется. Метод доступа count при этом наследуется Dog (через singleton-класс), но читает @count у объекта Dog, где она не задана, — отсюда nil. В отличие от @@-переменных, подклассы не делят это значение.Как правильно объявить метод класса
build (вызываемый как Report.build)?static def build ... endвнутри тела классаdef @@build ... endвнутри тела класса- Любой
def buildв классе уже доступен какReport.build def self.build ... endвнутри тела класса
Методы класса — это синглтон-методы объекта-класса, поэтому объявляются как
def self.build (или внутри class << self). Ключевого слова static в Ruby нет, а обычный def build создаёт метод экземпляра, доступный только через Report.new.build.Что выведет этот код?
class Greeter
def hi = "hi"
end
class Greeter
def bye = "bye"
end
class Greeter
def hi = "hello"
end
g = Greeter.new
puts g.hi + " " + g.bye- hello bye
- hi bye
- Ошибка: класс Greeter уже определён
- Ошибка NoMethodError: bye
Классы в Ruby открыты: повторное
class Greeter не создаёт новый класс, а дописывает существующий. Методы добавляются, а одноимённые — переопределяются последним определением. На этом построен monkey patching (и его риски: можно незаметно переписать чужой метод).Что выведет этот код?
class Pt
def to_s = "pt"
def inspect = "Pt()"
end
pt = Pt.new
puts pt
p pt
puts "#{pt}"- Pt(); Pt(); Pt()
- pt; Pt(); pt
- pt; pt; pt
- pt; Pt(); Pt()
puts и интерполяция строк используют to_s (представление для пользователя), а p — inspect (отладочное представление). Поэтому to_s переопределяют для вывода, а inspect — для отладки в консоли и логах.Что выведет этот код?
class Key
attr_reader :id
def initialize(id)
@id = id
end
def ==(other)
other.is_a?(Key) && id == other.id
end
end
h = { Key.new(1) => "a" }
p h[Key.new(1)]- nil
- "a"
- Ошибка KeyError
- Ошибка NoMethodError
Hash сравнивает ключи не через
==, а через hash и eql?. Здесь они унаследованы от Object и основаны на идентичности объекта, поэтому новый Key.new(1) даёт другой хеш и ключ не находится — [] возвращает nil (KeyError бросает только fetch).Какие методы нужно переопределить в классе
Money, чтобы [Money.new(5), Money.new(5)].uniq вернул один элемент?==и===- Только
== <=>иto_seql?иhash
uniq, Hash и Set определяют одинаковость через пару hash + eql?: равные объекты обязаны давать одинаковый hash. Переопределение только == на них не влияет. Обычно делают alias eql? == и def hash = [self.class, amount].hash.Что произойдёт при выполнении кода?
class User
attr_accessor :name
end
u = User.new
u.freeze
c = u.clone
d = u.dup
d.name = "Bob"
p d.name
c.name = "Ann"- Ошибка FrozenError уже на
d.name = "Bob" - Выведет "Bob", ошибок не будет
- Выведет "Bob", затем ошибка FrozenError
- Ошибка FrozenError уже на
u.clone
clone копирует состояние заморозки (и синглтон-методы), поэтому c тоже заморожен и присваивание бросает FrozenError. dup создаёт незамороженную копию, и её можно менять. Нужна размороженная копия через clone — используйте clone(freeze: false).Что выведет этот код?
o = Object.new
def o.hi = "hi"
p o.clone.respond_to?(:hi)
p o.dup.respond_to?(:hi)- true; true
- true; false
- false; false
- false; true
clone копирует синглтон-класс объекта вместе с его методами (и состояние frozen), а dup копирует только переменные экземпляра и класс. Поэтому синглтон-метод hi есть у клона, но не у дубликата. Модули, подключённые через extend, ведут себя так же.Что произойдёт при выполнении кода (без magic-комментария frozen_string_literal)?
arr = ["a", "b"].freeze
arr[0] << "!"
p arr
arr << "c"- Выведет ["a!", "b"], затем ошибка FrozenError
- Ошибка FrozenError уже на второй строке
- Выведет ["a", "b"], затем ошибка FrozenError
- Выведет ["a!", "b"], ошибок не будет
freeze поверхностный: замораживается сам массив (нельзя добавлять/удалять элементы), но не объекты внутри него. Строка "a" не заморожена, поэтому << её меняет. А arr << "c" изменяет сам массив — FrozenError. Для глубокой заморозки нужно морозить и элементы (например, arr.each(&:freeze)).Что выведет этот код?
Point = Struct.new(:x, :y)
a = Point.new(1)
p a
p a == Point.new(1, nil)- #<struct Point x=1, y=nil>; false
- Ошибка ArgumentError (given 1, expected 2)
- #<Point x=1>; true
- #<struct Point x=1, y=nil>; true
Struct допускает передачу меньшего числа аргументов — недостающие поля становятся
nil. Struct автоматически определяет == по значениям полей, поэтому две структуры с одинаковыми полями равны. Формат inspect — #<struct Имя поле=значение, ...>.Что выведет этот код (Ruby 3.3)?
Coord = Data.define(:lat, :lng)
c = Coord.new(lat: 1, lng: 2)
c2 = c.with(lng: 5)
p c2
p c.respond_to?(:lat=)- #<data Coord lat=1, lng=5>; true
- #<struct Coord lat=1, lng=5>; false
- #<data Coord lat=1, lng=5>; false
- Ошибка NoMethodError: with
Data.define (Ruby 3.2+) создаёт неизменяемые value-объекты: сеттеров нет, а «изменённая копия» получается через with. В отличие от Struct, все поля обязательны (пропуск — ArgumentError), а inspect начинается с #<data.self и контекст4
Что выведет этот код?
class Counter
attr_accessor :count
def initialize
@count = 0
end
def reset
count = 10
end
end
c = Counter.new
c.reset
p c.count- 0
- 10
- nil
- Ошибка NoMethodError
Внутри метода
count = 10 создаёт локальную переменную, а не вызывает сеттер — Ruby трактует присваивание без получателя как локальное. Чтобы вызвать count=, нужно писать self.count = 10 (или @count = 10). Поэтому @count остаётся 0.Что выведет
p self внутри тела класса Foo (вне методов)?- #<Foo>
- main
- Foo
- nil
Внутри тела класса (вне методов)
self — это сам объект-класс Foo. Именно поэтому def self.x определяет метод класса. main — это self на верхнем уровне программы, а #<Foo> был бы внутри метода экземпляра.Что выведет этот код?
class Config
class << self
def load = "loaded"
attr_accessor :env
end
end
Config.env = "prod"
p Config.load
p Config.env
p Config.new.respond_to?(:env)- "loaded"; "prod"; true
- "loaded"; "prod"; false
- "loaded"; nil; false
- Ошибка NoMethodError: env=
class << self открывает синглтон-класс объекта Config, поэтому всё, что объявлено внутри — включая attr_accessor, — становится методами класса и хранит данные в переменной экземпляра класса. У экземпляров Config.new этих методов нет.Что выведет этот код?
class Secret
def initialize
@code = 42
end
end
s = Secret.new
p s.instance_eval { @code }- nil
- Ошибка NoMethodError
- Ошибка NameError
- 42
instance_eval выполняет блок, подменяя self на получателя, поэтому @code внутри блока — переменная экземпляра объекта s. Это обходит инкапсуляцию (как и instance_variable_get). Без instance_eval блок видел бы @code верхнего уровня, т. е. nil.Наследование5
Что выведет этот код?
class Base
def greet(name)
"Hi, #{name}"
end
end
class Child < Base
def greet(name)
"#{super}!"
end
end
puts Child.new.greet("Ann")- Ошибка ArgumentError
- Hi, !
- Hi, Ann!
- !
super без скобок и без аргументов («zsuper») передаёт родительскому методу те же аргументы, с которыми был вызван текущий метод, — здесь "Ann". ArgumentError был бы при super() с пустыми скобками: тогда аргументы не передаются вовсе.Что произойдёт при вызове
Child.new("x")?class Base
def initialize(name)
@name = name
end
end
class Child < Base
def initialize(name)
super()
end
end
Child.new("x")- Объект создастся,
@nameбудет"x" - Ошибка ArgumentError (given 0, expected 1)
- Объект создастся,
@nameбудетnil - Ошибка NoMethodError: super
super() с пустыми скобками явно вызывает родительский метод без аргументов, а Base#initialize требует один — отсюда ArgumentError. Неявная передача аргументов работает только для super без скобок.Что выведет этот код?
class A
def show(x)
x
end
end
class B < A
def show(x)
x = x * 2
super
end
end
p B.new.show(5)- 10
- 5
- nil
- Ошибка ArgumentError
super без скобок передаёт текущие значения переменных-параметров, а не исходные аргументы вызова. Параметр x был переприсвоен в 10 до вызова super, поэтому родитель получает 10. Многие ожидают 5, считая, что передаются «оригинальные» аргументы.Что выведет этот код (Ruby 3.3)?
class Foo; end
p Foo.ancestors- [Foo, Object, BasicObject]
- [Foo, Object]
- [Foo, BasicObject, Object, Kernel]
- [Foo, Object, Kernel, BasicObject]
Класс без явного родителя наследуется от
Object, в который подмешан модуль Kernel, а корень иерархии — BasicObject. Модули попадают в ancestors сразу после класса, в который они включены, поэтому Kernel стоит между Object и BasicObject.Что выведет
Child.new.greet("Аня")?class Parent
def greet(name, punct = "!")
"Привет, #{name}#{punct}"
end
end
class Child < Parent
def greet(name, punct = "?")
name = name.upcase
super
end
end
puts Child.new.greet("Аня")Привет, АНЯ?—superбез скобок передаёт текущие значения всех параметров метода, включая изменённыйnameиpunctпо умолчанию изChildПривет, Аня!—superвызывает метод родителя с теми аргументами, что пришли вChild#greetизначальноПривет, АНЯ!—superпередаёт только обязательные параметры, необязательные берутся из родителяArgumentError—superбез аргументов вызываетParent#greetбез параметров
Голый
super (без скобок) — это «вызови метод родителя с теми же параметрами, что у меня сейчас», причём берутся *текущие* значения переменных-параметров: name уже перезаписан на АНЯ, а punct — это "?" из значения по умолчанию в Child. Чтобы вызвать родителя без аргументов, нужны пустые скобки — super(); здесь это дало бы ArgumentError, так как name обязателен. super(name) передаст только имя, и punct возьмёт значение по умолчанию уже из Parent — "!". Блок при голом super тоже передаётся неявно.Модули и миксины10
Что выведет этот код?
module M; end
module N; end
class C
include M
prepend N
end
p C.ancestors.first(3)- [C, M, N]
- [C, N, M]
- [N, C, M]
- [M, N, C]
prepend вставляет модуль ПЕРЕД классом в цепочке поиска методов, а include — сразу ПОСЛЕ класса. Порядок вызовов include/prepend в теле класса на это не влияет. Поэтому методы N перехватывают вызовы раньше методов самого C.Что выведет этот код?
module A
def hi; "A"; end
end
module B
def hi; "B"; end
end
class C
include A
include B
end
puts C.new.hi- A
- B
- AB
- Ошибка: конфликт имён методов
Каждый
include вставляет модуль сразу после класса, поэтому последний подключённый оказывается ближе всего: C.ancestors = [C, B, A, ...]. Метод ищется по цепочке и первым находится B#hi. Конфликт имён в Ruby не ошибка — просто побеждает тот, кто раньше в цепочке.Какой вызов сработает и вернёт
"hello"?module Greet
def hello
"hello"
end
end
class User
extend Greet
endUser.helloUser.new.hello- И
User.hello, иUser.new.hello - Ни один: нужно
include Greet
extend добавляет методы модуля в синглтон-класс объекта, у которого он вызван, — здесь это сам класс User, поэтому методы становятся методами класса. Чтобы методы были у экземпляров, нужен include.Что выведет этот код?
module Loud
def speak
super.upcase
end
end
class Dog
prepend Loud
def speak
"woof"
end
end
puts Dog.new.speak- woof
- Ошибка NoMethodError (super: no superclass method)
- WOOFwoof
- WOOF
С
prepend модуль Loud стоит в цепочке перед Dog, поэтому сначала вызывается Loud#speak, а его super уходит в Dog#speak. Так prepend используют для «обёрток» вокруг методов класса. С include было бы наоборот: Dog#speak перекрыл бы метод модуля и вывел woof.Какой метод нужно определить в классе, чтобы
include Comparable дал работающие <, >, between? и clamp?==<и><=>compare_to
Comparable строит все операторы сравнения на основе
<=>, который должен возвращать -1, 0, 1 (или nil для несравнимых). == модуль тоже выводит из <=>, а не наоборот. Метода compare_to Ruby не использует — это из Java.Что выведет этот код?
class Version
include Comparable
attr_reader :n
def initialize(n)
@n = n
end
def <=>(other)
n <=> other.n
end
end
a, b, c = Version.new(1), Version.new(3), Version.new(2)
p c.between?(a, b)
p [b, a, c].max.n- false; 3
- true; 3
- true; 2
- Ошибка NoMethodError: max
between? из Comparable проверяет a <= c && c <= b, используя <=>: 1 <= 2 <= 3 — true. Array#max тоже сравнивает элементы через <=>, поэтому вернёт версию с n = 3. Отдельно определять max или > не нужно.Что выведет этот код?
class Bag
include Enumerable
def initialize(*items)
@items = items
end
def each(&block)
@items.each(&block)
self
end
end
bag = Bag.new(3, 1, 2)
p bag.sort
p bag.map { |x| x * 10 }- [1, 2, 3]; [30, 10, 20]
- [3, 1, 2]; [30, 10, 20]
- [1, 2, 3]; [10, 20, 30]
- Ошибка NoMethodError: sort
Модулю Enumerable достаточно метода
each: на нём построены map, select, sort, min и десятки других. sort возвращает новый отсортированный массив, а map сохраняет исходный порядок обхода — поэтому [30, 10, 20], а не отсортированный.Что выведет этот код?
module Util
module_function
def double(x)
x * 2
end
end
class Calc
include Util
def run = double(5)
end
p Util.double(2)
p Calc.new.run
p Calc.new.respond_to?(:double)- 4; 10; true
- 4, затем ошибка NoMethodError
- Ошибка NoMethodError на
Util.double - 4; 10; false
module_function делает для каждого метода две копии: публичный метод модуля (Util.double) и ПРИВАТНЫЙ метод экземпляра. При include метод можно вызывать внутри класса без получателя, но снаружи он не виден, поэтому respond_to?(:double) — false.Как создать экземпляр класса
Order, объявленного внутри модуля Shop, из кода вне модуля?Shop.Order.newOrder.new— модуль не влияет на имяShop::Order.newShop->Order.new
Модуль служит пространством имён: константа
Order определена внутри Shop, и снаружи к ней обращаются через оператор разрешения области ::. Точка — это вызов метода (у Shop нет метода Order), а просто Order на верхнем уровне даст NameError.Что выведет этот код?
X = "top"
module Outer
X = "outer"
class Inner; end
end
class Outer::Inner
def x = X
end
puts Outer::Inner.new.x- outer
- top
- Ошибка NameError
- nil
Константы ищутся сначала по лексической области (
Module.nesting), затем по предкам класса. При компактной записи class Outer::Inner лексическая область — только Outer::Inner, модуль Outer в неё не входит, поэтому Outer::X не находится, и поиск доходит до Object::X = "top". При вложенной записи module Outer; class Inner результат был бы "outer".Видимость методов6
Что произойдёт при выполнении кода?
class Account
def show = secret
private
def secret = 42
end
a = Account.new
p a.show
p a.secret- Выведет 42, затем ошибка NoMethodError
- Выведет 42 и 42
- Ошибка NoMethodError уже на
a.show - Выведет nil, затем 42
Приватный метод можно вызвать без явного получателя изнутри объекта, поэтому
show успешно вызывает secret. Вызов a.secret снаружи с явным получателем запрещён — NoMethodError «private method called». private без аргументов делает приватными все методы, объявленные после него.Что выведет этот код (Ruby 3.3)?
class Box
def initialize
@size = 0
end
def grow
self.size = size + 1
self.size
end
private
attr_accessor :size
end
p Box.new.grow- Ошибка NoMethodError на
self.size - Ошибка NoMethodError на
self.size = - 0
- 1
Приватный сеттер всегда можно было вызывать через
self.size = (иначе это была бы локальная переменная). А начиная с Ruby 2.7 разрешён вызов ЛЮБОГО приватного метода с литеральным получателем self., поэтому и self.size работает. В Ruby до 2.7 последняя строка дала бы NoMethodError.Что произойдёт при выполнении кода?
class Account
def initialize(balance)
@balance = balance
end
def richer_than?(other)
balance > other.balance
end
protected
attr_reader :balance
end
a = Account.new(100)
b = Account.new(50)
p a.richer_than?(b)
p a.balance- Выведет true и 100
- Ошибка NoMethodError уже на
other.balance - Выведет true, затем ошибка NoMethodError
- Выведет false, затем ошибка NoMethodError
protected-метод можно вызывать с явным получателем, но только изнутри методов объекта того же класса (или подкласса) — поэтому other.balance внутри richer_than? разрешён. Снаружи класса a.balance запрещён, как и для private. Это типичное применение protected — сравнение объектов по скрытому состоянию.Чем
protected отличается от private в Ruby?- private-методы не наследуются и недоступны в подклассах, а protected — доступны
- protected можно вызвать как
other.mиз методов того же класса, private — нет - protected-методы доступны снаружи для любых объектов того же модуля, а private — нет
- Ничем: это синонимы, оставленные для совместимости
В Ruby видимость определяется формой вызова, а не иерархией: private-метод вызывается только неявно на
self (или с литеральным self.), а protected допускает явный получатель, если вызывающий объект — kind_of? класса, где метод определён. Частое заблуждение из Java/C++: private-методы в Ruby прекрасно наследуются и доступны в подклассах.Что выведет этот код?
class Parent
private
def secret = "s"
end
class Child < Parent
def reveal = secret
end
puts Child.new.reveal- s
- Ошибка NoMethodError: private method
- nil
- Ошибка NameError
В отличие от Java/C++, private в Ruby не ограничивает доступ из подклассов: приватные методы наследуются и вызываются в подклассе без явного получателя. Ограничение одно — нельзя писать
obj.secret с явным объектом-получателем.Что выведет этот код?
class Service
private
def self.build = "built"
end
puts Service.build- Ошибка NoMethodError: private method build
- Ошибка SyntaxError
- nil
- built
private без аргументов влияет только на методы экземпляра, определяемые далее через обычный def. На синглтон-методы def self.build он не действует, поэтому Service.build остаётся публичным. Чтобы скрыть метод класса, используют private_class_method :build или private внутри class << self.Метапрограммирование11
Что выведет этот код?
greeting = "hi"
Foo = Class.new do
define_method(:a) { greeting }
def b
greeting
end
end
p Foo.new.a
p Foo.new.b- "hi"; "hi"
- Ошибка NameError уже на
Foo.new.a - "hi", затем ошибка NameError
- "hi"; nil
Блоки — замыкания: блок
Class.new и блок define_method видят локальную переменную greeting. А def открывает новую область видимости («scope gate») и внешних локальных переменных не видит, поэтому в b — NameError «undefined local variable or method». Это главный практический довод за define_method в метапрограммировании.Что вернёт выражение
ObjectSpace.each_object(Class).select { |k| k < Animal }?- Только прямые подклассы Animal
- Все загруженные классы-потомки Animal, включая непрямых, но без самого Animal
- Все живые экземпляры класса Animal и его подклассов
- Animal и все его потомки, включая сам Animal
ObjectSpace.each_object(Class) перебирает все существующие объекты-классы, а k < Animal истинно, только если k — потомок Animal на любой глубине (для самого Animal это false, для несвязанных — nil). Для прямых подклассов в Ruby 3.1+ есть Animal.subclasses; each_object(Animal) перебрал бы экземпляры.Что выведет этот код?
class Dog; end
rex = Dog.new
max = Dog.new
def rex.bark = "Гав"
puts rex.bark
p max.respond_to?(:bark)
p rex.singleton_methods- Гав; false; [:bark]
- Гав; true; [:bark]
- Гав; false; []
- Ошибка NoMethodError
def rex.bark определяет синглтон-метод: он живёт в синглтон-классе конкретного объекта rex, а не в Dog, поэтому у max его нет. singleton_methods возвращает именно такие методы. Методы класса (def self.x) — частный случай того же механизма.Что произойдёт при выполнении кода?
class Vault
private
def code = 1234
end
v = Vault.new
p v.send(:code)
p v.public_send(:code)- Выведет 1234 и 1234
- Ошибка NoMethodError уже на
send - Выведет nil и 1234
- Выведет 1234, затем ошибка NoMethodError
send вызывает метод в обход видимости, включая private, а public_send соблюдает её и для приватного метода бросает NoMethodError. Поэтому для вызова методов по имени из внешних данных (например, параметров запроса) безопаснее public_send.Что выведет этот код?
class Ghost
def method_missing(name, *args)
if name.to_s.start_with?("get_")
name.to_s.sub("get_", "")
else
super
end
end
end
g = Ghost.new
p g.get_name
p g.respond_to?(:get_name)- "name"; true
- nil; false
- "name"; false
- Ошибка NoMethodError
method_missing перехватывает вызов несуществующего get_name, поэтому он работает. Но respond_to? про это не знает и возвращает false, пока не переопределён respond_to_missing?. super в ветке else важен: без него опечатки в любых других методах молча возвращали бы nil.Зачем вместе с
method_missing определять respond_to_missing??- Без него
method_missingне вызывается для приватных методов - Чтобы
respond_to?иmethod(:name)корректно работали для «динамических» методов - Он вызывается, если
method_missingбросил исключение - Чтобы Ruby закешировал динамический метод и не вызывал
method_missingповторно
respond_to_missing? — официальный способ сообщить, что объект обрабатывает метод через method_missing. Его учитывают respond_to? и method(:name) (иначе последний бросит NameError). Никакого кеширования он не делает: для этого метод определяют через define_method при первом вызове.Что выведет этот код?
class Light
def initialize(color)
@color = color
end
%w[red green].each do |c|
define_method("#{c}?") { @color == c }
end
end
l = Light.new("green")
p l.red?
p l.green?
p Light.instance_methods(false).sort- false; true; [:green?, :red?]
- false; true; [:green?, :initialize, :red?]
- true; true; [:green?, :red?]
- Ошибка NoMethodError: red?
define_method создаёт методы экземпляра во время выполнения тела класса; блок — замыкание, поэтому каждый метод «помнит» свой c, а self внутри блока — экземпляр, отсюда доступ к @color. instance_methods(false) возвращает только публичные и защищённые методы, объявленные в самом классе; initialize приватный и в список не попадает.Что выведет этот код?
class User
def initialize
@name = "Ann"
end
end
u = User.new
u.instance_variable_set(:@age, 30)
p u.instance_variables
p u.instance_variable_get(:@name)- [:@name]; "Ann"
- [:name, :age]; "Ann"
- Ошибка NoMethodError: instance_variable_set
- [:@name, :@age]; "Ann"
instance_variable_set создаёт переменную экземпляра на лету, даже если класс о ней не знает, и instance_variables показывает её в порядке создания. Имена передаются с символом @ (:@age); без него будет NameError. Оба метода — публичные и обходят инкапсуляцию.Что выведет этот код?
Base = Class.new do
def hi = "hi"
end
klass = Class.new(Base)
p klass.name
p klass.new.hi
Named = klass
p klass.name- nil; "hi"; nil
- "klass"; "hi"; "Named"
- nil; "hi"; "Named"
- "Base"; "hi"; "Named"
Class.new(Base) создаёт анонимный подкласс Base: у него пока нет имени, name возвращает nil. Имя класс получает при первом присваивании константе, поэтому после Named = klass — "Named". Присваивание локальной переменной (klass) имени не даёт.Что выведет этот код?
module Trackable
def self.included(base)
base.extend(ClassMethods)
end
module ClassMethods
def tracked? = true
end
end
class Order
include Trackable
end
p Order.tracked?
p Order.new.respond_to?(:tracked?)- true; true
- true; false
- Ошибка NoMethodError: tracked?
- false; true
Хук
self.included(base) вызывается при include и получает подключающий класс. Вызов base.extend(ClassMethods) добавляет методы ClassMethods как методы класса Order — классический паттерн (его же упрощает ActiveSupport::Concern). Экземплярам эти методы не достаются, а сам вложенный модуль при include Trackable не подмешивается.Что выведет этот код (файл запускается напрямую)?
module Shout
refine String do
def shout = upcase + "!"
end
end
begin
"a".shout
rescue NoMethodError
puts "нет метода"
end
using Shout
puts "b".shout- нет метода; B!
- A!; B!
- нет метода; нет метода
- Ошибка: using нельзя вызывать на верхнем уровне
Refinement — это «локальный» monkey patching:
refine сам ничего не меняет, методы становятся видимы только после using Shout и до конца файла (или тела класса/модуля). Поэтому первый вызов падает в NoMethodError, а второй работает. В отличие от открытия класса String, остальной код программы изменения не затрагивают.Исключения6
Что выведет этот код?
begin
raise Exception, "boom"
rescue => e
puts "caught: #{e.message}"
end
puts "after"- caught: boom, затем after
- Только after
- Ничего: программа упадёт с необработанным Exception: boom
- Только caught: boom
rescue без указания класса (и rescue => e) ловит только StandardError и его потомков. Exception — предок StandardError, поэтому он не перехватывается и завершает программу. По той же причине rescue Exception писать не стоит: он перехватит Interrupt (Ctrl+C), SystemExit от exit и NoMemoryError.Что выведет этот код (каждое
puts печатает с новой строки)?begin
puts "a"
rescue
puts "b"
else
puts "c"
ensure
puts "d"
end- a, d
- a, c, d
- a, b, c, d
- a, d, c
Исключения не было, поэтому
rescue пропускается, выполняется else (он срабатывает только при успешном завершении begin), а ensure выполняется всегда и последним. Ветка else не запускается, если было исключение, а ensure — запускается в любом случае.Что выведет этот код?
def compute
return 1
ensure
return 2
end
p compute- 1
- 2
- [1, 2]
- nil
Явный
return внутри ensure переопределяет возвращаемое значение метода (и даже «проглатывает» летящее исключение). Без явного return значение последнего выражения в ensure игнорируется и метод вернул бы 1 — поэтому return в ensure считается ловушкой.Что выведет этот код?
attempts = 0
begin
attempts += 1
raise "fail" if attempts < 3
puts "ok #{attempts}"
rescue
retry
end- ok 1
- Бесконечный цикл
- RuntimeError: fail
- ok 3
retry в rescue заново выполняет блок begin с начала. Переменная attempts объявлена снаружи, поэтому её значение сохраняется: на 1-й и 2-й попытке летит RuntimeError, на 3-й выводится ok 3. Бесконечным цикл был бы, если бы счётчик сбрасывался внутри begin — retry всегда стоит ограничивать счётчиком.Что выведет этот код?
class PaymentError < StandardError
def initialize(msg = "Платёж отклонён")
super
end
end
begin
raise PaymentError
rescue PaymentError => e
puts e.message
end- PaymentError
- Платёж отклонён
- Пустую строку
- ArgumentError
raise PaymentError создаёт экземпляр класса без аргументов, поэтому срабатывает значение по умолчанию. super без скобок передаёт родителю те же аргументы, что получил метод, — то есть msg. Если бы было написано super(), сообщение не передалось бы и message вернул бы имя класса PaymentError.Что выведет этот код?
begin
Integer("x")
rescue StandardError
puts "standard"
rescue ArgumentError
puts "argument"
end- standard
- argument
- standard и argument
- Ничего: исключение не будет поймано
Integer("x") бросает ArgumentError. Ветки rescue проверяются сверху вниз, и выполняется первая подходящая: ArgumentError — потомок StandardError, поэтому срабатывает первая ветка, а вторая недостижима. Более конкретные классы исключений нужно ставить выше общих.Методы и аргументы6
Что выведет этот код?
def bounds
return 1, 9
end
result = bounds
p result- 1
- 9
- [1, 9]
- SyntaxError
return 1, 9 возвращает массив [1, 9] — в Ruby нет кортежей, несколько значений упаковываются в массив. Его удобно сразу разложить: min, max = bounds.Что выведет этот код?
def f(a, *rest, b)
p [a, rest, b]
end
f(1, 2, 3, 4)- [1, [2, 3, 4], nil]
- [1, [2, 3], 4]
- ArgumentError
- [1, [2], 3]
Обязательные параметры заполняются первыми:
a получает первый аргумент, b — последний, а *rest забирает всё, что осталось посередине. Splat не «жадный» до конца — обязательные параметры после него всегда получают значения.Что произойдёт при запуске в Ruby 3.3?
def greet(name:, greeting: "Hi")
"#{greeting}, #{name}"
end
opts = { name: "Ann" }
puts greet(opts)- Выведет Hi, Ann
- ArgumentError
- Предупреждение о deprecation, затем Hi, Ann
- Выведет Hi,
С Ruby 3.0 позиционные и именованные аргументы разделены: хэш, переданный позиционно, больше не превращается в keyword-аргументы, и метод получает лишний позиционный аргумент —
ArgumentError. Нужно явно развернуть хэш: greet(**opts). Предупреждение с последующей работой — это поведение Ruby 2.7.Что передаёт
... в определении def wrapper(...) = target(...)?- Только позиционные аргументы, как
*args - Позиционные и именованные аргументы, но не блок
- Все позиционные, именованные аргументы и блок
- Только блок, как
&block
... (argument forwarding) пробрасывает всё сразу: позиционные аргументы, keyword-аргументы и блок — эквивалент *args, **kwargs, &block. Это удобно для обёрток и делегирования, где раньше *args терял keyword-аргументы после разделения в Ruby 3.Что выведет этот код?
def capture(&block)
block
end
p capture.nil?
pr = capture { |x| x * 2 }
p pr.call(21)- true, затем 42
- false, затем 42
- true, затем LocalJumpError
- ArgumentError при первом вызове
Параметр
&block превращает переданный блок в объект Proc. Если блок не передан, в параметре будет nil — ошибки нет, блок всегда опционален. Во втором вызове возвращается Proc, и call(21) даёт 42.Что выведет этот код?
def add(item, list = [])
list << item
end
add(1)
p add(2)- [1, 2]
- [2]
- nil
- [[1], 2]
В Ruby значение по умолчанию вычисляется заново при каждом вызове, поэтому каждый вызов без второго аргумента получает новый пустой массив. Это отличие от Python, где изменяемый default создаётся один раз и «накапливается».
Pattern matching6
Что выведет этот код?
case [1, [2, 3, 4]]
in [a, [b, *rest]]
p [a, b, rest]
end- [1, 2, [3, 4]]
- [1, [2, 3, 4], []]
- [1, 2, 3]
- NoMatchingPatternError
Array pattern сопоставляется структурно и может быть вложенным:
a получает 1, внутренний массив раскладывается на b = 2 и rest = [3, 4]. Без *rest шаблон [b] не совпал бы — array pattern требует точного совпадения длины.Что выведет этот код?
config = { db: { user: "admin", port: 5432 }, mode: "dev" }
case config
in { db: { user: String => user } }
puts "user=#{user}"
else
puts "no match"
end- no match
- NoMatchingPatternKeyError
- user=admin
- user=
Hash pattern совпадает частично: лишние ключи (
port, mode) игнорируются, проверяются только перечисленные. String => user проверяет тип и связывает значение с переменной. Чтобы запретить лишние ключи, добавляют **nil; в отличие от хэшей, array pattern требует точной длины.Что выведет этот код?
expected = 5
case 7
in ^expected then puts "five"
in Integer => n if n > 6 then puts "big #{n}"
in Integer then puts "int"
end- five
- big 7
- int
- NoMatchingPatternError
^expected (pin) сравнивает с текущим значением переменной (5), поэтому первая ветка не совпадает. Вторая совпадает по типу, связывает n = 7, и guard if n > 6 истинен. Без ^ шаблон in expected просто присвоил бы 7 в expected и совпал бы всегда — частая ошибка.Что произойдёт при выполнении этого кода?
case 42
in String then puts "str"
in Float then puts "float"
end- Ничего не выведет, case вернёт nil
- Выведет float
- SyntaxError
- Будет выброшено NoMatchingPatternError
В отличие от
case/when, который при отсутствии совпадений просто возвращает nil, case/in без ветки else бросает NoMatchingPatternError. Поэтому для неисчерпывающих шаблонов добавляют else.Что выведет этот код (find pattern)?
data = [1, :ok, "first", 2, "second"]
case data
in [*, String => s, *post]
p [s, post]
end- ["second", []]
- ["first", ["second"]]
- NoMatchingPatternError
- ["first", [2, "second"]]
Find pattern
[*, шаблон, *] ищет элемент, подходящий под шаблон, перебирая позиции слева направо, и останавливается на первом совпадении. Первая строка — "first", а *post получает весь хвост после неё, включая не-строки.Что выведет этот код?
user = { name: "Bob", age: 30 }
user => { name: }
p name
p(user in { age: String })- "Bob", затем false
- "Bob", затем NoMatchingPatternKeyError
- NameError: name не определена
- {:name=>"Bob"}, затем false
expr => pattern — rightward assignment: { name: } связывает значение ключа с локальной переменной name; при несовпадении он бросил бы исключение. А expr in pattern ничего не бросает и возвращает true/false — здесь false, так как возраст не строка.Многопоточность5
Что верно про потоки (
Thread) в CRuby 3.3?- Потоки «зелёные»: все они живут внутри одного системного потока ОС
- Из-за GVL Ruby-код потоков не идёт параллельно, но на время блокирующего I/O GVL отпускается
- GVL делает любой Ruby-код потокобезопасным, поэтому Mutex в CRuby не нужен
- Ruby-код потоков идёт параллельно на всех ядрах, GVL мешает только C-расширениям
Каждый
Thread в CRuby — настоящий поток ОС, но GVL (Global VM Lock) позволяет исполнять Ruby-код только одному потоку за раз. На время I/O (сеть, диск, sleep) GVL отпускается, поэтому потоки ускоряют I/O-bound задачи, но не CPU-bound. Потокобезопасности GVL не гарантирует.Почему здесь в общем случае нужен
Mutex, хотя в CRuby есть GVL?count = 0
threads = 10.times.map do
Thread.new { 1000.times { count += 1 } }
end
threads.each(&:join)
p count- Без Mutex метод
joinне дождётся завершения потоков - GVL отключается, когда потоков больше, чем ядер
count += 1— это чтение, сложение и запись; между ними поток может переключиться, и инкременты потеряются- Mutex не нужен: GVL гарантирует атомарность любой Ruby-операции
GVL защищает внутренности VM, но не делает составные операции атомарными:
count += 1 — это count = count + 1, и переключение потока между чтением и записью приводит к потере обновлений. Правильно: m = Mutex.new и m.synchronize { count += 1 }. То, что код «обычно» выдаёт 10000, — не гарантия.Что выведет этот код?
q = Queue.new
Thread.new do
3.times { |i| q << i }
q << :done
end
result = []
while (item = q.pop) != :done
result << item
end
p result- []
- [0, 1, 2]
- [0, 1, 2, :done]
- Зависнет навсегда (deadlock)
Queue — потокобезопасная очередь: pop блокирует вызывающий поток, пока в очереди не появится элемент, поэтому неважно, успел ли поток-производитель стартовать. Цикл забирает 0, 1, 2 и останавливается на :done, который в результат не попадает.Что выведет этот код?
f = Fiber.new do
Fiber.yield 1
Fiber.yield 2
3
end
p f.resume
p f.resume
p f.resume- 1, 2, nil
- 1, 1, 1
- 1, 2, 3
- 1, 2, затем FiberError
resume выполняет файбер до следующего Fiber.yield и возвращает переданное в него значение. Третий resume доводит блок до конца и возвращает его последнее выражение — 3. FiberError (dead fiber called) был бы только при четвёртом resume.Что верно про
Ractor (Ruby 3.x)?- Это обёртка над Thread с общим доступом ко всем объектам программы
- Ractor'ы могут выполнять Ruby-код параллельно; между ними передаются только shareable-объекты, остальные копируются или перемещаются
- Это легковесная корутина, которую переключают вручную через
resume - Все Ractor'ы делят один общий GVL, поэтому параллелизма не дают
Ractor — модель акторов: у каждого Ractor свой lock, поэтому Ruby-код в разных Ractor'ах идёт параллельно. Чтобы не было гонок, разделять можно только shareable-объекты (глубоко замороженные, классы, модули); остальное копируется при
send или перемещается (move: true). Фича пока экспериментальная и выдаёт предупреждение. Ручное переключение через resume — это Fiber.Стандартная библиотека9
Что выведет этот код в Ruby 3.3 (без
require)?s = Set[1, 2]
s << 2 << 3
p s.size
p s.include?(3)- 3, затем true
- 4, затем true
- 3, затем false
- NameError: uninitialized constant Set
Set хранит только уникальные элементы, поэтому повторное добавление 2 игнорируется и размер равен 3. Начиная с Ruby 3.2 Set доступен без require "set", так что NameError здесь не будет. include? у Set работает за O(1), в отличие от Array#include?.Что выведет этот код?
p "12abc".to_i
p Integer("12abc")- 12, затем 12
- 0, затем ArgumentError
- 12, затем ArgumentError
- 12, затем nil
String#to_i «снисходителен»: разбирает цифры в начале строки и молча игнорирует остальное (для "abc" вернёт 0). Kernel#Integer строгий и бросает ArgumentError на некорректной строке — поэтому его используют для валидации ввода. Вернуть nil вместо исключения можно через Integer("12abc", exception: false).Какой метод нужно определить в классе, чтобы
include Comparable дал ему <, >, ==, between? и clamp?==<=><each
Модуль
Comparable строит все операторы сравнения на основе <=>, который должен возвращать -1, 0, 1 (или nil, если объекты несравнимы). each — это требование модуля Enumerable, а не Comparable.Что выведет этот код?
require "json"
data = JSON.parse('{"name": "Ann", "age": 30}')
p data[:name]
p data["age"]- "Ann", затем 30
- nil, затем 30
- "Ann", затем nil
- KeyError
JSON.parse по умолчанию возвращает хэш со строковыми ключами, поэтому data[:name] — nil (а Hash#[] не бросает KeyError, это делает fetch). Чтобы получить символьные ключи, используют JSON.parse(str, symbolize_names: true).Что выведет этот код?
if /(?<year>\d{4})-(?<month>\d{2})/ =~ "Дата: 2024-05"
p month
end
p $~[:year]- "05", затем "2024"
- NameError: undefined local variable month
- "05", затем nil
- 5, затем 2024
Когда литерал регулярки с именованными группами стоит слева от
=~, Ruby создаёт локальные переменные с именами групп — month будет "05". Если бы слева стояла строка (str =~ /.../), переменные не создались бы и был бы NameError. $~ хранит MatchData последнего совпадения, а группы всегда строки, не числа.Что выведет этот код?
p "%05.1f|%03d" % [3.14159, 7]- "3.1|7"
- "03.14|007"
- "003.1|700"
- "003.1|007"
String#% работает как format/sprintf. %05.1f — дробное число с одним знаком после точки, шириной 5 и дополнением нулями слева: 003.1. %03d — целое шириной 3 с ведущими нулями: 007. Аргументы для нескольких спецификаторов передаются массивом.Что выведет этот код?
Point = Struct.new(:x, :y)
a = Point.new(1, 2)
b = Point.new(1, 2)
p a == b
p a.equal?(b)- true, затем false
- false, затем false
- true, затем true
- false, затем true
Struct автоматически определяет == через сравнение всех полей, поэтому a == b истинно. equal? же проверяет идентичность объектов (тот же object_id), а это два разных экземпляра.Что выведет этот код?
require "date"
diff = Date.new(2024, 3, 1) - Date.new(2024, 2, 1)
p diff
p diff.to_i- 29, затем 29
- (29/1), затем 29
- 28, затем 28
- 2505600.0, затем 2505600
Date#- возвращает разницу в днях как Rational, и p печатает его как (29/1); в 2024 году февраль високосный — 29 дней. Секунды в виде Float вернула бы разность двух объектов Time. DateTime считается устаревшим — для момента времени используют Time, для календарной даты Date.Для чего используется модуль
ObjectSpace?- Для изоляции глобальных переменных между потоками
- Для объявления пространств имён констант вместо
module - Для интроспекции кучи: перебор живых объектов (
each_object), статистика (count_objects), финализаторы - Для сериализации объектов в бинарный формат и обратно
ObjectSpace даёт доступ к объектам в куче: ObjectSpace.each_object(SomeClass) перебирает живые экземпляры, count_objects показывает статистику, define_finalizer вешает финализатор. Полезно при поиске утечек памяти. Бинарная сериализация — это Marshal, а пространства имён создаются модулями.Gems и Bundler3
Какие версии допускает строка
gem "nokogiri", "~> 1.15" в Gemfile?>= 1.15и< 1.16- Ровно
1.15 >= 1.15и< 2.0>= 1.15без верхней границы
Pessimistic-оператор
~> разрешает рост только последнего указанного сегмента версии: ~> 1.15 означает >= 1.15, < 2.0. Вариант < 1.16 получился бы для ~> 1.15.0 — с тремя сегментами разрешается меняться только патч-версии.Зачем нужен файл
Gemfile.lock?- Блокирует Gemfile от одновременного редактирования несколькими разработчиками
- Хранит кеш скачанных
.gem-файлов - Фиксирует точные версии всех гемов, включая транзитивные, чтобы везде стоял одинаковый набор
- Перечисляет гемы, которые запрещено обновлять через
bundle update
bundle install записывает в Gemfile.lock точные разрешённые версии всех зависимостей (включая зависимости зависимостей), и на других машинах и на проде ставится ровно этот набор. Для приложений lock-файл коммитят в репозиторий; версии в нём меняет bundle update.Зачем запускать
bundle exec rspec, а не просто rspec?- Чтобы команда использовала версии гемов из
Gemfile.lock, а не последние установленные в системе - Чтобы перед запуском автоматически установить недостающие гемы
- Чтобы запустить команду в отдельном процессе с увеличенным лимитом памяти
- Без
bundle execRSpec не найдёт файлы в папкеspec
bundle exec настраивает окружение ($LOAD_PATH, переменные) так, что подключаются только гемы и версии из бандла проекта. Без него может запуститься другая установленная версия гема и возникнуть конфликт версий. Недостающие гемы bundle exec не ставит — это делает bundle install.Тестирование4
Чем
let! отличается от let в RSpec?let!вычисляется сразу перед каждым примером,let— лениво при первом обращенииlet!мемоизирует значение на всю группу,let— на один примерletвычисляется заново при каждом обращении,let!— один разlet!нельзя переопределить во вложенномdescribe
let ленивый: блок выполняется при первом обращении внутри примера, и результат мемоизируется до конца этого примера. let! выполняется принудительно в неявном before — это нужно, когда объект (например, запись в БД) должен существовать, даже если тест к нему не обращается. Оба мемоизируются только в рамках одного примера.Какое ожидание RSpec пройдёт (файл без magic comment
frozen_string_literal)?expect(1).to eql(1.0)expect("ab").to be("ab")expect([1]).to equal([1])expect(1).to eq(1.0)
eq использует ==, а 1 == 1.0 истинно. eql использует eql?, который учитывает тип (1.eql?(1.0) — false). be(x) и equal проверяют идентичность объекта (equal?), а два строковых или массивных литерала — разные объекты.Чем опасно создавать записи БД в
before(:all) (before(:context)) в Rails-проекте с транзакционными тестами?- Блок выполняется после каждого примера, и записи удаляются слишком рано
- Блок выполняется один раз на группу вне транзакции примера, поэтому записи не откатываются и «утекают» в другие тесты
- Внутри
before(:all)нельзя обращаться к ActiveRecord — будет исключение - Записи создаются заново перед каждым примером, что сильно замедляет тесты
before(:each) выполняется внутри транзакции каждого примера, которая затем откатывается. before(:all) выполняется один раз до всех примеров группы, вне этих транзакций, поэтому созданные записи остаются в БД и влияют на другие тесты, а изменения объектов между примерами разделяются. Такие данные нужно удалять вручную в after(:all).Сколько тестов выполнит Minitest для этого класса?
require "minitest/autorun"
class CalcTest < Minitest::Test
def test_sum
assert_equal 4, 2 + 2
end
def sum_negative
assert_equal 0, 1 + -1
end
end- 2
- 0
- Ошибка: не определён метод setup
- 1
Minitest запускает как тесты только публичные методы, имена которых начинаются с
test_; sum_negative — обычный метод, и он не выполнится. Также обратите внимание на порядок аргументов: в assert_equal сначала ожидаемое значение, потом фактическое — иначе сообщения об ошибках будут вводить в заблуждение.Ruby on Rails11
Что произойдёт в каждой строке, если пользователя с id 999 нет в БД?
User.find(999)
User.find_by(id: 999)
User.where(id: 999)- nil; nil; пустой массив []
- RecordNotFound; nil; пустой ActiveRecord::Relation
- RecordNotFound; RecordNotFound; nil
- nil; RecordNotFound; пустой ActiveRecord::Relation
find бросает ActiveRecord::RecordNotFound (в контроллере это превращается в 404), find_by возвращает nil, а where всегда возвращает ленивый ActiveRecord::Relation — коллекцию, а не одну запись, даже если совпадение одно. Чтобы получить объект из where, нужен .first или find_by.Сколько SQL-запросов выполнит этот код (10 постов у разных авторов) и как это исправить?
# Post belongs_to :author
Post.limit(10).each do |post|
puts post.author.name
end- 1 запрос: Rails сам делает JOIN для belongs_to; исправлять не нужно
- 2 запроса; исправлять не нужно
- 11 запросов;
Post.limit(10).select(:author) - 11 запросов;
Post.includes(:author).limit(10)
Это проблема N+1: один запрос за постами и по запросу на автора каждого поста.
includes(:author) подгружает связь заранее — обычно вторым запросом WHERE id IN (...), итого 2 запроса. Ассоциации по умолчанию загружаются лениво, автоматического JOIN нет.Чем
has_many :patients, through: :appointments отличается от has_and_belongs_to_many :patients?- Связь идёт через полноценную модель
Appointment, у которой могут быть свои атрибуты, валидации и колбэки throughне требует отдельной таблицы для связиhas_and_belongs_to_manyподдерживает только связь один-ко-многимthroughработает только с полиморфными связями
Обе связи — многие-ко-многим через промежуточную таблицу. У HABTM таблица «голая», без модели, а
has_many :through использует join-модель (Appointment belongs_to :doctor и :patient), в которую можно добавить поля (дата приёма), валидации и колбэки. Поэтому through обычно предпочтительнее.Гарантирует ли
validates :email, uniqueness: true уникальность email в таблице?- Да: Rails блокирует таблицу на время проверки и вставки
- Нет: проверка делает SELECT до INSERT, и два параллельных запроса могут пройти её оба — нужен уникальный индекс в БД
- Да, если запись сохраняется в транзакции (а
saveвсегда в транзакции) - Нет:
uniquenessвообще не обращается к БД и проверяет только объекты в памяти
Валидация уникальности — это отдельный SELECT перед вставкой; между ним и INSERT другой процесс может вставить такую же запись (race condition). Транзакция с обычным уровнем изоляции это не предотвращает. Надёжно —
add_index :users, :email, unique: true в миграции, а валидация остаётся для понятных сообщений об ошибке.Что произойдёт при вызове этого экшена с параметрами
user[name] и user[admin]?def create
@user = User.create(params[:user])
end- Пользователь создастся со всеми переданными полями, включая admin
- Создастся пользователь без атрибутов
- Будет выброшено ActiveModel::ForbiddenAttributesError
- NoMethodError: params[:user] равен nil
params[:user] — объект ActionController::Parameters, который не разрешён (permitted? false), и mass assignment с ним бросает ForbiddenAttributesError. Это защита strong parameters: нужно явно перечислить поля, например params.require(:user).permit(:name) — тогда admin будет отброшен.При
resources :articles в routes.rb какой экшен обработает запрос PATCH /articles/5?editupdateshowcreate
resources создаёт 7 REST-маршрутов; PATCH и PUT /articles/:id ведут в update. edit — это GET /articles/5/edit, который только показывает форму редактирования, а create — POST /articles.Какое выражение вернёт
true в Rails (ActiveSupport)?0.blank?[].present?" ".blank?false.present?
blank? истинен для nil, false, пустых коллекций и строк, состоящих только из пробельных символов, поэтому " ".blank? — true. 0 не считается пустым (0.blank? — false), а present? — просто !blank?, поэтому для [] и false он возвращает false.Что произойдёт, если не-администратор отправит
PATCH на update?class ArticlesController < ApplicationController
before_action :require_admin, only: %i[edit update]
def update
# ...
end
private
def require_admin
redirect_to root_path unless current_user&.admin?
end
end- Выполнится redirect, и экшен
updateуже не будет вызван - Выполнится redirect, затем отработает
updateи упадёт с DoubleRenderError - Колбэк не сработает:
only:принимает только строки - Сначала выполнится
update, а redirect применится после него
Если
before_action вызывает render или redirect_to, Rails прерывает цепочку колбэков и сам экшен не выполняет. Поэтому достаточно сделать redirect, без явного return или исключения. only: принимает и символы, и строки.Какой вызов сохранит изменение атрибута в БД, пропустив и валидации, и колбэки модели?
user.update(name: "X")user.update_attribute(:name, "X")user.save(validate: false)user.update_column(:name, "X")
update_column (и update_columns, update_all) выполняет прямой UPDATE без валидаций и колбэков, не меняя даже updated_at. Ловушка — update_attribute: он пропускает валидации, но колбэки выполняет. save(validate: false) тоже вызывает колбэки.Что вернут вызовы
Article.by_author(nil) и Article.by_author2(nil)?class Article < ApplicationRecord
scope :by_author, ->(id) { where(author_id: id) if id.present? }
def self.by_author2(id)
where(author_id: id) if id.present?
end
endnilиnil- Relation со всеми статьями (
all) иnil - Relation со всеми статьями в обоих случаях
- Пустой Relation и
nil
Если тело
scope возвращает nil или false, Rails подменяет результат на all, чтобы цепочки вроде Article.by_author(nil).published не ломались. Обычный метод класса так не делает и вернёт nil, и следующий вызов в цепочке упадёт с NoMethodError.Вы изменили файл миграции, которая уже была применена, и снова запустили
rails db:migrate. Что произойдёт?- Rails заметит изменение файла и выполнит миграцию повторно
- Миграция будет откатана и применена заново
- Ничего: версия миграции уже записана в таблице
schema_migrations, и повторно она не выполнится - Rails выдаст ошибку о несовпадении контрольной суммы миграции
Rails отслеживает применённые миграции по их версии (timestamp в имени файла) в таблице
schema_migrations, а содержимое файла не проверяет. Изменения нужно оформлять новой миграцией; в локальной разработке можно сделать rails db:rollback и затем db:migrate (или db:migrate:redo).Строки и регулярные выражения19
Что выведет
p "a1b22c333".scan(/\d+/) (Ruby 3.3)?- ["1", "2", "2", "3", "3", "3"]
- "1"
- ["a", "b", "c"]
- ["1", "22", "333"]
scan возвращает массив ВСЕХ непересекающихся совпадений; квантификатор \d+ жадный, поэтому подряд идущие цифры попадают в одно совпадение. Вариант с отдельными цифрами был бы у /\d/ без плюса.
Что выведет этот код (Ruby 3.3)?
p "k1=v1;k2=v2".scan(/(\w+)=(\w+)/)- {"k1"=>"v1", "k2"=>"v2"}
- ["k1", "v1", "k2", "v2"]
- [["k1", "v1"], ["k2", "v2"]]
- ["k1=v1", "k2=v2"]
Если в регулярке есть группы, scan возвращает для каждого совпадения массив захваченных групп, а не всё совпадение целиком. Хеш он не строит — для этого нужно дописать .to_h.
Что выведет этот код (Ruby 3.3)?
p "abc123" =~ /\d/
p "abc123".match?(/\d/)
p "abc" =~ /\d/- 1, true, false
- 3, true, nil
- true, true, false
- 3, 3, nil
=~ возвращает индекс начала первого совпадения (здесь 3) или nil, а match? — строго true/false. Индекс 0 тоже истинен в Ruby, поэтому в условиях =~ работает, но значения у операторов разные.
Что выведет этот код (Ruby 3.3)?
"x-42" =~ /(\d+)/
"y-7".match?(/(\d+)/)
p $1- "42"
- "7"
- nil
- 42
match? специально не обновляет $~ и связанные переменные ($1 и т.д.) — поэтому он быстрее. $1 остался от предыдущего =~, а это строка "42", а не число.
Валидация пользовательского ввода. Что выведет код?
input = "abc\n<script>alert(1)</script>"
p input.match?(/^[a-z]+$/)
p input.match?(/\A[a-z]+\z/)- false, затем false
- true, затем true
- false, затем true
- true, затем false
В Ruby ^ и $ — это начало и конец СТРОКИ ТЕКСТА (line), а не всей строки, поэтому первая строка "abc" проходит проверку, и вредоносный хвост пропускается. Для валидации всегда используйте \A и \z — они якорятся к началу и концу всей строки.
Что выведет этот код (Ruby 3.3)?
s = "abc\n"
p s.match?(/\Aabc\Z/)
p s.match?(/\Aabc\z/)- false, затем false
- false, затем true
- true, затем false
- true, затем true
\Z совпадает с концом строки ИЛИ позицией перед завершающим переводом строки, а \z — только с абсолютным концом. Поэтому для строгой проверки (например, ввода с формы) нужен именно \z.
Что вернёт выражение
"cat hat".gsub(/[ch]/, "c" => "k") (Ruby 3.3)?- TypeError
- "kat at"
- "kat hat"
- "kat kat"
Если вторым аргументом gsub передан хеш, совпавший текст ищется в нём как ключ. Для "h" ключа нет, hash["h"] даёт nil, а nil превращается в пустую строку — совпадение просто удаляется, а не остаётся как было.
Что вернёт выражение
"price: 10, tax: 3".gsub(/\d+/) { |n| (n.to_i * 2).to_s } (Ruby 3.3)?- "price: 20, tax: 6"
- "price: 20, tax: 3"
- "price: 1010, tax: 33"
- ["20", "6"]
gsub с блоком заменяет КАЖДОЕ совпадение результатом блока; в блок передаётся строка совпадения. sub заменил бы только первое, а результат всегда строка, а не массив.
Что выведет этот код (Ruby 3.3)?
name = "John Smith"
p name.sub(/(\w+) (\w+)/, '\2, \1')- "\\2, \\1"
- "John Smith"
- ArgumentError
- "Smith, John"
В строке замены \1, \2 ссылаются на группы. Важно, что строка в одинарных кавычках: в двойных "\2" было бы восьмеричным escape-символом (\x02), и подстановка групп сломалась бы — тогда пишут "\\2".
Что выведет этот код (Ruby 3.3)?
re = /(?<num>\d+)/
if re =~ "id=42"
p num
end- 42
- nil
- Ошибка NameError
- "42"
Именованные группы превращаются в локальные переменные, только если слева от =~ стоит регулярка-ЛИТЕРАЛ (без интерполяции). Здесь регулярка в переменной, поэтому num не создаётся, и обращение к нему — NameError. Значение можно взять через $~[:num].
Что выведет этот код (Ruby 3.3)?
m = "id=42".match(/(?<key>\w+)=(?<val>\d+)/)
p m[:val]
p m.named_captures- nil, затем {}
- "42", затем {"key"=>"id", "val"=>"42"}
- 42, затем {:key=>"id", :val=>42}
- "42", затем {:key=>"id", :val=>"42"}
MatchData позволяет обращаться к группам по имени через [:name] или ["name"]; значения групп — всегда строки. named_captures по умолчанию возвращает хеш со СТРОКОВЫМИ ключами — имена групп, а не символы.
Что выведет этот код (Ruby 3.3)?
s = "100USD 200EUR 300USD"
p s.scan(/\d+(?=USD)/)- ["100", "300"]
- ["100USD", "300USD"]
- ["USD", "USD"]
- ["100", "200", "300"]
(?=USD) — позитивный просмотр вперёд: проверяет, что дальше идёт USD, но не включает его в совпадение. Поэтому в результат попадают только числа перед USD.
Что выведет этот код (Ruby 3.3)?
p "$30 and 5".scan(/(?<!\$)\d+/)- ["5"]
- ["30", "5"]
- []
- ["0", "5"]
Негативный просмотр назад (?<!\$) проверяет лишь один символ перед текущей позицией. У "3" перед ним $, поэтому совпадение с него не начинается, но со следующей позиции "0" (перед ним "3") — начинается. Чтобы исключить всё число, нужна граница: /(?<![$\d])\d+/.
Что выведет этот код (Ruby 3.3)?
s = "привет"
p s.length
p s.bytesize- 6, затем 6
- 12, затем 6
- 6, затем 12
- 12, затем 12
length считает символы, а bytesize — байты. Строка в UTF-8, а каждая кириллическая буква занимает 2 байта, поэтому 6 символов = 12 байт.
Что выведет этот код (Ruby 3.3)?
s = "é".b
p s.length
p s.force_encoding("UTF-8").length- 1, затем 2
- 2, затем 1
- 1, затем 1
- 2, затем 2
b возвращает копию строки в бинарной кодировке (ASCII-8BIT), где каждый байт — «символ»; "é" в UTF-8 занимает 2 байта. force_encoding не перекодирует байты, а лишь меняет метку кодировки (и меняет саму строку), поэтому снова получаем 1 символ.
Что выведет этот код (Ruby 3.3)?
s = "abc\xFF"
p s.valid_encoding?
p s.scrub("?")- false, затем "abc?"
- true, затем "abc\xFF"
- false, затем "abc"
- Ошибка SyntaxError при разборе литерала
Байт \xFF недопустим в UTF-8, но Ruby разрешает такой литерал — строка просто получается невалидной, и valid_encoding? это показывает. scrub заменяет невалидные байты на указанную строку (по умолчанию на символ U+FFFD).
Что выведет
p "a,b,,c,,".split(",") (Ruby 3.3)?- ["a", "b", "", "c", "", ""]
- ["a", "b", "c"]
- ["a", "b", nil, "c"]
- ["a", "b", "", "c"]
split по умолчанию отбрасывает пустые элементы в КОНЦЕ результата, но пустые строки в середине сохраняет. Чтобы сохранить и хвостовые, передают лимит -1: split(",", -1).
Что вернёт выражение
"a-b-c".sub("-", "+")?- "a-b-c"
- nil
- "a+b-c"
- "a+b+c"
sub заменяет только ПЕРВОЕ вхождение, gsub — все. Оба метода возвращают новую строку; nil возвращает только sub! / gsub!, если замен не было.
Что выведет этот код (Ruby 3.3)?
s = "start\nend"
p s.match?(/start.end/)
p s.match?(/start.end/m)- true, затем false
- false, затем true
- true, затем true
- false, затем false
По умолчанию точка не совпадает с переводом строки. В Ruby флаг /m включает режим, где точка совпадает и с \n (в других языках это флаг s); многострочность ^ и $ в Ruby включена всегда.
Объектная модель17
Что выведет этот код (Ruby 3.3)?
class A
def self.make = "A.make"
end
class B < A; end
p B.make
p B.singleton_class.superclass- "A.make", затем #<Class:A>
- "A.make", затем Class
- NoMethodError
- "A.make", затем A
Методы класса живут в его singleton-классе (eigenclass). Суперкласс singleton-класса B — singleton-класс A, поэтому B «наследует» методы класса A. Обычный Class в этой цепочке находится выше.
Что выведет этот код (Ruby 3.3)?
class Foo; end
Foo.class_eval do
def a = "a"
end
Foo.instance_eval do
def b = "b"
end
p Foo.new.a
p Foo.b
p Foo.new.respond_to?(:b)- "a", NoMethodError
- "a", "b", true
- NoMethodError на Foo.new.a
- "a", "b", false
class_eval выполняет блок как тело класса — def создаёт метод экземпляра. instance_eval выполняет блок в контексте самого объекта Foo, и def там определяет singleton-метод этого объекта, то есть метод класса Foo.b, а у экземпляров его нет.
Что выведет этот код (Ruby 3.3)?
def kind(x)
case x
when Numeric then "number"
when Enumerable then "collection"
else "other"
end
end
p kind(1.5), kind({ a: 1 }), kind("str")- "number", "collection", "collection"
- "other", "other", "other"
- "number", "collection", "other"
- "number", "other", "other"
when вызывает Module#===, то есть проверяет x.is_a?(модуль). Float — потомок Numeric, Hash включает Enumerable, а String с Ruby 1.9 НЕ является Enumerable (для перебора есть each_char).
Что выведет
p 5.class.class, Class.superclass, Module.superclass (Ruby 3.3)?- Class, Class, Module
- Class, Module, Object
- Class, Object, Object
- Integer, Module, BasicObject
Любой класс — объект класса Class. Class наследует от Module, а Module — от Object; поэтому классы умеют всё, что модули, плюс new и наследование.
Что выведет этот код (Ruby 3.3)?
module Settings
def self.const_missing(name)
"default_#{name.downcase}"
end
end
p Settings::TIMEOUT- "default_timeout"
- NameError: uninitialized constant Settings::TIMEOUT
- nil
- :default_timeout
При обращении к несуществующей константе Ruby вызывает const_missing у модуля с именем константы (Symbol). Здесь он переопределён и возвращает строку; без него было бы NameError. На этом хуке раньше строился автолоад Rails (classic autoloader).
Что выведет этот код (Ruby 3.3)?
class Tracker
@log = []
def self.method_added(name)
@log << name
end
def self.log = @log
def a; end
def self.b; end
def c; end
end
p Tracker.log- [:a, :b, :c]
- [:method_added, :log, :a, :b, :c]
- []
- [:a, :c]
Хук method_added вызывается при определении методов ЭКЗЕМПЛЯРА. Определение методов класса (def self.x) вызывает другой хук — singleton_method_added, поэтому :b, :log и сам :method_added в журнал не попадают.
Что выведет этот код (Ruby 3.3)?
class Foo
@x = 1
def x = @x
end
p Foo.new.x
p Foo.instance_variable_get(:@x)- 1, затем nil
- nil, затем nil
- nil, затем 1
- 1, затем 1
@x в теле класса принадлежит объекту-классу Foo (class instance variable), а @x в методе экземпляра — конкретному экземпляру, где он не задан и равен nil. Это разные переменные разных объектов.
Что выведет
p nil.class, true.class, 1.5.class (Ruby 3.3)?- Object, TrueClass, Numeric
- NilClass, TrueClass, Float
- nil, Boolean, Float
- NilClass, Boolean, Decimal
В Ruby всё — объекты, включая nil и true/false. У них свои классы NilClass, TrueClass, FalseClass; общего класса Boolean нет.
Что выведет этот код (Ruby 3.3)?
class Animal; end
class Dog < Animal; end
d = Dog.new
p d.is_a?(Animal), d.instance_of?(Animal)- true, false
- true, true
- false, false
- false, true
is_a? (kind_of?) учитывает всю цепочку предков, а instance_of? проверяет только точный класс объекта. d — экземпляр Dog, поэтому instance_of?(Animal) ложно.
Что выведет этот код (Ruby 3.3)?
class Animal; end
class Dog < Animal; end
p Dog < Animal, Animal < Dog, Dog < String- true, false, false
- true, true, nil
- true, false, ArgumentError
- true, false, nil
Module#< проверяет «является потомком». Если классы связаны, но в обратную сторону — false, а если вообще не связаны наследованием — nil. Это частая ловушка в условиях: nil тоже ложен, но это не то же самое, что false.
Что выведет этот код (Ruby 3.3)?
module Greet
def hi = "hi"
end
s = "x"
s.extend(Greet)
p s.hi
p s.is_a?(Greet)
p "y".respond_to?(:hi)- "hi", true, true
- NoMethodError
- "hi", true, false
- "hi", false, false
extend подключает модуль в singleton-класс конкретного объекта: только у s появляется метод hi, и s.is_a?(Greet) истинно. Другие строки не затронуты — в отличие от include в класс String.
Что произойдёт при выполнении кода?
class A; end
class B < A; end
class B < Object; end- Только предупреждение already initialized constant B
- TypeError: superclass mismatch for class B
- Класс B будет переоткрыт, и его суперклассом станет Object
- Будет создан второй, независимый класс B
Класс можно переоткрывать сколько угодно, но суперкласс при этом указывать нельзя другой. Попытка сменить родителя приводит к TypeError superclass mismatch.
Что выведет этот код (Ruby 3.3)?
class A
def who = "A"
end
class B < A
def who = "B"
end
p A.instance_method(:who).bind_call(B.new)- "A"
- "B"
- TypeError
- NoMethodError
instance_method возвращает UnboundMethod именно из класса A; bind_call привязывает его к объекту (любому экземпляру A или потомка) и вызывает. Так можно вызвать «родительскую» реализацию в обход переопределения; привязать к объекту не из иерархии A было бы TypeError.
Что выведет этот код (Ruby 3.3)?
class Greeter
def hi = "hi"
alias hello hi
def hi = "hey"
end
g = Greeter.new
p g.hi, g.hello- "hey", "hey"
- "hi", "hi"
- NoMethodError
- "hey", "hi"
alias копирует ТЕКУЩЕЕ тело метода под новым именем. Последующее переопределение hi на hello не влияет — это не ссылка на имя. На этом основан старый приём обёртки методов (alias_method chain).
Что выведет этот код (Ruby 3.3)?
class Temp
include Comparable
attr_reader :deg
def initialize(deg)
@deg = deg
end
def <=>(other)
deg <=> other.deg
end
end
a = Temp.new(5)
b = Temp.new(5)
p a == b
p a.equal?(b)- true, затем true
- NoMethodError
- true, затем false
- false, затем false
Comparable даёт и ==: он возвращает true, если <=> вернул 0. При этом equal? — проверка идентичности объектов, и он не переопределяется: это два разных объекта.
Что выведет этот код (Ruby 3.3)?
module M
def hi = 1
end
class C
include M
end
p C.new.method(:hi).owner- #<Class:C>
- M
- C
- Object
owner у Method показывает модуль или класс, где метод реально определён. Метод найден через цепочку предков C, но принадлежит модулю M — так удобно искать, откуда «пришёл» метод (вместе с source_location).
Что выведет этот код (Ruby 3.3)?
module A
module B
p Module.nesting
end
end- [A::B, A]
- [A, A::B]
- [A::B]
- [A::B, A, Object]
Module.nesting возвращает лексическую вложенность в точке вызова — от самого внутреннего к внешнему. Именно по ней (а потом по предкам) ищутся константы; Object в nesting не входит.
Память и производительность14
Что выведет этот код (Ruby 3.3)?
# frozen_string_literal: true
a = "ok"
b = "ok"
p a.equal?(b)
p a.frozen?- false, затем true
- false, затем false
- true, затем false
- true, затем true
С магическим комментарием строковые литералы заморожены и дедуплицируются: одинаковые литералы — один и тот же объект, без новой аллокации при каждом выполнении. Без комментария каждый литерал создаёт новую изменяемую строку, и equal? дал бы false.
Какое выражение при каждом вызове метода НЕ создаёт новый объект (Ruby 3.3, без магического комментария)?
- [:status]
- "status".dup
- :status
- "status"
Символ — единственный объект на всю программу, ссылка на него не аллоцирует память. Строковый литерал без frozen_string_literal и литерал массива создают новый объект при каждом выполнении, dup — тем более.
Что выведет
p 42.frozen?, :sym.frozen?, nil.frozen?, "str".frozen? (Ruby 3.3, без магического комментария frozen_string_literal)?- false, true, false, false
- true, true, true, false
- false, false, false, false
- true, true, true, true
Integer, Symbol, nil, true/false — неизменяемые значения, они всегда заморожены. Строковый литерал в Ruby 3.3 без магического комментария frozen_string_literal создаёт обычную изменяемую строку.
Что верно про сборку мусора символов в Ruby 3.3?
- Символы, созданные динамически (to_sym, intern), собираются GC с Ruby 2.2; символы-литералы из исходного кода — нет
- Символы никогда не собираются GC, поэтому любой to_sym на пользовательском вводе — неограниченная утечка памяти
- Все символы собираются GC сразу, как только на них не осталось ссылок, как обычные объекты
- Символы хранятся на стеке и освобождаются при выходе из метода
До Ruby 2.2 символы были бессмертными, и to_sym на внешних данных был классической утечкой/DoS. С 2.2 динамические символы стали собираемыми; бессмертными остаются символы из литералов и имён методов/констант.
Почему для склейки строки в цикле
s << part эффективнее, чем s += part?- << выполняется в отдельном потоке
- += замораживает результат, и Ruby приходится его размораживать
- Разницы нет: += компилируется в <<
- += на каждой итерации создаёт новую строку и копирует в неё всё накопленное, а << дописывает в существующую
s += part — это s = s + part: создаётся новый объект, копируется вся строка, старая уходит в мусор, так что цикл получается квадратичным. << мутирует строку на месте (но помните: это меняет её и для всех, кто держит ссылку).
Зачем писать
each, а не map, когда результат блока не нужен (только побочный эффект)?- each работает параллельно, а map — последовательно
- map изменяет исходный массив
- map создаёт и заполняет новый массив результатов, который сразу уходит в мусор
- map не умеет вызывать методы с побочными эффектами
map всегда аллоцирует массив того же размера с результатами блока. Если результат не используется, это лишняя память и работа для GC, а также вводит читателя в заблуждение.
Какой однопроходный вариант заменяет
users.select(&:active?).map(&:email) без промежуточного массива?- users.find_all(&:active?).collect(&:email)
- users.filter_map { |u| u.email if u.active? }
- users.map { |u| u.email if u.active? }
- users.flat_map { |u| u.email if u.active? }
filter_map (Ruby 2.7) за один проход собирает только истинные результаты блока. map и flat_map оставят nil для неактивных, а find_all/collect — те же select/map под другими именами, с тем же промежуточным массивом.
Нужно найти первые 10 строк с
ERROR в лог-файле на 20 ГБ. Какой вариант читает файл построчно и останавливается сразу после 10-й найденной строки?- File.foreach(path).lazy.select { |l| l.include?("ERROR") }.first(10)
- File.readlines(path).select { |l| l.include?("ERROR") }.first(10)
- File.read(path).lines.grep(/ERROR/).first(10)
- File.foreach(path).select { |l| l.include?("ERROR") }.first(10)
readlines и read загружают весь файл в память. foreach без блока читает построчно, но обычный select всё равно пройдёт файл до конца; lazy делает цепочку ленивой, и first(10) прекращает чтение, как только набралось 10 совпадений.
Что выведет этот код (Ruby 3.3)?
r = (1..Float::INFINITY).lazy.map { |x| x * 2 }.take(3)
p r.class
p r.to_a- Array, затем [2, 4, 6]
- Зависнет: бесконечный диапазон
- Enumerator::Lazy, затем [1, 2, 3]
- Enumerator::Lazy, затем [2, 4, 6]
У ленивого перечислителя take возвращает снова Lazy — ничего ещё не вычислено. Значения материализуются при to_a/force (или при first(n), который сразу возвращает массив); поэтому бесконечный диапазон не проблема.
Что верно про сборщик мусора CRuby 3.3?
- GC запускается только при явном вызове GC.start
- Память под объекты нужно освобождать вручную через ObjectSpace.free
- Это mark-and-sweep сборщик, поколенческий и инкрементальный; с Ruby 2.7 есть GC.compact для уплотнения кучи
- Это подсчёт ссылок: объект освобождается сразу, как только счётчик ссылок обнулился
CRuby использует трассирующий mark-and-sweep с поколениями (RGenGC) и инкрементальной разметкой, поэтому циклические ссылки ему не страшны. Подсчёт ссылок — это CPython; GC.start лишь принудительно запускает сборку, обычно она идёт автоматически.
Нужен кэш «объект → вычисленные данные», который не мешает GC собирать сами объекты-ключи. Что использовать?
- ObjectSpace.each_object
- ObjectSpace::WeakMap (или WeakRef)
- Hash.new.compare_by_identity
- Заморозить ключи через freeze
Обычный Hash держит сильные ссылки, и закэшированные объекты никогда не освободятся. WeakMap/WeakRef хранят слабые ссылки, которые GC не учитывает; в Ruby 3.3 добавлен ещё ObjectSpace::WeakKeyMap.
Зачем нужен унарный минус у строки —
-str (String#-@, с Ruby 3.2 есть алиас dedup)?- Возвращает замороженную дедуплицированную копию: одинаковые строки становятся одним объектом, что экономит память
- Возвращает строку в обратном порядке символов
- Возвращает незамороженную копию строки — противоположность +str
- Удаляет пробелы в начале и в конце строки
-str возвращает замороженную строку из внутренней таблицы интернированных строк, поэтому тысячи одинаковых значений (например, повторяющиеся ключи при парсинге) хранятся одним объектом. Размороженную копию, наоборот, даёт +str.
Что вернёт
Benchmark.realtime?require "benchmark"
t = Benchmark.realtime { sleep 0.1 }- Integer — прошедшее время в миллисекундах (около 100)
- Объект Benchmark::Tms с полями user, system и real
- Результат блока — nil
- Float — прошедшее время в секундах (около 0.1)
realtime возвращает время выполнения блока в секундах как Float. Объект Benchmark::Tms с разбивкой на user/system/real возвращает Benchmark.measure.
В цикле на 100 000 итераций проверяется
allowed.include?(id), где allowed — массив из 50 000 элементов. Что даст основное ускорение?- Отсортировать массив — include? сам переключится на бинарный поиск
- Использовать allowed.lazy.include?(id)
- Один раз преобразовать allowed в Set — проверка станет хеш-поиском
- Заморозить массив через freeze — замороженные массивы ищутся быстрее
Array#include? — линейный поиск O(n) на каждой проверке, а Set (хеш внутри) ищет за O(1) в среднем. freeze и sort на include? не влияют; бинарный поиск по отсортированному массиву есть только явно через bsearch.
Новое в Ruby 318
Какое определение endless-метода (Ruby 3.0+) корректно?
- def sq(x) => x * x
- def sq(x): x * x
- def sq(x) = x * x
- def sq x = x * x
Endless-метод записывается как def имя(параметры) = выражение. Скобки вокруг параметров обязательны: без них x = x * x читается как параметр со значением по умолчанию. Стрелка => и двоеточие — синтаксис других языков.
Что выведет этот код (Ruby 3.3)?
x = 1
y = 2
h = { x:, y: }
p h- {:x=>nil, :y=>nil}
- {"x"=>1, "y"=>2}
- SyntaxError
- {:x=>1, :y=>2}
С Ruby 3.1 в литерале хеша можно опустить значение: { x: } означает { x: x }. Ключи остаются символами, а значения берутся из одноимённых переменных.
Что выведет этот код (Ruby 3.3)?
def role = "admin"
user = "Ann"
p({ user:, role: })- {:user=>"Ann", :role=>"admin"}
- NameError: undefined local variable role
- {:user=>"Ann", :role=>nil}
- {:user=>"Ann", :role=>:role}
Сокращение { role: } подставляет значение идентификатора role — это может быть и локальная переменная, и вызов метода без аргументов. Здесь переменной нет, поэтому вызывается метод role.
Что выведет этот код (Ruby 3.3)?
pairs = [[1, 2], [3, 4]]
p pairs.map { _1 + _2 }
p pairs.map { _1 }- NoMethodError, затем [[1, 2], [3, 4]]
- [3, 7], затем [[1, 2], [3, 4]]
- [3, 7], затем [1, 3]
- [3, 7], затем [[1], [3]]
Нумерованные параметры (Ruby 2.7) работают как |a, b|, когда в блоке есть _2, поэтому пара раскладывается. Если используется только _1, блок ведёт себя как |x| — в _1 попадает весь элемент, без распаковки.
В какой версии Ruby появился неявный параметр блока
it ([1, 2].map { it * 2 })?- 3.0
- 3.3
- 3.4
- 2.7
it добавлен в Ruby 3.4 как более читаемая замена _1 для блоков с одним параметром. В 2.7 появились нумерованные параметры _1, _2…, а Ruby 3.3 лишь выдаёт предупреждение о будущем значении it.
Что выведет этот код (Ruby 3.3)?
def show(*args, **opts) = p([args, opts])
def wrap(*, **) = show(*, **)
wrap(1, 2, a: 3)- [[1, 2, {:a=>3}], {}]
- [[], {}]
- SyntaxError: анонимные * и ** нельзя передавать дальше
- [[1, 2], {:a=>3}]
С Ruby 3.2 анонимные параметры * и ** можно передать дальше как * и ** (а анонимный блок & — с 3.1). Позиционные и именованные аргументы при этом не смешиваются: a: 3 приходит именно в opts.
Что произойдёт при выполнении кода?
Point = Data.define(:x, :y)
p Point.new(1)- ArgumentError (missing keyword: :y)
- #<data Point x=1, y=nil>
- #<struct Point x=1, y=nil>
- nil
В отличие от Struct, Data (Ruby 3.2) требует все атрибуты: недостающие не заполняются nil, а вызывают ArgumentError. Позиционные аргументы внутри превращаются в именованные, поэтому сообщение говорит про missing keyword.
Что вернёт выражение
{ a: 1, b: 2, c: 3 }.except(:b, :z) (Ruby 3.3)?- {:a=>1, :c=>3, :z=>nil}
- {:a=>1, :c=>3}
- {:b=>2}
- KeyError: key not found: :z
Hash#except (Ruby 3.0) возвращает новый хеш без указанных ключей; отсутствующие ключи просто игнорируются. Противоположный метод, оставляющий только указанные ключи, — slice.
Что вернёт выражение
[1, 2, 3, 4].filter_map { |x| x * 10 if x.even? } (Ruby 3.3)?- [2, 4]
- [10, 20, 30, 40]
- [20, 40]
- [nil, 20, nil, 40]
filter_map отображает элементы блоком и сразу отбрасывает ложные результаты (nil и false). Обычный map оставил бы nil для нечётных.
Что вернёт выражение
[1, 2, 3, 4].filter_map { |x| x.even? } (Ruby 3.3)?- [2, 4]
- [false, true, false, true]
- [true]
- [true, true]
filter_map возвращает РЕЗУЛЬТАТЫ блока, а не исходные элементы: false отброшены, true остались. Чтобы получить сами чётные элементы, нужен select(&:even?).
Что выведет
p [1, 2, 3].intersect?([3, 4]), [1, 2].intersect?([5]) (Ruby 3.3)?- true, false
- [3], []
- 3, nil
- true, nil
Array#intersect? (Ruby 3.1) возвращает true/false — есть ли общие элементы. Это быстрее и выразительнее, чем (a & b).any?, потому что не строит массив пересечения.
Что выведет этот код (Ruby 3.3)?
Point = Data.define(:x, :y)
case Point.new(x: 0, y: 5)
in { x: 0, y: } then puts "on axis y=#{y}"
in Point then puts "point"
end- on axis y=
- on axis y=5
- point
- NoMatchingPatternError
Data реализует deconstruct_keys, поэтому объекты можно сопоставлять с хеш-паттерном. Первая ветка подходит (x равен 0) и связывает y со значением 5; до второй ветки дело не доходит.
Как включить YJIT в Ruby 3.3?
- Добавить require "yjit" в начало программы
- Только пересобрать Ruby с MJIT и задать переменную MJIT=1
- Он выключен по умолчанию: флаг ruby --yjit, переменная RUBY_YJIT_ENABLE=1 или (с 3.3) RubyVM::YJIT.enable в коде
- Ничего делать не нужно: YJIT включён по умолчанию с Ruby 3.0
YJIT (JIT-компилятор от Shopify) входит в CRuby с 3.1, но по умолчанию выключен. В 3.3 появилась возможность включить его во время работы через RubyVM::YJIT.enable (например, после загрузки приложения); MJIT в 3.3 удалён.
Что выведет
p 7.ceildiv(2), 7 / 2 (Ruby 3.3)?- 3, 3
- 4, 3.5
- 3.5, 3
- 4, 3
Integer#ceildiv (Ruby 3.2) — деление с округлением вверх, удобно для подсчёта страниц. Обычный / для целых округляет вниз (к минус бесконечности).
Что выведет этот код (Ruby 3.3)?
S = Struct.new(:a, :b)
p S.new(a: 1, b: 2)- #<struct S a=1, b=2>
- #<struct S a={:a=>1, :b=>2}, b=nil>
- ArgumentError
- #<struct S a=nil, b=nil>
С Ruby 3.2 Struct принимает именованные аргументы даже без keyword_init: true. До 3.2 хеш попадал целиком в первое поле, а b оставалось nil — частая ошибка при обновлении старого кода.
Что выведет этот код (Ruby 3.3)?
a = (1..5).overlap?(5..8)
b = (1...5).overlap?(5..8)
p a, b- NoMethodError
- true, false
- true, true
- false, false
Range#overlap? добавлен в Ruby 3.3. Диапазон 1..5 включает 5, поэтому пересекается с 5..8, а 1...5 исключает конец и с 5..8 общих значений не имеет.
Что выведет этот код (Ruby 3.3)?
class A; end
class B < A; end
class C < B; end
p A.subclasses- [C, B]
- NoMethodError
- [B]
- [B, C]
Class#subclasses (Ruby 3.1) возвращает только ПРЯМЫХ наследников. Для всех потомков раньше использовали ObjectSpace.each_object(Class) с проверкой k < A.
Как изменился вывод
p({ name: "Ann", 1 => 2 }) в Ruby 3.4 по сравнению с 3.3?- Никак: в обеих версиях {:name=>"Ann", 1=>2}
- 3.4 выводит как JSON: {"name": "Ann", "1": 2}
- 3.4: {name => "Ann", 1 => 2}
- 3.3: {:name=>"Ann", 1=>2}; 3.4: {name: "Ann", 1 => 2}
В Ruby 3.4 Hash#inspect стал выводить символьные ключи в современном стиле key: value, а остальные ключи — с пробелами вокруг =>. Это важно для тестов, сравнивающих вывод inspect строкой.
Идиомы Ruby15
Что выведет этот код (Ruby 3.3)?
@calls = 0
def find_user
@calls += 1
nil
end
def current_user
@current_user ||= find_user
end
3.times { current_user }
p @calls- 3
- 1
- 0
- NoMethodError
Мемоизация через ||= не работает, если результат nil или false: переменная остаётся ложной, и вычисление повторяется при каждом вызове. Для таких случаев проверяют defined?(@current_user) или instance_variable_defined?.
Что выведет этот код (Ruby 3.3)?
p Array(nil), Array([1, 2]), Array("a")- [], [[1, 2]], ["a"]
- [], [1, 2], ["a"]
- [nil], [[1, 2]], ["a"]
- [nil], [1, 2], ["a"]
Kernel#Array приводит значение к массиву: nil даёт пустой массив, массив возвращается как есть, остальное оборачивается. Идиома для параметров «один элемент или список»: Array(ids).each { ... }.
Что выведет этот код (Ruby 3.3)?
def expensive
puts "computing"
0
end
h = { a: 1 }
p h.fetch(:a, expensive)
p h.fetch(:a) { expensive }- computing, 1, computing, 1
- 1, computing, 1
- computing, 1, 1
- 1, 1
Аргумент по умолчанию вычисляется ДО вызова fetch, даже если ключ есть. Блок же вызывается только при отсутствии ключа — поэтому для дорогих значений по умолчанию используют форму с блоком.
Что выведет этот код (Ruby 3.3)?
opts = { cache: false }
a = opts[:cache] || true
b = opts.fetch(:cache, true)
p a, b- false, false
- true, true
- false, true
- true, false
Идиома x || default ломается на явно переданном false: оно ложно, и подставляется default. fetch проверяет именно наличие ключа и сохраняет false.
Что выведет этот код (Ruby 3.3)?
a = [3, 1, 2].tap { |x| x.sort }
b = [3, 1, 2].then { |x| x.sort }
p a, b- [3, 1, 2], [1, 2, 3]
- [1, 2, 3], [1, 2, 3]
- [3, 1, 2], [3, 1, 2]
- [1, 2, 3], [3, 1, 2]
tap передаёт объект в блок и возвращает сам объект, игнорируя результат блока (а sort не мутирует массив). then (yield_self) возвращает результат блока — удобно для цепочек преобразований.
Что выведет этот код (Ruby 3.3)?
a = [0.1, 0.2, 0.3]
p a.sum
p a.inject(:+)- 0.6000000000000001, затем 0.6
- 0.6, затем 0.6000000000000001
- 0.6000000000000001, затем 0.6000000000000001
- 0.6, затем 0.6
Для Float Array#sum использует компенсационное суммирование Кэхэна-Бабушки и накапливает меньше ошибки округления. inject(:+) складывает «в лоб»: 0.1 + 0.2 = 0.30000000000000004, отсюда хвост в последнем знаке.
Что выведет этот код (Ruby 3.3)?
p ["a", "b"].sum("")
p ["a", "b"].sum- "ab", затем 0
- TypeError, затем TypeError
- "ab", затем TypeError
- "ab", затем "ab"
sum начинает с начального значения 0, и 0 + "a" — TypeError (String can't be coerced into Integer). С явной стартовой строкой "" суммирование строк работает, хотя для склейки идиоматичнее join.
Что выведет этот код (Ruby 3.3)?
p Integer("12a", exception: false), Integer("0x1A", exception: false)- 12, 26
- nil, nil
- nil, 0
- nil, 26
С exception: false Integer() вместо ArgumentError возвращает nil — удобная проверка ввода без rescue. При этом Integer() понимает префиксы 0x, 0b, 0o и 0, поэтому "0x1A" — это 26 (а to_i вернул бы 0).
Что выведет этот код (Ruby 3.3)?
p 15.clamp(1, 10), -3.clamp(0..), 5.clamp(..3)- 10, 0, 3
- 15, -3, 5
- 10, -3, 3
- 1, 0, 3
clamp ограничивает значение диапазоном: берёт ближайшую границу, если значение за её пределами. Можно передать две границы или диапазон, в том числе бесконечный с одной стороны.
Что выведет этот код (Ruby 3.3)?
people = [["Bob", 30], ["Ann", 30], ["Cid", 25]]
p people.sort_by { |name, age| [-age, name] }.map(&:first)- ["Cid", "Bob", "Ann"]
- ["Ann", "Bob", "Cid"]
- ["Cid", "Ann", "Bob"]
- ["Bob", "Ann", "Cid"]
Массивы сравниваются поэлементно, поэтому ключ [-age, name] сортирует по убыванию возраста, а при равенстве — по имени по возрастанию. Минус перед числом — стандартный приём для обратного порядка по одному из ключей.
Что выведет
p %i[a b].zip([1, 2]).to_h (Ruby 3.3)?- {:a=>[1, 2]}
- {"a"=>1, "b"=>2}
- {:a=>1, :b=>2}
- [[:a, 1], [:b, 2]]
zip склеивает массивы в пары, а to_h превращает массив пар в хеш. %i[] создаёт массив символов, поэтому ключи — символы.
Что выведет
p %i[draft published] (Ruby 3.3)?- ["draft", "published"]
- [:"draft published"]
- "draft published"
- [:draft, :published]
%i[] — литерал массива символов (разделитель — пробелы), %w[] — массива строк. Удобно для списков статусов, атрибутов в attr_reader и т.п.
Что такое guard clause?
def discount(user)
return 0 unless user
return 0 if user.banned?
user.vip? ? 20 : 5
end- Ранний выход из метода (return/raise/next) при особом случае, чтобы основная логика не была вложена в if
- Блок rescue, который защищает метод от исключений
- Проверка типов аргументов, встроенная в Ruby 3
- Конструкция, запрещающая вызывать метод с nil
Guard clause — проверка в начале метода с немедленным выходом. Она убирает вложенность if/else и делает «счастливый путь» последней, ничем не обёрнутой строкой; RuboCop прямо рекомендует этот стиль.
Что выведет этот код (Ruby 3.3)?
user = nil
user&.update(puts("saving"))
p :done- NoMethodError
- Только :done
- saving, затем :done
- saving, затем NoMethodError
Если получатель &. равен nil, вызов пропускается целиком, и даже аргументы метода не вычисляются, поэтому puts не выполняется. Это стоит помнить, если в аргументах есть побочные эффекты.
Что вернёт выражение
{ a: 1, b: 2 }.transform_keys(&:to_s) (Ruby 3.3)?- [["a", 1], ["b", 2]]
- {"a"=>"1", "b"=>"2"}
- {"a"=>1, "b"=>2}
- {:a=>"1", :b=>"2"}
transform_keys возвращает новый хеш с преобразованными ключами, значения не трогает (для них есть transform_values). Типичный приём для строковых ключей перед сериализацией.
Найдите ошибку17
Найдите ошибку. Что выведет код?
DEFAULT_TAGS = []
def tag(item, tags = DEFAULT_TAGS)
tags << item
end
tag("a")
p tag("b")- ["b"] — значение по умолчанию вычисляется заново при каждом вызове
- FrozenError — константы заморожены
- ["b"], но с предупреждением о константе
- ["a", "b"] — метод мутирует общий массив-константу
Выражение по умолчанию действительно вычисляется при каждом вызове, но здесь оно каждый раз возвращает ОДИН и тот же объект DEFAULT_TAGS, и << меняет его для всех. Константы в Ruby не заморожены автоматически; исправление — tags = [] или DEFAULT_TAGS.dup (и freeze у константы).
Найдите ошибку. Что выведет код (Ruby 3.3, без магического комментария)?
def admin?(role)
role.equal?("admin")
end
p admin?("admin")- false
- true
- nil
- "admin"
equal? проверяет идентичность объектов, а два строковых литерала — разные объекты. Для сравнения значений нужен ==; equal? почти никогда не переопределяют и применяют редко.
В чём проблема этого кода воркера?
loop do
begin
process_next_job
rescue Exception => e
logger.error(e.message)
end
end- Проблемы нет: rescue Exception — рекомендуемый способ поймать все ошибки
- rescue Exception ловит и Interrupt (Ctrl+C), и SystemExit от exit, и SignalException, поэтому процесс нельзя штатно остановить; нужен rescue => e (StandardError)
- rescue внутри loop недопустим — нужен retry
- У Exception нет метода message
Exception — корень всей иерархии, включая служебные исключения для остановки процесса и NoMemoryError. Голый rescue => e ловит StandardError — именно прикладные ошибки, а сигналы и exit проходят дальше.
Что выведет этот код (Ruby 3.3)?
x = 10
[1, 2, 3].each { |x| x += 1 }
p x- 11
- 16
- 10
- 13
Параметр блока x затеняет внешнюю переменную — внутри блока это отдельная локальная переменная, и внешний x не меняется. Это частый источник незаметных багов при одинаковых именах.
Что выведет этот код (Ruby 3.3)?
total = 0
[1, 2, 3].each { |n; total| total = n * 10 }
p total- 30
- 60
- SyntaxError
- 0
Имена после точки с запятой в параметрах блока — блоко-локальные переменные: они затеняют одноимённые внешние, даже если блоку не передаются. Поэтому присваивание не трогает внешний total.
Найдите ошибку. Что выведет код?
def double_all(items)
results = items.map do |i|
return nil if i.nil?
i * 2
end
results.compact
end
p double_all([1, nil, 3])- nil
- [2, 6]
- [2, nil, 6]
- LocalJumpError
return внутри блока завершает весь МЕТОД double_all, а не итерацию — на nil метод сразу возвращает nil. Чтобы пропустить элемент, нужен next (или next nil), а ещё проще — filter_map.
Найдите ошибку. Что произойдёт?
class Money
include Comparable
attr_reader :cents
def initialize(cents)
@cents = cents
end
def <=>(other)
cents <=> other.cents
end
end
p Money.new(100) == 100- nil
- NoMethodError: у Integer нет метода cents
- false
- true
Comparable#== вызывает <=>, а он обращается к other.cents. С Ruby 2.3 Comparable#== не глотает исключения, поэтому сравнение с объектом другого типа падает. Правильный <=> начинается с return nil unless other.is_a?(Money) — тогда == вернёт false.
Найдите ошибку. Что произойдёт?
user = nil
p user&.profile.name- ""
- SyntaxError
- NoMethodError: undefined method name for nil
- nil
В Ruby &. защищает только один следующий вызов: user&.profile вернёт nil, а затем обычный .name вызывается уже на nil. Цепочку нужно писать user&.profile&.name (RuboCop: Lint/SafeNavigationChain).
Почему этот код падает с NoMethodError?
index = [1, 2].inject({}) { |h, x| h[x] = x * 10 }- inject не принимает начальное значение-хеш
- Параметры блока перепутаны: должно быть |x, h|
- Внутри блока inject нельзя изменять хеш
- Блок возвращает значение присваивания (10), и на второй итерации аккумулятор h — уже Integer без метода []=
Следующее значение аккумулятора inject — это результат блока, а результат присваивания h[x] = 10 равен 10. Нужно вернуть h явно (...; h) или использовать each_with_object({}), где аккумулятор передаётся сам.
Найдите ошибку. Что выведет код?
nums = [2, 4, 5, 6]
nums.each { |n| nums.delete(n) if n.even? }
p nums- [4, 5]
- [5]
- [2, 4, 5, 6]
- RuntimeError: can't modify array during iteration
each идёт по индексам, а удаление сдвигает элементы: после удаления 2 на место индекса 1 встаёт 5, и 4 пропускается. Ruby не запрещает менять массив во время each — нужно использовать reject!/delete_if или select.
Найдите ошибку. Что выведет код (без магического комментария)?
def greet(name)
name << "!"
"Hi, #{name}"
end
user = "Ann"
greet(user)
p user- FrozenError
- "Ann!"
- "Ann"
- "Hi, Ann!"
В метод передаётся ссылка на тот же объект, а << мутирует строку на месте — меняется и переменная вызывающего кода. Внутри метода безопаснее создать новую строку: name + "!" или "#{name}!".
Что выведет этот код (Ruby 3.3)?
r = [1, 2].map { |x| puts x * 10 }
p r- [10, 20]
- 10, 20, затем [1, 2]
- 10, 20, затем [nil, nil]
- 10, 20, затем [10, 20]
puts печатает и возвращает nil, поэтому map собирает nil-ы. Если нужно и напечатать, и вернуть значение, используют p (он возвращает аргумент) или выводят отдельно.
Найдите ошибку. Что выведет код?
done = 1
total = 3
p done / total * 100- 33
- 100
- 0.33
- 0
1 / 3 для целых — это 0, и умножение уже ничего не спасает. Нужно перейти к Float до деления: done * 100.0 / total или done.fdiv(total) * 100.
Что выведет
p 0.1 + 0.2 == 0.3 (Ruby 3.3)?- false
- true
- 0.30000000000000004
- nil
0.1 и 0.2 не представимы точно в двоичной плавающей точке, сумма равна 0.30000000000000004. Деньги считают в целых копейках, Rational (0.1r + 0.2r == 0.3r) или BigDecimal, а Float сравнивают с допуском.
Найдите ошибку. Что выведет код?
def access(role)
case role
when "admin" || "root" then "full"
else "limited"
end
end
p access("root")- SyntaxError
- "limited"
- "full"
- nil
"admin" || "root" вычисляется заранее и даёт просто "admin", так что root не проверяется. Несколько вариантов в when перечисляют через запятую: when "admin", "root".
Что произойдёт при выполнении кода?
h = { a: 1 }
h.each { |k, v| h[:"#{k}2"] = v }
p h- Бесконечный цикл: новые ключи тоже перебираются
- {:a2=>1}
- RuntimeError: can't add a new key into hash during iteration
- {:a=>1, :a2=>1}
Добавлять НОВЫЕ ключи в хеш во время его перебора запрещено — Ruby бросает RuntimeError (изменять значения существующих ключей и удалять можно). Решение — собрать изменения в отдельный хеш и затем merge!.
Найдите ошибку. Что выведет код?
tags = ["a", "b"]
tags = tags.uniq!
p tags- ["a", "b"]
- []
- true
- nil
Bang-методы вроде uniq!, compact!, flatten! возвращают nil, если ничего не изменили. Их результат нельзя присваивать: либо tags.uniq! отдельной строкой, либо tags = tags.uniq.
ActiveRecord23
Что произойдёт с комментариями при
post.destroy, если в модели Post объявлено has_many :comments, dependent: :delete_all?- Для каждого комментария загрузится объект и вызовется
destroyс колбэками - Они удалятся одним SQL-запросом
DELETE, без загрузки объектов и без их колбэков - У комментариев обнулится
post_id, а сами записи останутся - Удаление поста будет запрещено, пока у него есть комментарии
dependent: :delete_all удаляет дочерние записи прямо в БД одним запросом, поэтому колбэки Comment (и их собственные dependent) не выполняются. Загрузка каждого объекта с колбэками — это dependent: :destroy, обнуление ключа — :nullify, запрет удаления — :restrict_with_exception / :restrict_with_error.Что выведет этот код, если у пользователя с id 1 есть посты?
class User < ApplicationRecord
has_many :posts, dependent: :restrict_with_error
end
user = User.find(1)
p user.destroy
p User.exists?(1)- Исключение
ActiveRecord::DeleteRestrictionError - Объект
user, затемfalse(посты удалены вместе с ним) false, затемtruenil, затемtrue
При
:restrict_with_error Rails добавляет ошибку в user.errors[:base] и прерывает удаление, а destroy возвращает false — запись остаётся в БД. Исключение DeleteRestrictionError выбрасывает другой вариант — dependent: :restrict_with_exception.Какие колонки должны быть в таблице
comments для ассоциации belongs_to :commentable, polymorphic: true?- Только
commentable_id commentable_idиcommentable_class- Никаких: нужна отдельная join-таблица
commentables commentable_idиcommentable_type
Полиморфная связь хранит id родителя и имя его класса: в
commentable_type лежит, например, "Post" или "Photo". По одному id Rails не понял бы, в какой таблице искать. Обратная сторона — обычный внешний ключ (FOREIGN KEY) на такую колонку в БД не повесить.Объявлено
class Admin < User; end, обе модели используют таблицу users (Single Table Inheritance). Что верно?- В таблице нужна колонка
type:Admin.createзапишет туда"Admin", аAdmin.allдобавит условие поtype - Rails создаст отдельную таблицу
adminsпри первом сохраненииAdmin - Нужна колонка
kind, и её значение надо выставлять вручную перед сохранением User.allвернёт только записи с пустымtype, без администраторов
STI хранит всю иерархию в одной таблице, а класс записи — в колонке
type (имя колонки по умолчанию). Запросы через подкласс автоматически фильтруются по type, а запрос через базовый класс User.all возвращает все записи, включая Admin, и создаёт объекты нужных классов.Как Rails 7.1 загрузит данные в этом коде (
Post has_many :comments)?posts = Post.includes(:comments)
.where(comments: { approved: true })
posts.to_a- Двумя запросами: сначала посты, затем комментарии, как
preload - Одним запросом с
INNER JOIN comments, какjoins - Одним запросом с
LEFT OUTER JOIN comments, какeager_load - Выбросит ошибку: сначала нужно вызвать
references(:comments)
includes сам выбирает стратегию: если условия ссылаются на таблицу ассоциации, он переключается на eager_load (один запрос с LEFT OUTER JOIN). Для хэш-условия where(comments: ...) Rails сам понимает, что таблица используется, поэтому references не нужен — он обязателен только для строковых условий.Что произойдёт при выполнении этого кода в Rails 7.1?
Post.includes(:comments)
.where("comments.approved = true")
.to_a- Один запрос с LEFT OUTER JOIN: Rails найдёт имя таблицы
commentsв строке - Ошибка SQL: Rails выберет
preload, и в запросе кpostsтаблицыcommentsне будет - Два запроса, и строковое условие применится ко второму — к комментариям
- Один запрос с INNER JOIN, вернутся только посты с одобренными комментариями
Rails не разбирает строковые фрагменты SQL, поэтому
includes остаётся в режиме preload: первый запрос — SELECT posts.* FROM posts WHERE (comments.approved = true), и БД выдаёт ошибку (ActiveRecord::StatementInvalid). Нужно добавить .references(:comments), использовать eager_load или хэш-условие where(comments: { approved: true }).Чем
preload отличается от eager_load?preloadиспользуетINNER JOIN, аeager_load— подзапросpreloadгрузит ассоциацию лениво при первом обращении,eager_load— сразу- Ничем: оба — синонимы
includes preloadгрузит ассоциацию отдельным запросом,eager_load— одним запросом сLEFT OUTER JOIN
Оба метода загружают ассоциации заранее и решают проблему N+1.
preload всегда делает отдельный запрос WHERE post_id IN (...), поэтому по таблице ассоциации нельзя фильтровать; eager_load всегда делает JOIN. includes выбирает между ними автоматически.В БД есть автор A с тремя постами и автор B без постов. Что вернёт
Author.joins(:posts).to_a.size?- 1
- 3
- 2
- 4
joins делает INNER JOIN: автор B без постов в результат не попадает, а автор A повторяется по разу на каждую строку соединения — три объекта. Чтобы убрать дубликаты, добавляют .distinct. Сами посты joins не загружает — для этого нужен includes/eager_load.Почему
User.pluck(:email) обычно лучше, чем User.all.map(&:email)?- Делает
SELECT emailи возвращает массив строк, не создавая объекты моделей - Кэширует результат между запросами
- Возвращает ленивый
Relation, к которому можно дописать условия - Выполняет запрос в фоне, не блокируя текущий поток
User.all.map(&:email) выбирает все колонки и создаёт объект User на каждую строку — это лишние память и время. pluck сразу выполняет запрос только по нужным колонкам и возвращает обычный массив значений (это не Relation, цепочку продолжить нельзя).Что произойдёт на второй строке, если в таблице
users есть колонка email?user = User.select(:id).first
user.email- Вернётся
nil - Rails выполнит дополнительный запрос и вернёт email
ActiveModel::MissingAttributeError: атрибут не был выбран запросомNoMethodError: методemailне определён
select возвращает объекты модели, но заполняет только выбранные колонки. Обращение к невыбранному атрибуту выбрасывает MissingAttributeError, а не возвращает nil — так Rails не даёт спутать «не загружено» с «пусто в БД». Метод email при этом существует, поэтому NoMethodError не будет.В каком порядке будут обработаны пользователи (Rails 7.1, настройки по умолчанию)?
User.order(:name).find_each(batch_size: 500) do |user|
puts user.name
end- По имени, пачками по 500
- В произвольном порядке, как вернёт БД
- Никак:
find_eachпослеorderвсегда выбрасывает исключение - По возрастанию первичного ключа:
order(:name)игнорируется с предупреждением в логе
Пакетная обработка листает таблицу по первичному ключу (
WHERE id > последний LIMIT 500), поэтому пользовательская сортировка отбрасывается, а в лог пишется предупреждение. Исключение будет только при config.active_record.error_on_ignored_order = true. Направление по ключу можно задать опцией order: :desc.Что верно про вызов
Post.where(draft: true).update_all(published: true)?- Загружает каждую запись и вызывает
update, поэтому валидации отработают - Один
UPDATEв БД; валидации и колбэки не вызываются,updated_atсам не меняется - Возвращает
Relationс уже обновлёнными записями - Обновляет
publishedи автоматически проставляетupdated_at
update_all строит один SQL UPDATE ... WHERE draft = TRUE и возвращает число затронутых строк. Объекты моделей не создаются, поэтому нет ни валидаций, ни колбэков, ни автоматического updated_at (его передают явно: update_all(published: true, updated_at: Time.current)).Что выведет этот код (локаль по умолчанию —
en)?class User < ApplicationRecord
validates :email, presence: true
end
user = User.new(email: "")
p user.save
p user.errors.full_messages- Исключение
ActiveRecord::RecordInvalid nil, затем["Email can't be blank"]false, затем[]false, затем["Email can't be blank"]
save запускает валидации и при ошибке возвращает false, заполняя errors. Исключение RecordInvalid выбрасывает только save!. Пустая строка не проходит presence, потому что проверка идёт через blank?.Что вернёт
User.create(email: ""), если модель валидирует наличие email?false- Несохранённый объект
User(persisted?—false) с заполненнымиerrors nil- Выбросит
ActiveRecord::RecordInvalid
create всегда возвращает объект, даже если сохранить его не удалось, поэтому if User.create(...) всегда истинно — частая ошибка. Проверяют persisted? / errors или используют create!, который при невалидных данных выбрасывает RecordInvalid.Какие пользователи останутся в БД после выполнения этого кода?
User.transaction do
User.create!(name: "Kotori")
User.transaction do
User.create!(name: "Nemu")
raise ActiveRecord::Rollback
end
end- Оба: и Kotori, и Nemu
- Только Kotori
- Никого: откатится вся транзакция
- Никого, и наружу вылетит
ActiveRecord::Rollback
Вложенный
transaction без requires_new: true не создаёт новую транзакцию, а присоединяется к внешней. ActiveRecord::Rollback молча перехватывается внутренним блоком и до внешнего не доходит, поэтому внешняя транзакция фиксирует обе записи. Чтобы откатить только внутреннюю часть, нужен User.transaction(requires_new: true) (SAVEPOINT).В таблице
products есть колонка lock_version. Что произойдёт при выполнении этого кода?a = Product.find(1)
b = Product.find(1)
a.update!(price: 10)
b.update!(price: 20)- Обе записи сохранятся, в БД останется цена 20
- Второй
update!вернётfalse - Второй
update!выброситActiveRecord::StaleObjectError - Второй вызов будет ждать, пока первый не освободит блокировку строки
Колонка
lock_version включает оптимистичную блокировку: UPDATE ... WHERE id = 1 AND lock_version = 0 для b не затронет ни одной строки (версия уже стала 1), и Rails выбросит StaleObjectError. Ожидание блокировки строки — это пессимистичная блокировка (lock / with_lock, SELECT ... FOR UPDATE).У
Comment объявлено belongs_to :post, counter_cache: true, в posts есть колонка comments_count. Какой вызов вернёт число комментариев без SQL-запроса (ассоциация ещё не загружена)?post.comments.countpost.comments.lengthpost.comments.to_a.countpost.comments.size
size у незагруженной ассоциации берёт значение из comments_count, если есть счётчик. count всегда выполняет SELECT COUNT(*), а length и to_a загружают все комментарии в память. Счётчик Rails обновляет при create/destroy комментария, но не при массовых операциях вроде update_all и не при прямом SQL.Что выведет этот код (Rails 7.1)?
class Article < ApplicationRecord
enum :status, { draft: 0, published: 1 }
end
a = Article.create!(status: :draft)
a.published!
p a.status
p a.draft?1, затемfalse"published", затемfalse:published, затемfalse"published", затемtrue
В БД хранится число, но геттер enum-атрибута возвращает имя значения строкой —
"published", а не символ и не 1. Метод published! сразу сохраняет запись (update!), а предикаты вроде draft? проверяют текущее значение. Enum также даёт скоупы Article.published и Article.not_draft.Нужно только проверить, есть ли у пользователя неоплаченные заказы. Какой вариант эффективнее?
user.orders.unpaid.present?user.orders.unpaid.to_a.any?user.orders.unpaid.exists?user.orders.unpaid.length > 0
exists? выполняет SELECT 1 ... LIMIT 1 и не создаёт объектов. present?, to_a и length загружают все подходящие записи в память, хотя нужен только ответ «да/нет». Если записи всё равно понадобятся дальше, загрузка оправдана — тогда повторного запроса не будет.Какую операцию в методе
change миграции Rails не сможет откатить автоматически (db:rollback выбросит ActiveRecord::IrreversibleMigration)?add_column :users, :age, :integeradd_index :users, :email, unique: truerename_column :users, :login, :usernamechange_column :users, :age, :bigint
Для
add_column, add_index, rename_column, create_table Rails знает обратную операцию. У change_column прежний тип колонки неизвестен, поэтому откат невозможен — используют пару up/down или блок reversible.На
users.email есть уникальный индекс и validates :email, uniqueness: true. Два параллельных запроса одновременно прошли валидацию с одинаковым email. Что произойдёт со вторым user.save?- Выбросит
ActiveRecord::RecordNotUnique— ошибку от БД, а не вернётfalse - Вернёт
false, ошибка появится вuser.errors[:email] - Запишет дубликат: индекс проверяется только при запуске миграции
- Тихо обновит уже существующую запись с тем же email
save возвращает false только при неудачной валидации. Здесь валидация уже пройдена, и INSERT отклоняет сама БД — Rails превращает это в исключение RecordNotUnique. Его нужно ловить (rescue ActiveRecord::RecordNotUnique) и показывать пользователю как обычную ошибку валидации.Зачем указывают
inverse_of у ассоциаций?- Чтобы при удалении поста удалялись и его комментарии
- Чтобы
post.comments.first.postбыл тем же объектом в памяти, что иpost, без лишнего запроса - Чтобы Rails создал внешний ключ в БД
- Чтобы ассоциация по умолчанию загружалась жадно
inverse_of связывает две стороны ассоциации: загруженный комментарий получает ссылку на уже существующий объект post, а не грузит его заново. Это экономит запросы и избавляет от рассинхронизации (изменили post в памяти — комментарий видит изменения). В простых случаях Rails определяет обратную связь сам, но, например, при ассоциации со scope её приходится указывать явно.Что произойдёт с письмом, если
payment.charge! выбросит исключение?class Order < ApplicationRecord
after_save { OrderMailer.confirmed(self).deliver_now }
end
Order.transaction do
order.update!(status: "confirmed")
payment.charge!
end- Письмо не уйдёт: колбэки откатываются вместе с транзакцией
- Письмо отправится, но только после фиксации транзакции
- Письмо уйдёт, хотя изменения заказа откатятся; нужен
after_commit - Письмо не уйдёт: внутри транзакции
after_saveне вызывается
after_save выполняется внутри транзакции сразу после UPDATE, до коммита. Транзакция откатит данные в БД, но отправленное письмо не вернуть. Побочные эффекты (письма, задачи, вызовы API) вешают на after_commit (after_update_commit и т.п.) — он срабатывает только после успешной фиксации.Rails: контроллеры и роутинг15
Почему при ошибке сохранения здесь используется
render :new, а не redirect_to new_user_path?def create
@user = User.new(user_params)
if @user.save
redirect_to @user
else
render :new, status: :unprocessable_entity
end
endredirect_toне умеет перенаправлять на экшенnewrender :newзаново вызывает экшенnew, и тот создаёт свежий@userredirect_toработает только для GET-запросов, аcreate— это POSTrenderотдаёт шаблон в том же запросе: форма покажет введённые данные и ошибки из@user
render :new просто рендерит шаблон new в текущем запросе, экшен new при этом не вызывается, и @user с errors остаётся доступен. redirect_to заставляет браузер сделать новый GET-запрос — объект с ошибками и введённые данные теряются.Что произойдёт при запросе неопубликованного поста?
def show
@post = Post.find(params[:id])
redirect_to root_path unless @post.published?
render :show
end- Произойдёт редирект на
root_path AbstractController::DoubleRenderError:redirect_toне прерывает экшен- Отрендерится
show, а редирект будет проигнорирован - Ответ 204 без тела
redirect_to лишь формирует ответ и не останавливает метод, поэтому затем выполняется render :show — второй ответ в одном экшене, и Rails выбрасывает DoubleRenderError. Исправление: return redirect_to(root_path) unless @post.published? или redirect_to root_path and return.Почему в Rails 7 (с Turbo) при неудачной отправке формы пишут
render :new, status: :unprocessable_entity, а не просто render :new?- Turbo Drive ждёт в ответ на отправку формы редирект или код 4xx/5xx; ответ 200 с HTML он не отрисует
- Без явного статуса Rails вернёт 500
- Статус 422 нужен, чтобы браузер не кэшировал страницу с формой
- Без этого статуса
flash.nowне попадёт в шаблон
Turbo перехватывает отправку формы через fetch и ожидает либо редирект (303/302) после успешного изменения, либо ошибку 4xx/5xx с HTML, который он и покажет. На ответ 200 Turbo не обновит страницу, и пользователь не увидит ошибок валидации. Поэтому генераторы Rails 7 добавляют
status: :unprocessable_entity (422).В чём проблема этого фрагмента экшена?
if login_failed?
flash[:alert] = "Неверный пароль"
render :new, status: :unprocessable_entity
end- Сообщение не покажется:
flashдоступен только после редиректа flashнельзя использовать вместе со статусом 422- Сообщение покажется сейчас и ещё раз на следующей странице; при
renderнуженflash.now - Проблемы нет:
flashочищается сразу после рендера
Обычный
flash предназначен для следующего запроса (после redirect_to), но в текущем запросе он тоже читается — поэтому сообщение видно сразу и «переживёт» ещё один переход. flash.now[:alert] действует только в текущем запросе и подходит для render.Что произойдёт в
params.require(:user).permit(:name), если в запросе вообще нет ключа user?- Вернётся пустой
ActionController::Parameters - Вернётся
nil - Будет выброшено
ActiveModel::ForbiddenAttributesError - Будет выброшено
ActionController::ParameterMissing, Rails ответит 400 Bad Request
require гарантирует наличие ключа: если его нет (или значение пустое), выбрасывается ParameterMissing, который Rails превращает в ответ 400. ForbiddenAttributesError возникает в другой ситуации — когда в модель передают неразрешённые параметры без permit.Что выведет этот код (Rails 7.1, Ruby 3.3, настройки по умолчанию)?
params = ActionController::Parameters.new(
user: { name: "Ann", admin: "1" }
)
p params.require(:user).permit(:name).to_h{"name"=>"Ann"}{"name"=>"Ann", "admin"=>"1"}{:name=>"Ann"}- Исключение
ActionController::UnpermittedParameters
Неразрешённые ключи (
admin) по умолчанию просто отбрасываются (в development/test об этом пишется в лог). Исключение UnpermittedParameters будет только при config.action_controller.action_on_unpermitted_parameters = :raise. to_h возвращает HashWithIndifferentAccess со строковыми ключами.Пришли параметры
{ post: { title: "Hi", tags: ["ruby", "rails"] } }. Что будет с tags в этом вызове?params.require(:post).permit(:title, :tags)- Пропустится как есть
- Отфильтруется: для массива скаляров нужно
permit(:title, tags: []) - Пропустится только первый элемент
"ruby" - Будет выброшено
ActionController::ParameterMissing
Символ в
permit разрешает только скалярное значение (строку, число, файл и т.п.). Массив нужно объявить явно: tags: [], вложенный хэш — address: [:city, :zip]. Иначе ключ молча отбрасывается.Что делает
head :no_content в экшене контроллера?- Рендерит только секцию
<head>шаблона - Возвращает 404, если запись не найдена
- Отправляет ответ со статусом 204 и пустым телом, без рендера шаблона
- Делает редирект на предыдущую страницу
head формирует ответ только из статуса и заголовков. :no_content — это 204, его часто отдают API после успешного DELETE или PATCH. Шаблон при этом не рендерится, и второй render в том же экшене вызвал бы DoubleRenderError.Что произойдёт при запросе
GET /posts/1.xml?def show
@post = Post.find(params[:id])
respond_to do |format|
format.html
format.json { render json: @post }
end
end- Отрендерится HTML-шаблон как формат по умолчанию
- Rails сам сериализует
@postв XML - Ответ 404 Not Found
ActionController::UnknownFormat, клиент получит 406 Not Acceptable
respond_to обслуживает только перечисленные форматы. Для xml подходящего блока нет, поэтому выбрасывается UnknownFormat, который Rails превращает в ответ 406. Запись при этом найдена, так что 404 здесь ни при чём.В каком порядке выполнятся эти фильтры перед экшеном
PostsController?class ApplicationController < ActionController::Base
before_action :a
end
class PostsController < ApplicationController
before_action :b
prepend_before_action :c
end- a, b, c
- a, c, b
- c, a, b
- c, b, a
Фильтры выполняются в порядке объявления, унаследованные из родителя — первыми (a, затем b).
prepend_before_action ставит фильтр в самое начало всей цепочки, включая унаследованные, поэтому c идёт перед a.before_action :authenticate вызвал redirect_to login_path. Выполнится ли after_action :log_visit этого контроллера?- Да:
after_actionвыполняется всегда, какensure - Да, но только если
log_visitобъявлен раньшеauthenticate - Нет, и Rails выбросит
DoubleRenderError - Нет: цепочка прервана, не выполнятся ни экшен, ни
after_action
Если
before_action отрендерил ответ или сделал редирект, цепочка колбэков останавливается: экшен не вызывается, а after_action пропускаются. Для кода, который должен выполниться всегда, используют around_action с ensure или middleware.Что верно про маршрут
resource :profile (в единственном числе)?- Маршруты без
:idи безindex(/profile,/profile/edit), а обслуживает ихProfilesController - Маршруты те же, что у
resources, но контроллер —ProfileController - Создаётся только один маршрут —
show - Маршруты с
:id, но безnewиcreate
Единичный ресурс описывает объект, который у клиента один (свой профиль, корзина), поэтому
:id в URL не нужен и экшена index нет. При этом контроллер, как и для resources, называется во множественном числе — ProfilesController; это частая ловушка.Какие маршруты добавят блоки
member и collection?resources :photos do
member { post :publish }
collection { get :search }
endPOST /photos/publishиGET /photos/:id/searchPOST /photos/:id/publishиGET /photos/searchPOST /photos/:id/publishиGET /photos/:id/searchPOST /publish/:idиGET /search
member — действие над конкретной записью, поэтому в URL есть :id (хелпер publish_photo_path(photo)). collection — действие над всей коллекцией, без :id (хелпер search_photos_path).Какой URL будет у экшена
show для комментария 7 статьи 3?resources :articles do
resources :comments, shallow: true
end/articles/3/comments/7/articles/comments/7/comments/7/articles/3/7
При
shallow: true вложенными остаются только маршруты, которым нужен родитель: index, new, create (/articles/3/comments). Для show, edit, update, destroy id комментария и так однозначен, поэтому URL короткий — /comments/7.Какой вариант в
routes.rb даст URL /admin/users, но обрабатывать его будет обычный UsersController (без модуля Admin)?namespace :admin do resources :users endscope module: "admin" do resources :users endresources :users, module: "admin"scope "/admin" do resources :users end
scope "/admin" меняет только путь, контроллер остаётся UsersController, а хелпер — users_path. namespace :admin меняет сразу путь, модуль (Admin::UsersController) и хелперы (admin_users_path). scope module: "admin" и опция module: меняют только модуль контроллера, URL остаётся /users.Rails: фоновые задачи и кэш12
Почему в аргументы
Sidekiq::Job передают user.id, а не сам объект user?- Аргументы сериализуются в JSON: объект модели так не передать, а к запуску он устареет
- Sidekiq не умеет передавать больше одного аргумента
- Объект передаётся по ссылке, и задача изменит его прямо в контроллере
- По id Sidekiq понимает, что задачу не нужно запускать дважды
Sidekiq кладёт аргументы в Redis в виде JSON, поэтому допустимы только простые типы (строки, числа, массивы, хэши). Задача выполняется в другом процессе и позже, так что запись надо загрузить заново по id — тогда данные будут актуальными. В ActiveJob объекты моделей передавать можно: их сериализует GlobalID, но запись всё равно перечитывается из БД.
Что произойдёт, когда воркер возьмёт задачу (
NotifyJob < ApplicationJob, user — запись ActiveRecord)?NotifyJob.perform_later(user)
user.destroy # до того как задача начала выполняться- Задача получит
userв том состоянии, в каком он был при постановке в очередь performполучитnilвместо пользователяActiveJob::DeserializationError: по GlobalID запись уже не найти- Задача будет тихо пропущена без ошибок
ActiveJob сохраняет в очередь не объект, а ссылку GlobalID вида
gid://app/User/1 и при выполнении загружает запись из БД. Если её уже удалили, загрузка падает с DeserializationError. Такие задачи часто отбрасывают через discard_on ActiveJob::DeserializationError.Почему фоновые задачи (Sidekiq/ActiveJob) стоит делать идемпотентными?
- Иначе Sidekiq откажется ставить задачу в очередь
- Задача может выполниться повторно (ретрай, рестарт воркера), и повтор не должен, например, списать деньги дважды
- Идемпотентные задачи выполняются параллельно, остальные — строго по одной
- Это важно только для задач, запускаемых через
perform_now
Очереди гарантируют выполнение «хотя бы один раз», а не «ровно один раз»: задача может упасть посередине и перезапуститься или быть повторно выдана после сбоя воркера. Поэтому задачу пишут так, чтобы повтор был безопасным: проверяют статус перед действием, используют уникальные ключи операций и т.п.
Сколько раз по умолчанию Sidekiq повторит упавшую задачу, прежде чем переместить её в Dead set?
- 3 раза с паузой 5 секунд
- Ни разу: ретраи нужно включать вручную
- Бесконечно, пока задача не выполнится
- 25 раз с экспоненциально растущей паузой (около трёх недель)
По умолчанию Sidekiq делает до 25 повторов с экспоненциальной задержкой — суммарно около трёх недель, после чего задача попадает в Dead set. Число повторов настраивается опцией
sidekiq_options retry: 5 (или retry: false), так что включать ретраи вручную не нужно.ExternalApi.sync каждый раз выбрасывает Net::OpenTimeout. Что произойдёт после третьей неудачной попытки?class SyncJob < ApplicationJob
retry_on Net::OpenTimeout, wait: 5.seconds, attempts: 3
def perform(id)
ExternalApi.sync(id)
end
end- Задача будет молча удалена
- Исключение пробросится в бэкенд очереди (например, Sidekiq), дальше действует его логика
- ActiveJob продолжит повторять её каждые 5 секунд без ограничений
- Задача будет выполнена синхронно через
perform_now
Когда попытки
retry_on исчерпаны, ActiveJob пробрасывает исключение наружу — в адаптер очереди, у которого могут быть свои ретраи или очередь «мёртвых» задач. Чтобы поступить иначе (например, записать ошибку и не повторять), retry_on передают блок, который вызовется после последней попытки.Чем
ReportJob.perform_now(id) отличается от ReportJob.perform_later(id)?perform_nowвыполняет задачу сразу в текущем процессе,perform_laterставит её в очередь для воркераperform_nowставит задачу в начало очереди,perform_later— в конецperform_nowвыполняется в отдельном потоке,perform_later— в отдельном процессе- Ничем: оба метода ставят задачу в очередь
perform_now синхронно вызывает perform прямо здесь — запрос ждёт окончания работы, зато исключения видны сразу (удобно в тестах и консоли). perform_later сериализует аргументы и отдаёт задачу адаптеру очереди, а выполнит её воркер позже.WelcomeJob#perform делает User.find(user_id). Какая проблема возможна в Rails 7.1 с адаптером Sidekiq?User.transaction do
user = User.create!(email: email)
WelcomeJob.perform_later(user.id)
Profile.create!(user: user)
# ...ещё несколько запросов
end- Задача не попадёт в очередь, пока транзакция не завершится
- Sidekiq откатит транзакцию, если задача упадёт
- Проблемы нет: внутри транзакции
perform_laterвыполняется синхронно - Воркер может взять задачу до коммита и получить
ActiveRecord::RecordNotFound
perform_later сразу пишет задачу в Redis, а воркер работает через своё соединение с БД и не видит незакоммиченную запись. Если же транзакция откатится, задача выполнится для несуществующего пользователя. Задачу ставят в after_commit или после блока транзакции (в Rails 7.2 появилась опция enqueue_after_transaction_commit).Как работает этот код?
stats = Rails.cache.fetch("dashboard/stats", expires_in: 10.minutes) do
Stats.compute # тяжёлый расчёт
end- Всегда выполняет блок и обновляет кэш на 10 минут
- Возвращает значение из кэша, а при промахе выполняет блок, сохраняет результат на 10 минут и возвращает его
- Запускает блок раз в 10 минут по расписанию в фоне
- Только читает кэш; записывать нужно отдельно через
Rails.cache.write
fetch с блоком — основной приём низкоуровневого кэширования: при попадании блок не выполняется, при промахе (или истёкшем ключе) результат блока записывается в кэш и возвращается. Принудительно пересчитать можно опцией force: true.Что выведет этот код при
config.cache_store = :memory_store (ключа в кэше изначально нет)?calls = 0
2.times do
Rails.cache.fetch("missing_user") { calls += 1; nil }
end
p calls- 1
- 2
- 0
- Ошибка: в кэш нельзя записать
nil
По умолчанию
fetch кэширует и nil: после первого вызова в кэше лежит запись со значением nil, и второй вызов возвращает её, не выполняя блок. Чтобы nil не сохранялся (например, «пользователь пока не найден»), передают skip_nil: true. Со :null_store (по умолчанию в test) результат был бы 2.Почему после изменения товара этот фрагмент перерисуется без ручной очистки кэша?
<% cache @product do %>
<%= render @product %>
<% end %>- Rails удаляет все фрагменты из кэша в колбэке
after_saveлюбой модели - Фрагменты хранятся только до конца текущего запроса
- Ключ кэша включает id и
updated_atтовара, а также дайджест шаблона, — после обновления ключ другой cacheкаждый раз сравнивает HTML старого и нового фрагмента
Ключ фрагмента строится из
cache_key_with_version модели (имя, id, updated_at) и хэша шаблона. Обновили запись — изменился updated_at, ключ новый, и фрагмент рендерится заново; старая запись просто вытесняется из кэша со временем. Изменение самого шаблона тоже меняет ключ.Изменили цену одного товара, но страница категории показывает старую цену. Как правильно исправить (Russian doll caching)?
<% cache @category do %>
<% @category.products.each do |product| %>
<% cache product do %>
<%= render product %>
<% end %>
<% end %>
<% end %>- Убрать внутренний
cache product - Добавить
expires_in: 1.minuteво внутреннийcache - Вызывать
Rails.cache.clearпосле каждого сохранения товара - Объявить в
Productbelongs_to :category, touch: true, чтобы менялсяupdated_atкатегории
Внешний фрагмент закэширован по ключу категории; пока у категории не меняется
updated_at, Rails отдаёт старый HTML целиком и до внутренних фрагментов не доходит. touch: true обновляет updated_at категории при сохранении товара: внешний ключ меняется, а неизменённые внутренние фрагменты берутся из кэша.Приложение работает в нескольких процессах Puma на разных серверах с
config.cache_store = :memory_store. Что верно?- Кэш общий для всех процессов, так как хранится в оперативной памяти
- У каждого процесса свой кэш: запись или удаление ключа в одном процессе не видны другим
- Rails автоматически синхронизирует
:memory_storeчерез базу данных :memory_storeзапрещён в production и вызовет ошибку при старте
:memory_store хранит данные в памяти конкретного Ruby-процесса, поэтому Rails.cache.delete в одном процессе не сбросит ключ в остальных, и они будут отдавать устаревшие данные. Общий кэш дают :redis_cache_store, :mem_cache_store или :solid_cache_store.Безопасность в Rails15
Какой вызов уязвим для SQL-инъекции?
User.where(name: params[:name])User.where("name = '#{params[:name]}'")User.where("name = ?", params[:name])User.where("name = :n", n: params[:name])
Интерполяция вставляет ввод пользователя прямо в текст SQL: строка
' OR '1'='1 изменит смысл запроса. Хэш-условия, плейсхолдеры ? и именованные :n передают значение отдельно и экранируют его, поэтому они безопасны.params[:sort] приходит из URL. Как безопасно сортировать по колонке, выбранной пользователем?Post.order(params[:sort])- Обернуть значение в
sanitize_sql(params[:sort]) - Вызвать
params[:sort].html_safe - Сверить значение с белым списком (
%w[title created_at].include?(params[:sort])), иначе взять колонку по умолчанию - Удвоить кавычки:
params[:sort].gsub("'", "''")
Имя колонки и направление сортировки нельзя передать как bind-параметр, поэтому надёжная защита — белый список допустимых значений. Удвоение кавычек не помогает: для инъекции в
ORDER BY кавычки не нужны. html_safe относится к HTML-экранированию и с SQL никак не связан.Что верно про этот запрос поиска?
Product.where("name LIKE ?", "%#{params[:q]}%")- Это SQL-инъекция: интерполяция в аргументе так же опасна, как в строке запроса
- Rails сам экранирует
%и_внутри bind-параметра - Запрос упадёт: плейсхолдер
?нельзя использовать сLIKE - Инъекции нет, но
%и_из ввода сработают как шаблоны LIKE; их экранируют черезsanitize_sql_like
Интерполяция здесь строит значение параметра, а не текст SQL, — оно экранируется как строка, так что инъекции нет. Но символы
% и _ в значении остаются спецсимволами LIKE: запрос q=% найдёт всё. Правильно: "%#{Product.sanitize_sql_like(params[:q])}%".Пользователь сохранил в
bio строку <script>alert(1)</script>. Какой вариант в ERB-шаблоне выполнит этот скрипт в браузере?<%= @user.bio %><%= raw @user.bio %><%= h @user.bio %><%= sanitize @user.bio %>
<%= %> в Rails экранирует вывод по умолчанию, h делает то же явно, а sanitize оставляет только безопасные теги и вырезает <script>. raw (как и .html_safe) отключает экранирование — так появляется XSS.Что не так с этим хелпером?
def badge(name)
"<b>#{name}</b>".html_safe
endhtml_safeне экранируетname, а лишь помечает всю строку безопасной — это XSS; лучшеcontent_tag(:b, name)- Ничего:
html_safeэкранирует интерполированные значения html_safeвыбросит ошибку на строке, содержащей теги- ERB всё равно экранирует результат, и тег
<b>выведется как текст
html_safe ничего не преобразует — он возвращает ActiveSupport::SafeBuffer с пометкой «доверенный HTML», и ERB перестаёт его экранировать. Если в name окажется <script>, он попадёт на страницу. content_tag(:b, name) или safe_join экранируют содержимое и при этом оставляют сам тег.Пользователь указал
website = "javascript:alert(document.cookie)". Что верно про этот код в шаблоне?<%= link_to "Сайт автора", @user.website %>- Rails экранирует значение атрибута, поэтому XSS невозможна
link_toсам отбрасывает ссылки со схемойjavascript:- При клике выполнится JS: экранирование HTML тут не помогает, нужно разрешать только схемы http/https
- Скрипт выполнится сразу при загрузке страницы, без клика
Экранирование защищает от выхода за пределы атрибута, но строка
javascript:... и так валидна внутри href, и браузер выполнит её при клике. Пользовательские URL проверяют при сохранении (например, URI.parse(url).scheme должна быть http или https).Для чего в формах Rails скрытое поле
authenticity_token?- Для аутентификации пользователя вместо пароля
- Для защиты полей формы от SQL-инъекций
- Чтобы браузер не кэшировал форму
- Для защиты от CSRF: Rails проверяет, что не-GET запрос отправлен со страницы самого приложения
Токен связан с сессией и вставляется в формы (и в
csrf_meta_tags для JS). Сторонний сайт может заставить браузер отправить POST с cookie пользователя, но не знает токена, поэтому protect_from_forgery такой запрос отклонит.Почему GET-экшены не должны изменять данные (например, маршрут
GET /posts/1/delete)?- Проверка CSRF-токена не применяется к GET, и такой URL можно вызвать чужими руками, например через
<img src>на другом сайте - GET-запросы не доходят до контроллера, если включён кэш
- Rails запрещает вызывать
saveв GET-экшенах - GET-запросы не передают cookies сессии
Rails проверяет
authenticity_token только для POST/PATCH/PUT/DELETE, считая GET безопасным. Браузер жертвы отправит GET вместе с cookie, если вставить URL в картинку или ссылку, — и запись удалится. Кроме того, GET-ссылки обходят поисковые роботы и префетчеры.Какой файл Rails-проекта нельзя коммитить в git?
config/credentials.yml.encconfig/routes.rbconfig/master.keyGemfile.lock
credentials.yml.enc зашифрован, его коммитят. Ключ для расшифровки — config/master.key (Rails сам добавляет его в .gitignore); на сервер его передают отдельно или через переменную RAILS_MASTER_KEY. Значения читают так: Rails.application.credentials.dig(:aws, :secret_key).Чем опасен этот код в контроллере?
def user_params
params.require(:user).permit!
endpermit!выбрасывает исключение на любом лишнем ключеpermit!разрешает все ключи, и пользователь может передать, например,user[admin]=1- Ничем:
permit!разрешает только атрибуты, которые есть в модели permit!отключает защиту от CSRF для этого экшена
permit! помечает весь хэш (включая вложенные) как разрешённый, возвращая уязвимость mass assignment: любое поле модели, например admin или role, можно изменить через форму. Атрибуты надо перечислять явно в permit(:name, :email).Счета принадлежат пользователям. Как исправить доступ к чужим счетам в этом экшене?
def show
@invoice = Invoice.find(params[:id])
endInvoice.find(params[:id].to_i)Invoice.find_by(id: params[:id])Invoice.find(Invoice.sanitize_sql(params[:id]))current_user.invoices.find(params[:id])
Это IDOR (небезопасная прямая ссылка на объект): подставив чужой id, можно открыть любой счёт. Поиск через ассоциацию текущего пользователя добавляет
WHERE user_id = ..., и для чужого id будет RecordNotFound (404). Приведение типа и экранирование тут ни при чём — проблема в авторизации, а не в инъекции.Как не допустить попадания паролей и токенов из параметров запроса в логи Rails?
config.filter_parameters += [:password, :token]— значения заменятся на[FILTERED]config.log_level = :errorparams.require(:user).permit(:password)protect_from_forgery with: :exception
filter_parameters маскирует значения подходящих параметров в логах (совпадение по части имени, так что :password закроет и password_confirmation). Понижение уровня логов просто скрывает всё подряд, а permit и CSRF-защита на логи не влияют.Что опасного в этом экшене?
def create
klass = params[:type].constantize
@report = klass.new(report_params)
end- Ничего:
constantizeнаходит только модели ActiveRecord constantizeвыполняет строку как Ruby-код черезeval- Пользователь может создать объект любого загруженного класса; нужен белый список вроде
{ "pdf" => PdfReport }.fetch(params[:type]) - Уязвимость только одна — SQL-инъекция в
report_params
constantize ищет константу по имени (через Object.const_get, без eval), но годится любая: File, Logger, внутренние классы приложения. Вызов new с контролируемыми аргументами у произвольного класса — путь к неожиданным побочным эффектам вплоть до выполнения кода. Ввод пользователя сопоставляют с явным списком допустимых классов.Что выведет этот код (в
users есть колонка password_digest, подключён гем bcrypt)?class User < ApplicationRecord
has_secure_password
end
user = User.create!(email: "a@b.c", password: "secret123")
p user.authenticate("wrong")
p user.authenticate("secret123") == usernil, затемtruefalse, затемfalse- Исключение
BCrypt::Errors::InvalidHash false, затемtrue
has_secure_password хранит только bcrypt-хэш в password_digest. authenticate возвращает сам объект при верном пароле и false при неверном (не nil), поэтому удобно писать user&.authenticate(pass) в условии.Почему API-токен сравнивают через
ActiveSupport::SecurityUtils.secure_compare(a, b), а не через a == b?==для строк в Ruby не учитывает регистр- Время сравнения не зависит от позиции первого несовпадения, что защищает от timing-атак
secure_compareдополнительно расшифровывает токен==может изменить одну из сравниваемых строк
Обычное сравнение строк прекращается на первом отличающемся байте, и по времени ответа атакующий может подбирать токен посимвольно.
secure_compare сравнивает за постоянное время. == в Ruby регистрозависим и строк не меняет.RSpec и тестирование17
Что выведет этот пример (каждое
puts — с новой строки)?RSpec.describe "lazy" do
let(:list) { puts "build"; [] }
it "works" do
puts "start"
list << 1
list << 2
puts list.size
end
end- build, start, 2
- start, build, build, build, 0
- start, build, 2
- start, build, 1
let ленивый: блок выполняется при первом обращении (после start) и запоминается до конца примера, поэтому все три обращения работают с одним массивом. Вариант с тремя build был бы верен для обычного метода без мемоизации.Пройдут ли примеры при запуске в порядке объявления?
counter = 0
RSpec.describe "memo" do
let(:n) { counter += 1 }
it("a") { expect(n + n).to eq(2) }
it("b") { expect(n).to eq(2) }
end- Оба пройдут
- a упадёт:
n + nдаст 3 - b упадёт: в новом примере
nснова будет 1 - Оба упадут: внешняя переменная
counterнедоступна внутриlet
В примере a блок
let выполняется один раз (n = 1, мемоизировано), и n + n = 2. Мемоизация сбрасывается между примерами, поэтому в b блок выполняется снова, но counter — внешняя переменная, замкнутая блоком, и уже равна 1, так что n = 2. Это заодно показывает, почему общее изменяемое состояние вне let делает тесты зависимыми от порядка.Что здесь является
subject и пройдёт ли пример?RSpec.describe Array do
it { is_expected.to be_empty }
end- subject — сам класс
Array; пример упадёт - Неявный subject —
Array.new, то есть[]; пример пройдёт - subject не определён — будет
NoMethodError - subject —
nil; пример упадёт
Если в
describe передан класс, неявный subject — это described_class.new. is_expected — краткая форма expect(subject), а be_empty вызывает empty?. Для класса с обязательными аргументами конструктора subject задают явно: subject(:order) { Order.new(user) }.Что будет при запуске этих примеров в порядке объявления?
RSpec.describe "shared state" do
before(:all) { @list = [] }
it("a") { @list << 1; expect(@list.size).to eq(1) }
it("b") { @list << 2; expect(@list.size).to eq(1) }
end- Оба пройдут: перед каждым примером создаётся новый массив
- Оба упадут: переменные из
before(:all)недоступны в примерах - a упадёт, b пройдёт
- a пройдёт, b упадёт:
@list— один и тот же массив для всех примеров
before(:all) выполняется один раз на группу, а его переменные экземпляра копируются в каждый пример по ссылке — на тот же объект. Изменения из примера a видны в b, и размер там уже 2. Изменяемое состояние создают в before(:each) или let.Что произойдёт при выполнении этого кода в примере RSpec?
user = double("User", name: "Ann")
puts user.name
user.email- Выведет
Ann, затем ошибка: double получил неожиданное сообщение:email - Выведет
Ann, затемuser.emailвернётnil - Ошибка уже на
user.name: у double нет методов - Выведет
Ann, аuser.emailвернёт сам double
Обычный double отвечает только на явно застабленные сообщения (
name: "Ann" — это стаб), на любое другое он выбрасывает RSpec::Mocks::MockExpectationError. Возвращать себя на любое сообщение будет только double(...).as_null_object.Каким будет результат этого примера?
it "notifies" do
mailer = double("Mailer")
expect(mailer).to receive(:deliver)
end- Пример пройдёт: в нём нет проверок значения
- Пример упадёт: ожидался 1 вызов
deliver, а получено 0 - Пример пройдёт:
deliverне вызывался с неверными аргументами - Ошибка: у double нельзя ожидать сообщение без предварительного
allow
expect(...).to receive — это mock: ожидание проверяется в конце примера, и если метод не вызвали нужное число раз (по умолчанию ровно один), пример падает. Так проверяют, что код действительно отправил сообщение.Чем
allow(api).to receive(:fetch) отличается от expect(api).to receive(:fetch)?allowработает только с double,expect— только с реальными объектамиallowвызывает настоящий метод, аexpect— нетallowтолько подменяет метод (стаб), аexpectещё и требует, чтобы метод вызвали, иначе пример упадёт- Ничем, это синонимы
Стаб (
allow) задаёт поведение и не важен для результата теста, если его не вызвали. Мок (expect ... to receive) — это проверка взаимодействия. Оба работают и с double, и с реальными объектами (partial double), и оба по умолчанию не вызывают настоящий метод — для этого есть and_call_original.Что произойдёт при выполнении этой строки (класс
User загружен, метода nmae у него нет)?user = instance_double(User, nmae: "Ann")- Ничего:
instance_doubleведёт себя как обычныйdouble - Ошибка появится только при вызове
user.nmae - Вернётся настоящий объект
User - Ошибка сразу:
instance_doubleпроверяет, чтоUserреализует методnmae
Проверяемые дублёры (
instance_double, class_double) сверяются с реальным классом: стабить можно только существующие методы, с совместимым числом аргументов. Это ловит опечатки и тесты, которые продолжают проходить после переименования метода в коде.Что выведет этот код в примере RSpec?
dice = double("Dice")
allow(dice).to receive(:roll).and_return(1, 2)
p [dice.roll, dice.roll, dice.roll]- [1, 2, nil]
- [1, 2, 1]
- [1, 2, 2]
- [[1, 2], [1, 2], [1, 2]]
and_return с несколькими значениями отдаёт их по очереди, а когда они заканчиваются, повторяет последнее. Циклического возврата к первому значению и nil не будет.Почему здесь используется
spy, а не double("Logger")?logger = spy("Logger")
OrderService.new(logger: logger).call # внутри: logger.info("done")
expect(logger).to have_received(:info).with("done")- Обычный double упал бы на неожиданном
info; spy принимает любые сообщения и запоминает их дляhave_received have_receivedработает только с реальными объектами, а spy — реальныйLogger- spy автоматически вызывает настоящий метод
Logger#info - Разницы нет:
spy— просто короткое имя дляdouble
Стиль «arrange — act — assert» проверяет вызов после действия через
have_received. Для этого объект должен заранее разрешать сообщение: либо это spy (double как null object), либо метод застаблен через allow. Обычный double без стаба выбросил бы ошибку ещё внутри call.Чем
build(:user) отличается от create(:user) в FactoryBot?buildсохраняет без валидаций,create— с валидациямиbuildвозвращает хэш атрибутов,create— объектbuildпишет в тестовую БД,create— в основнуюbuildсоздаёт объект в памяти без сохранения,createещё и сохраняет его в БД
build вызывает только new с атрибутами, create — ещё и save!. Там, где БД не нужна, build делает тесты быстрее. Хэш атрибутов возвращает отдельная стратегия — attributes_for.Сколько записей сохранится в БД при
FactoryBot.build(:post) (FactoryBot 6, настройки по умолчанию)?FactoryBot.define do
factory :author do
name { "Ann" }
end
factory :post do
title { "Hi" }
author
end
end- 1: сохранится автор, а пост останется в памяти
- 0: ассоциация
authorтоже будет построена черезbuild - 2: сохранятся и пост, и автор
- 1: сохранится пост без автора
Начиная с FactoryBot 5 опция
use_parent_strategy по умолчанию включена: ассоциации строятся той же стратегией, что и родитель, поэтому build(:post) строит и автора без сохранения. В старых версиях build сохранял ассоциации через create, что замедляло тесты.Какая стратегия FactoryBot вернёт объект с заполненным
id и persisted? равным true, не обращаясь к БД?build_stubbedbuildcreateattributes_for
build_stubbed присваивает фиктивный id и подменяет методы сохранения так, что объект выглядит сохранённым, а попытка реально записать его в БД выбрасывает ошибку. build даёт persisted? == false и id == nil, create реально пишет в БД.Чем request spec отличается от system spec в Rails?
- Request spec тестирует только модели, system spec — контроллеры
- System spec не обращается к базе данных
- Request spec шлёт HTTP-запрос в приложение без браузера, а system spec через Capybara управляет браузером и может исполнять JS
- Request spec можно запускать только в CI
Request spec (
get "/posts", post "/posts", params: ...) проходит через весь стек Rails — маршруты, контроллер, рендер — и проверяет ответ; он быстрый, но JS не исполняет. System spec имитирует пользователя (visit, click_on, fill_in) и с драйвером вроде headless Chrome проверяет поведение страницы целиком.Почему этот тест не проходит?
it "creates a user" do
expect(User.create!(email: "a@b.c")).to change(User, :count).by(1)
end- Матчер
changeне умеет работать сUser.count create!нужно заменить наcreateby(1)нужно заменить наfrom(0).to(1)- Матчеру
changeнужен блокexpect { ... }; здесь запись создаётся ещё до начала измерения
change сравнивает значение до и после выполнения блока, поэтому код нужно передать блоком: expect { User.create!(...) }.to change(User, :count).by(1). С круглыми скобками create! выполняется сразу, а матчер получает объект вместо блока и не может ничего измерить.Что выведет этот файл спецификации (буквы по порядку)?
RSpec.describe "outer" do
before { puts "A" }
after { puts "E" }
context "inner" do
before { puts "B" }
after { puts "D" }
it("x") { puts "C" }
end
end- B A C D E
- A B C E D
- A B C D E
- B A C E D
Хуки
before выполняются от внешней группы к внутренней, а after — в обратном порядке: от внутренней к внешней. Так внутренняя группа может опираться на состояние, подготовленное внешней, а очистка идёт «изнутри наружу».Что произойдёт при выполнении этого кода в примере RSpec?
mailer = double("Mailer")
expect(mailer).to receive(:send_to).with("a@b.c")
mailer.send_to("x@y.z")- Пример пройдёт:
withлишь документирует ожидаемые аргументы - Пример упадёт:
send_toвызван с неожиданными аргументами - Пример пройдёт, потому что
send_toвсё-таки был вызван - Ошибка:
withможно использовать только сallow
with ограничивает ожидание конкретными аргументами: вызов с другими значениями не удовлетворяет ожиданию, и RSpec сообщает о неожиданных аргументах (expected: ("a@b.c"), got: ("x@y.z")). Если любые аргументы допустимы, with не пишут или используют anything.Паттерны и SOLID18
Какую задачу в Rails обычно решает service object (например,
Orders::Create.new(user, params).call)?- Заменяет модель ActiveRecord для работы с БД
- Выносит бизнес-операцию из контроллера и модели в отдельный класс с одной ответственностью
- Кэширует ответы контроллера
- Регистрирует маршруты для бизнес-операций
Сервис инкапсулирует один сценарий (создать заказ, списать оплату, отправить уведомления), который иначе раздувает контроллер или модель. Такой класс легко тестировать отдельно и переиспользовать из контроллера, задачи или консоли. С БД он работает через обычные модели, не заменяя их.
Когда уместен form object — класс с
include ActiveModel::Model?- Когда модель нужно сохранить без валидаций
- Когда форма отправляется через JavaScript
- Когда одна форма создаёт или меняет несколько моделей (например, пользователя и компанию) с общими валидациями
- Когда у модели больше десяти атрибутов
Form object принимает параметры формы, валидирует их как единое целое (
validates, errors, работа с form_with) и сохраняет нужные модели, обычно в транзакции. Так валидации конкретного сценария не засоряют модели и не требуют accepts_nested_attributes_for.Что выведет этот код?
require "delegate"
User = Struct.new(:first, :last)
class UserPresenter < SimpleDelegator
def full_name
"#{first} #{last}"
end
end
pr = UserPresenter.new(User.new("Ann", "Lee"))
p pr.full_name
p pr.firstNameError:firstне определён вUserPresenter"Ann Lee", затемNoMethodError"Ann Lee", затем"Ann"" ", затемnil
SimpleDelegator пересылает все неизвестные ему методы обёрнутому объекту, поэтому и first/last внутри full_name, и внешний pr.first уходят в User. Это типичная реализация декоратора/презентера: добавляем методы отображения, не трогая модель.Как называется приём, показанный в этом коде?
class Guest
def name = "Гость"
def admin? = false
end
user = current_user || Guest.new
puts "Привет, #{user.name}"- Singleton
- Фабричный метод
- Декоратор
- Null Object
Null Object заменяет
nil объектом с тем же интерфейсом и нейтральным поведением, и код больше не проверяет if user / user&.name в каждом месте. Декоратор оборачивает существующий объект, а здесь вместо отсутствующего пользователя подставляется заглушка.Какой принцип Ruby демонстрирует метод
export?require "stringio"
def export(target, data)
target.write(data)
end
export(File.open("out.txt", "w"), "x")
export(StringIO.new, "x")
export($stdout, "x")- Утиную типизацию: важен не класс объекта, а то, что он отвечает на
write - Множественное наследование
- Перегрузку метода по типу аргумента
- Проверку типа аргумента при компиляции
File, StringIO и $stdout не связаны общим предком-интерфейсом, но все понимают сообщение write, и этого достаточно. Перегрузки по типам в Ruby нет, а типы проверяются во время выполнения — при отправке сообщения.Какой принцип SOLID в первую очередь нарушает этот класс?
class Report
def build(data); end # считает показатели
def to_pdf; end # верстает PDF
def deliver(to); end # отправляет письмо
def save; end # пишет в БД
end- Принцип подстановки Лисков (LSP)
- Принцип единственной ответственности (SRP)
- Принцип разделения интерфейсов (ISP)
- Принцип инверсии зависимостей (DIP)
У класса четыре причины для изменения: логика расчёта, вёрстка, доставка и хранение. SRP предлагает разделить их (
ReportBuilder, PdfRenderer, ReportMailer...), чтобы правка формата PDF не задевала расчёты. LSP касается наследования, которого здесь нет.Какой принцип нарушает этот код и как его обычно исправляют?
def area(shape)
case shape.kind
when :circle then 3.14 * shape.r**2
when :square then shape.side**2
end
end- SRP: метод
areaнадо разбить на два метода - LSP: круг нельзя подставлять вместо квадрата
- OCP: для новой фигуры придётся править
area; лучше дать каждой фигуре свой методarea - Нарушения нет:
caseпо типу — идиоматичный Ruby
Принцип открытости/закрытости: код должен расширяться без изменения существующего. Здесь каждая новая фигура требует новой ветки
when (и так в каждом подобном case). Полиморфизм — Circle#area, Square#area и вызов shape.area — позволяет добавлять фигуры, не трогая вызывающий код.Что выведет код и какой принцип нарушен?
class Rectangle
attr_accessor :width, :height
def area = width * height
end
class Square < Rectangle
def width=(v); @width = @height = v; end
def height=(v); @width = @height = v; end
end
r = Square.new
r.width = 5
r.height = 2
p r.area4— нарушен LSP: квадрат нельзя подставить туда, где ждут прямоугольник10— нарушений нет25— нарушен OCP4— нарушен SRP
Присваивание
height = 2 в Square меняет и ширину, поэтому площадь 2 × 2 = 4, хотя код, рассчитанный на Rectangle, ожидает 10. Подкласс ломает ожидания базового типа — это классический пример нарушения принципа подстановки Лисков.Какой вариант лучше соответствует принципу инверсии зависимостей (DIP) для сервиса, который отправляет уведомления?
- Сервис создаёт
EmailNotifier.newпрямо внутри методаcall - Сервис наследуется от
EmailNotifier - Сервис берёт уведомитель из глобальной переменной
$notifier - Сервис получает уведомитель через конструктор (
notifier:) и вызываетnotify, не зная конкретного класса
DIP: высокоуровневый код зависит от абстракции (в Ruby — от «протокола» с методом
notify), а конкретную реализацию передают снаружи. Тогда можно подставить SmsNotifier или тестовый double. Жёсткое EmailNotifier.new внутри и глобальная переменная — скрытые зависимости, наследование — лишняя связанность.Как принцип разделения интерфейсов (ISP) обычно проявляется в Ruby?
- Через обязательные интерфейсы, объявленные ключевым словом
interface - Небольшие модули-роли и узкие «утиные» протоколы вместо одного большого модуля, требующего реализовать всё подряд
- Через запрет подключать (
include) больше одного модуля в класс - Каждый метод выносится в отдельный класс
Ключевого слова
interface в Ruby нет. ISP проявляется в том, что клиент зависит только от нужных ему методов: например, Enumerable требует лишь each, а Comparable — лишь <=>. Плохой признак — модуль с десятком методов, которые классы заглушают через raise NotImplementedError.Классу
Order нужно логирование. Какой вариант соответствует принципу «композиция вместо наследования»?class Order < Logger- Скопировать нужные методы
LoggerвOrder - Передать объект-логгер в
Orderи вызывать@logger.info(...) - Унаследовать
LoggerотOrder
Заказ не «является» логгером, он «использует» логгер, поэтому связь — композиция: объект хранится в поле и получает сообщения. Так логгер легко заменить, а
Order не получает десятки чужих методов и остаётся свободен для своей иерархии.Что выведет код и какой паттерн здесь реализован?
FORMATTERS = {
json: ->(h) { h.to_json },
csv: ->(h) { h.values.join(",") }
}
def export(data, format:)
FORMATTERS.fetch(format).call(data)
end
p export({ a: 1, b: 2 }, format: :csv)"1,2"— Наблюдатель"a,b"— СтратегияKeyError— Фабрика"1,2"— Стратегия
Алгоритм форматирования выбирается во время выполнения из набора взаимозаменяемых объектов с одинаковым интерфейсом (
call) — это Стратегия; в Ruby её часто делают на лямбдах. values даёт [1, 2], join(",") — "1,2". Ключ :csv есть, поэтому fetch не выбрасывает KeyError.Что выведет этот код (шаблонный метод с «абстрактным»
body)?class Report
def render = "#{header}|#{body}"
def header = "H"
def body = raise(NotImplementedError)
end
class Sales < Report
def body = "sales"
end
puts Sales.new.render
begin
Report.new.render
rescue => e
puts "ошибка: #{e.class}"
endH|sales, затемошибка: NotImplementedErrorH|sales, затем программа упадёт:NotImplementedErrorне наследуетStandardError, иrescue => eего не ловитH|sales, затемH|- Ошибка уже на первом
puts
Подкласс переопределяет шаг
body, и Sales.new.render даёт H|sales. Но NotImplementedError наследуется от ScriptError, а не от StandardError, а голый rescue ловит только StandardError. Поэтому для «абстрактных» методов часто заводят свой класс ошибки на базе StandardError или пишут rescue NotImplementedError явно.Что выведет этот код (value object на
Data, Ruby 3.3)?Money = Data.define(:amount, :currency)
a = Money.new(amount: 100, currency: "USD")
b = Money.new(100, "USD")
prices = { a => "сто долларов" }
p a == b
p prices[b]true, затем"сто долларов"false, затемniltrue, затемnilArgumentError:Dataпринимает только именованные аргументы
Data.define создаёт неизменяемый value object: конструктор принимает и позиционные, и именованные аргументы, а ==, eql? и hash основаны на значениях полей. Поэтому b равен a и находит его значение в хэше, хотя это другой объект.Что произойдёт при выполнении этого кода?
require "singleton"
class AppConfig
include Singleton
end
p AppConfig.instance.equal?(AppConfig.instance)
AppConfig.newtrue, затем создастся второй объектfalse, затемNoMethodErrorNoMethodErrorуже при вызовеinstancetrue, затемNoMethodError: методnewприватный
Модуль
Singleton делает new приватным и добавляет instance, который при каждом вызове возвращает один и тот же объект. Поэтому equal? даёт true, а прямой AppConfig.new — NoMethodError (private method new called).Какой метод появится у
Order и зачем?class Order < ApplicationRecord
belongs_to :customer
delegate :city, to: :customer, prefix: true
endorder.city— префикс влияет только на имя в логахorder.order_cityorder.customer_city— вместо цепочкиorder.customer.city(закон Деметры)Order.customer_city— метод класса, возвращающий города всех клиентов
delegate с prefix: true создаёт метод экземпляра с именем цели в начале: customer_city. Вызывающий код общается только с заказом и не лезет «через объект» к адресу клиента. Если customer может быть nil, добавляют allow_nil: true, иначе будет Module::DelegationError.Зачем конструктор этого query object принимает
relation со значением по умолчанию Order.all?class StaleOrdersQuery
def initialize(relation = Order.all)
@relation = relation
end
def call
@relation.where(status: "pending")
.where("created_at < ?", 3.days.ago)
end
end- Чтобы запрос выполнялся сразу в конструкторе
- Чтобы загрузить все заказы в память и фильтровать их в Ruby
- Это обязательная сигнатура для классов в папке
app/queries - Чтобы запрос можно было заранее сузить и продолжить цепочку:
StaleOrdersQuery.new(user.orders).call.limit(10)
Order.all — ленивый Relation, SQL не выполняется, пока результат не понадобится. Query object принимает любую выборку и возвращает тоже Relation, поэтому его можно комбинировать со скоупами, пагинацией и другими запросами и легко тестировать отдельно.Что верно после
include Archivable в модели Post?module Archivable
extend ActiveSupport::Concern
included do
scope :archived, -> { where.not(archived_at: nil) }
end
class_methods do
def archive_all = update_all(archived_at: Time.current)
end
def archive! = update!(archived_at: Time.current)
end- Все три метода станут методами экземпляра
Post Post.archivedиPost.archive_all— методы класса, аpost.archive!— метод экземпляра- Блок
includedвыполнится один раз при загрузке модуля, а не в контекстеPost archive_allстанет методом экземпляра, потому что объявлен черезdef
ActiveSupport::Concern выполняет блок included в контексте класса, который подключил модуль (поэтому scope срабатывает в Post), а методы из class_methods подмешивает через extend как методы класса. Обычные def модуля становятся методами экземпляра — как при любом include.How the quiz works
- Pick topics and a level — Junior covers the basics, Middle the everyday details, Senior the tricky corners of the language.
- Answer by tapping an option or with the keyboard: 1–4 or A–D, Enter for the next question.
- Read the explanation — after a mistake it opens right away, after a correct answer it is one tap away.
- Review your mistakes — "Retry mistakes" after the quiz, or the "Only my mistakes" mode later: your answers are remembered in this browser.
An unfinished quiz survives a page reload, so you can continue any time.
Quiz topics
- Типы и числа 10
- Строки 11
- Символы 5
- nil и истинность 5
- Операторы 5
- Условия и циклы 9
- Переменные и видимость 6
- Вывод и форматирование 5
- Основы синтаксиса 1
- Массивы 11
- Хеши 11
- Диапазоны 6
- Enumerable 12
- Блоки 5
- Proc и lambda 8
- Итераторы 3
- Классы и объекты 15
- self и контекст 4
- Наследование 5
- Модули и миксины 10
- Видимость методов 6
- Метапрограммирование 11
- Исключения 6
- Методы и аргументы 6
- Pattern matching 6
- Многопоточность 5
- Стандартная библиотека 9
- Gems и Bundler 3
- Тестирование 4
- Ruby on Rails 11
- Строки и регулярные выражения 19
- Объектная модель 17
- Память и производительность 14
- Новое в Ruby 3 18
- Идиомы Ruby 15
- Найдите ошибку 17
- ActiveRecord 23
- Rails: контроллеры и роутинг 15
- Rails: фоновые задачи и кэш 12
- Безопасность в Rails 15
- RSpec и тестирование 17
- Паттерны и SOLID 18
Other quizzes
SQL Quiz410 questionsJavaScript Quiz440 questionsjQuery Quiz110 questionsPHP Quiz410 questionsSymfony Quiz64 questionsLaravel Quiz30 questionsPython Quiz410 questionsGo Quiz410 questionsTypeScript Quiz210 questionsReact Quiz410 questionsJava Quiz115 questionsC# Quiz65 questionsHTML Quiz210 questionsCSS Quiz210 questionsOOP Quiz50 questionsGit Quiz50 questionsQA Quiz40 questionsZig Quiz115 questions
