Регулярные выражения Ruby — бесплатный тест онлайн

Вопрос 1 из 25

Какой вывод учитывает и возвращаемое значение, и побочный эффект в теме «Группы»? Не выбирайте ответ по одному точному фрагменту: вся формулировка должна выдерживать проверку.

# Проследите выполнение и выберите точный результат.
pattern = /\A\+(\d{1,3})-(\d+)\z/
match = pattern.match('+372-5551234')
p match&.captures

Шаблон захватывает код страны и локальную часть номера в две отдельные группы. Это объясняется тем, что якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Из строки извлекаются `year: 2026`, `month: 07`, `day: 16` через имена, а не номера. Это объясняется тем, что круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе. Шаблон захватывает код страны и локальную часть номера в две отдельные группы. Это объясняется тем, что круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе. Шаблон находит число 42 только потому, что после него стоит `kg`, но само `kg` в результат не входит. Это объясняется тем, что круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе. Шаблон захватывает код страны и локальную часть номера в две отдельные группы. Это объясняется тем, что lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину.

Вопрос 2 из 25

Проследите выполнение фрагмента. Какой результат верен для темы «Контекстные проверки lookaround»? Выберите связку, в которой верны и основной вывод, и его обоснование.

# Проследите выполнение и выберите точный результат.
text = 'mass=42kg, count=7'
match = text.match(/\d+(?=kg)/)
p [match[0], match.begin(0), match.end(0)]

Шаблон находит число 42 только потому, что после него стоит `kg`, но само `kg` в результат не входит. Причина такого результата: lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину. Шаблон находит число 42 только потому, что после него стоит `kg`, но само `kg` в результат не входит. Причина такого результата: круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе. Шаблон с `^...$` находит допустимую отдельную строку внутри текста, хотя весь ввод содержит дополнительную строку. Причина такого результата: lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину. Шаблон находит число 42 только потому, что после него стоит `kg`, но само `kg` в результат не входит. Причина такого результата: якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. После экранирования строка `a+b` совпадает только буквально, а не означает «одна или больше a перед b». Причина такого результата: lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину.

Вопрос 3 из 25

Что произойдёт после последней строки в примере по теме «Именованные захваты»? Выберите связку, в которой верны и основной вывод, и его обоснование.

# Проследите выполнение и выберите точный результат.
pattern = /\A(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})\z/
match = pattern.match('2026-07-16')
p match.named_captures

Из строки извлекаются `year: 2026`, `month: 07`, `day: 16` через имена, а не номера. Такой итог следует из правила: якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Шаблон находит число 42 только потому, что после него стоит `kg`, но само `kg` в результат не входит. Такой итог следует из правила: именованные захваты доступны по имени и делают код устойчивее к добавлению других групп перед ними. Из строки извлекаются `year: 2026`, `month: 07`, `day: 16` через имена, а не номера. Такой итог следует из правила: подстановка внешней строки внутрь Regexp требует `Regexp.escape`; иначе метасимволы меняют смысл шаблона. Из строки извлекаются `year: 2026`, `month: 07`, `day: 16` через имена, а не номера. Такой итог следует из правила: именованные захваты доступны по имени и делают код устойчивее к добавлению других групп перед ними. Шаблон захватывает код страны и локальную часть номера в две отдельные группы. Такой итог следует из правила: именованные захваты доступны по имени и делают код устойчивее к добавлению других групп перед ними.

Вопрос 4 из 25

Что покажет выполнение этого фрагмента из раздела «Безопасность шаблона»? Выберите связку, в которой верны и основной вывод, и его обоснование.

# Проследите выполнение и выберите точный результат.
needle = 'a+b'
pattern = /\A#{Regexp.escape(needle)}\z/
p [pattern.match?('a+b'), pattern.match?('aaab')]

Шаблон с `^...$` находит допустимую отдельную строку внутри текста, хотя весь ввод содержит дополнительную строку. Механизм результата таков: подстановка внешней строки внутрь Regexp требует `Regexp.escape`; иначе метасимволы меняют смысл шаблона. После экранирования строка `a+b` совпадает только буквально, а не означает «одна или больше a перед b». Механизм результата таков: якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. После экранирования строка `a+b` совпадает только буквально, а не означает «одна или больше a перед b». Механизм результата таков: именованные захваты доступны по имени и делают код устойчивее к добавлению других групп перед ними. После экранирования строка `a+b` совпадает только буквально, а не означает «одна или больше a перед b». Механизм результата таков: подстановка внешней строки внутрь Regexp требует `Regexp.escape`; иначе метасимволы меняют смысл шаблона. Шаблон находит число 42 только потому, что после него стоит `kg`, но само `kg` в результат не входит. Механизм результата таков: подстановка внешней строки внутрь Regexp требует `Regexp.escape`; иначе метасимволы меняют смысл шаблона.

Вопрос 5 из 25

Какой вывод учитывает и возвращаемое значение, и побочный эффект в теме «Проверка допущений»? Нужен вариант без логического разрыва между первой и второй частью.

# Проследите выполнение и выберите точный результат.
text = "SAFE
DROP"
p(/^SAFE$/.match?(text))
p(/\ASAFE\z/.match?(text))

Шаблон с `^...$` находит допустимую отдельную строку внутри текста, хотя весь ввод содержит дополнительную строку. Наблюдение согласуется с тем, что круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе. Шаблон с `^...$` находит допустимую отдельную строку внутри текста, хотя весь ввод содержит дополнительную строку. Наблюдение согласуется с тем, что якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Шаблон с `^...$` находит допустимую отдельную строку внутри текста, хотя весь ввод содержит дополнительную строку. Наблюдение согласуется с тем, что lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину. После экранирования строка `a+b` совпадает только буквально, а не означает «одна или больше a перед b». Наблюдение согласуется с тем, что якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Шаблон находит число 42 только потому, что после него стоит `kg`, но само `kg` в результат не входит. Наблюдение согласуется с тем, что якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста.

Вопрос 6 из 25

Базовый пример выглядит корректно. Что всё же нарушает контракт в блоке «Группы»? Проверьте обе половины ответа: частично верный вариант остаётся неверным.

# Обычный запуск проходит. Найдите скрытый риск.
pattern = /\A\+(\d{1,3})-(\d+)\z/
match = pattern.match('+372-5551234')
p match&.captures

Проверка только формы регулярным выражением не подтверждает календарную допустимость даты вроде 2026-02-31. Причина — круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе. Валидация токена через `^` и `$` может принять атакующий ввод с переводом строки и опасным хвостом. Причина — круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе. Лишние захваты меняют номера групп после правки шаблона и ломают код, который обращается к `$1` и `$2`. Причина — якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Лишние захваты меняют номера групп после правки шаблона и ломают код, который обращается к `$1` и `$2`. Причина — круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе. Лишние захваты меняют номера групп после правки шаблона и ломают код, который обращается к `$1` и `$2`. Причина — lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину.

Вопрос 7 из 25

Какой дефект может проявиться на границе показанного сценария «Контекстные проверки lookaround»? Одного совпавшего вывода недостаточно — проверьте также вторую часть ответа.

# Обычный запуск проходит. Найдите скрытый риск.
text = 'mass=42kg, count=7'
match = text.match(/\d+(?=kg)/)
p [match[0], match.begin(0), match.end(0)]

Проверка только формы регулярным выражением не подтверждает календарную допустимость даты вроде 2026-02-31. Этот риск связан с тем, что lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину. Лишние захваты меняют номера групп после правки шаблона и ломают код, который обращается к `$1` и `$2`. Этот риск связан с тем, что lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину. Сложные вложенные проверки контекста делают выражение непредсказуемым по времени и трудным для сопровождения. Этот риск связан с тем, что якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Сложные вложенные проверки контекста делают выражение непредсказуемым по времени и трудным для сопровождения. Этот риск связан с тем, что lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину. Сложные вложенные проверки контекста делают выражение непредсказуемым по времени и трудным для сопровождения. Этот риск связан с тем, что круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе.

Вопрос 8 из 25

Какое скрытое условие делает фрагмент «Именованные захваты» хрупким? Проверьте обе половины ответа: частично верный вариант остаётся неверным.

# Обычный запуск проходит. Найдите скрытый риск.
pattern = /\A(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})\z/
match = pattern.match('2026-07-16')
p match.named_captures

Проверка только формы регулярным выражением не подтверждает календарную допустимость даты вроде 2026-02-31. Уязвимое место возникает потому, что якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Лишние захваты меняют номера групп после правки шаблона и ломают код, который обращается к `$1` и `$2`. Уязвимое место возникает потому, что именованные захваты доступны по имени и делают код устойчивее к добавлению других групп перед ними. Проверка только формы регулярным выражением не подтверждает календарную допустимость даты вроде 2026-02-31. Уязвимое место возникает потому, что именованные захваты доступны по имени и делают код устойчивее к добавлению других групп перед ними. Сложные вложенные проверки контекста делают выражение непредсказуемым по времени и трудным для сопровождения. Уязвимое место возникает потому, что именованные захваты доступны по имени и делают код устойчивее к добавлению других групп перед ними. Проверка только формы регулярным выражением не подтверждает календарную допустимость даты вроде 2026-02-31. Уязвимое место возникает потому, что подстановка внешней строки внутрь Regexp требует `Regexp.escape`; иначе метасимволы меняют смысл шаблона.

Вопрос 9 из 25

Какой рабочий сбой вероятнее всего связан именно с механизмом «Безопасность шаблона»? Одного совпавшего вывода недостаточно — проверьте также вторую часть ответа.

# Обычный запуск проходит. Найдите скрытый риск.
needle = 'a+b'
pattern = /\A#{Regexp.escape(needle)}\z/
p [pattern.match?('a+b'), pattern.match?('aaab')]

Проверка только формы регулярным выражением не подтверждает календарную допустимость даты вроде 2026-02-31. К такому сбою приводит правило: подстановка внешней строки внутрь Regexp требует `Regexp.escape`; иначе метасимволы меняют смысл шаблона. Даже экранированный пользовательский фрагмент не спасает от катастрофического возврата, если окружающий шаблон сам содержит опасные вложенные квантификаторы. К такому сбою приводит правило: якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Даже экранированный пользовательский фрагмент не спасает от катастрофического возврата, если окружающий шаблон сам содержит опасные вложенные квантификаторы. К такому сбою приводит правило: подстановка внешней строки внутрь Regexp требует `Regexp.escape`; иначе метасимволы меняют смысл шаблона. Сложные вложенные проверки контекста делают выражение непредсказуемым по времени и трудным для сопровождения. К такому сбою приводит правило: подстановка внешней строки внутрь Regexp требует `Regexp.escape`; иначе метасимволы меняют смысл шаблона. Даже экранированный пользовательский фрагмент не спасает от катастрофического возврата, если окружающий шаблон сам содержит опасные вложенные квантификаторы. К такому сбою приводит правило: именованные захваты доступны по имени и делают код устойчивее к добавлению других групп перед ними.

Вопрос 10 из 25

Какой риск не исчезает после успешного запуска кода «Проверка допущений»? Ищите не знакомые слова, а технически непротиворечивую пару утверждений.

# Обычный запуск проходит. Найдите скрытый риск.
text = "SAFE
DROP"
p(/^SAFE$/.match?(text))
p(/\ASAFE\z/.match?(text))

Лишние захваты меняют номера групп после правки шаблона и ломают код, который обращается к `$1` и `$2`. Источник риска: якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Валидация токена через `^` и `$` может принять атакующий ввод с переводом строки и опасным хвостом. Источник риска: круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе. Проверка только формы регулярным выражением не подтверждает календарную допустимость даты вроде 2026-02-31. Источник риска: якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Валидация токена через `^` и `$` может принять атакующий ввод с переводом строки и опасным хвостом. Источник риска: якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Валидация токена через `^` и `$` может принять атакующий ввод с переводом строки и опасным хвостом. Источник риска: lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину.

Вопрос 11 из 25

Что является технической причиной наблюдаемого поведения «Группы»? Оценивайте ответ целиком: обе части утверждения должны быть точными.

Круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе. Поэтому из строки извлекаются `year: 2026`, `month: 07`, `day: 16` через имена, а не номера. Круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе. Поэтому шаблон находит число 42 только потому, что после него стоит `kg`, но само `kg` в результат не входит. Lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину. Поэтому шаблон захватывает код страны и локальную часть номера в две отдельные группы. Якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Поэтому шаблон захватывает код страны и локальную часть номера в две отдельные группы. Круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе. Поэтому шаблон захватывает код страны и локальную часть номера в две отдельные группы.

Вопрос 12 из 25

Какое общее правило связывает результат и риск в разделе «Контекстные проверки lookaround»? Смотрите на всю причинную связку, а не только на знакомую формулировку.

Круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе. Из этого следует, что шаблон находит число 42 только потому, что после него стоит `kg`, но само `kg` в результат не входит. Lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину. Из этого следует, что шаблон с `^...$` находит допустимую отдельную строку внутри текста, хотя весь ввод содержит дополнительную строку. Lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину. Из этого следует, что шаблон находит число 42 только потому, что после него стоит `kg`, но само `kg` в результат не входит. Якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Из этого следует, что шаблон находит число 42 только потому, что после него стоит `kg`, но само `kg` в результат не входит. Lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину. Из этого следует, что после экранирования строка `a+b` совпадает только буквально, а не означает «одна или больше a перед b».

Вопрос 13 из 25

Какой механизм отделяет верный разбор от похожего, но ошибочного объяснения «Именованные захваты»? Сопоставьте не только итог, но и правило, риск или проверку, которые с ним связаны.

Именованные захваты доступны по имени и делают код устойчивее к добавлению других групп перед ними. Наблюдаемое следствие: из строки извлекаются `year: 2026`, `month: 07`, `day: 16` через имена, а не номера. Именованные захваты доступны по имени и делают код устойчивее к добавлению других групп перед ними. Наблюдаемое следствие: шаблон находит число 42 только потому, что после него стоит `kg`, но само `kg` в результат не входит. Именованные захваты доступны по имени и делают код устойчивее к добавлению других групп перед ними. Наблюдаемое следствие: шаблон захватывает код страны и локальную часть номера в две отдельные группы. Подстановка внешней строки внутрь Regexp требует `Regexp.escape`; иначе метасимволы меняют смысл шаблона. Наблюдаемое следствие: из строки извлекаются `year: 2026`, `month: 07`, `day: 16` через имена, а не номера. Якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Наблюдаемое следствие: из строки извлекаются `year: 2026`, `month: 07`, `day: 16` через имена, а не номера.

Вопрос 14 из 25

Какое правило Ruby или Rails объясняет поведение в теме «Безопасность шаблона»? Оценивайте ответ целиком: обе части утверждения должны быть точными.

Подстановка внешней строки внутрь Regexp требует `Regexp.escape`; иначе метасимволы меняют смысл шаблона. Именно поэтому после экранирования строка `a+b` совпадает только буквально, а не означает «одна или больше a перед b». Подстановка внешней строки внутрь Regexp требует `Regexp.escape`; иначе метасимволы меняют смысл шаблона. Именно поэтому шаблон находит число 42 только потому, что после него стоит `kg`, но само `kg` в результат не входит. Якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Именно поэтому после экранирования строка `a+b` совпадает только буквально, а не означает «одна или больше a перед b». Подстановка внешней строки внутрь Regexp требует `Regexp.escape`; иначе метасимволы меняют смысл шаблона. Именно поэтому шаблон с `^...$` находит допустимую отдельную строку внутри текста, хотя весь ввод содержит дополнительную строку. Именованные захваты доступны по имени и делают код устойчивее к добавлению других групп перед ними. Именно поэтому после экранирования строка `a+b` совпадает только буквально, а не означает «одна или больше a перед b».

Вопрос 15 из 25

Какое правило остаётся верным, даже если вход и порядок вызовов изменятся, в теме «Проверка допущений»? Оценивайте ответ целиком: обе части утверждения должны быть точными.

Круглые скобки создают захватывающую группу, `(?:...)` — незахватывающую; повторитель относится к ближайшему атому или группе. Это правило даёт такой результат: шаблон с `^...$` находит допустимую отдельную строку внутри текста, хотя весь ввод содержит дополнительную строку. Якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Это правило даёт такой результат: шаблон с `^...$` находит допустимую отдельную строку внутри текста, хотя весь ввод содержит дополнительную строку. Lookahead и lookbehind проверяют контекст без включения его в совпадение; поддерживаемая форма lookbehind должна иметь допустимую длину. Это правило даёт такой результат: шаблон с `^...$` находит допустимую отдельную строку внутри текста, хотя весь ввод содержит дополнительную строку. Якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Это правило даёт такой результат: после экранирования строка `a+b` совпадает только буквально, а не означает «одна или больше a перед b». Якоря `\A` и `\z` относятся ко всей строке, а `^` и `$` в Ruby могут совпадать у границ строк внутри многострочного текста. Это правило даёт такой результат: шаблон находит число 42 только потому, что после него стоит `kg`, но само `kg` в результат не входит.

Вопрос 16 из 25

Какой вариант правки выдержит граничный сценарий темы «Группы»? Сопоставьте не только итог, но и правило, риск или проверку, которые с ним связаны.

# Выберите изменение, которое исправляет причину.
pattern = /\A\+(\d{1,3})-(\d+)\z/
match = pattern.match('+372-5551234')
p match&.captures

После структурного разбора передавать поля календарной или доменной библиотеке для семантической проверки. Так закрывается риск: лишние захваты меняют номера групп после правки шаблона и ломают код, который обращается к `$1` и `$2`. Использовать именованные группы для значимых полей и незахватывающие — только для структуры. Так закрывается риск: валидация токена через `^` и `$` может принять атакующий ввод с переводом строки и опасным хвостом. Оставлять lookaround коротким; сложную грамматику разделять на предварительный разбор и простые проверки. Так закрывается риск: лишние захваты меняют номера групп после правки шаблона и ломают код, который обращается к `$1` и `$2`. Использовать именованные группы для значимых полей и незахватывающие — только для структуры. Так закрывается риск: лишние захваты меняют номера групп после правки шаблона и ломают код, который обращается к `$1` и `$2`. Использовать именованные группы для значимых полей и незахватывающие — только для структуры. Так закрывается риск: проверка только формы регулярным выражением не подтверждает календарную допустимость даты вроде 2026-02-31.

Вопрос 17 из 25

Какое изменение устраняет причину проблемы в теме «Контекстные проверки lookaround», а не маскирует симптом? В правильном ответе вторая часть действительно объясняет или проверяет первую.

# Выберите изменение, которое исправляет причину.
text = 'mass=42kg, count=7'
match = text.match(/\d+(?=kg)/)
p [match[0], match.begin(0), match.end(0)]

Оставлять lookaround коротким; сложную грамматику разделять на предварительный разбор и простые проверки. Это изменение устраняет проблему: проверка только формы регулярным выражением не подтверждает календарную допустимость даты вроде 2026-02-31. Для проверки полного значения использовать `\A` и `\z`, а многострочный поиск выделять в отдельную операцию. Это изменение устраняет проблему: сложные вложенные проверки контекста делают выражение непредсказуемым по времени и трудным для сопровождения. После структурного разбора передавать поля календарной или доменной библиотеке для семантической проверки. Это изменение устраняет проблему: сложные вложенные проверки контекста делают выражение непредсказуемым по времени и трудным для сопровождения. Оставлять lookaround коротким; сложную грамматику разделять на предварительный разбор и простые проверки. Это изменение устраняет проблему: сложные вложенные проверки контекста делают выражение непредсказуемым по времени и трудным для сопровождения. Оставлять lookaround коротким; сложную грамматику разделять на предварительный разбор и простые проверки. Это изменение устраняет проблему: лишние захваты меняют номера групп после правки шаблона и ломают код, который обращается к `$1` и `$2`.

Вопрос 18 из 25

Какой вариант решения «Именованные захваты» останется понятным при сопровождении? Верный вариант не содержит частично правильной подмены причины или следствия.

# Выберите изменение, которое исправляет причину.
pattern = /\A(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})\z/
match = pattern.match('2026-07-16')
p match.named_captures

После структурного разбора передавать поля календарной или доменной библиотеке для семантической проверки. Такая правка нужна из-за риска: лишние захваты меняют номера групп после правки шаблона и ломают код, который обращается к `$1` и `$2`. Оставлять lookaround коротким; сложную грамматику разделять на предварительный разбор и простые проверки. Такая правка нужна из-за риска: проверка только формы регулярным выражением не подтверждает календарную допустимость даты вроде 2026-02-31. После структурного разбора передавать поля календарной или доменной библиотеке для семантической проверки. Такая правка нужна из-за риска: сложные вложенные проверки контекста делают выражение непредсказуемым по времени и трудным для сопровождения. После структурного разбора передавать поля календарной или доменной библиотеке для семантической проверки. Такая правка нужна из-за риска: проверка только формы регулярным выражением не подтверждает календарную допустимость даты вроде 2026-02-31. Для проверки полного значения использовать `\A` и `\z`, а многострочный поиск выделять в отдельную операцию. Такая правка нужна из-за риска: проверка только формы регулярным выражением не подтверждает календарную допустимость даты вроде 2026-02-31.

Вопрос 19 из 25

Какое изменение устраняет причину проблемы в теме «Безопасность шаблона», а не маскирует симптом? Не выбирайте ответ по одному точному фрагменту: вся формулировка должна выдерживать проверку.

# Выберите изменение, которое исправляет причину.
needle = 'a+b'
pattern = /\A#{Regexp.escape(needle)}\z/
p [pattern.match?('a+b'), pattern.match?('aaab')]

После структурного разбора передавать поля календарной или доменной библиотеке для семантической проверки. Решение адресует следующий дефект: даже экранированный пользовательский фрагмент не спасает от катастрофического возврата, если окружающий шаблон сам содержит опасные вложенные квантификаторы. Экранировать данные, ограничивать длину входа и избегать неоднозначных вложенных повторов; критичные шаблоны измерять на худших строках. Решение адресует следующий дефект: проверка только формы регулярным выражением не подтверждает календарную допустимость даты вроде 2026-02-31. Экранировать данные, ограничивать длину входа и избегать неоднозначных вложенных повторов; критичные шаблоны измерять на худших строках. Решение адресует следующий дефект: сложные вложенные проверки контекста делают выражение непредсказуемым по времени и трудным для сопровождения. Экранировать данные, ограничивать длину входа и избегать неоднозначных вложенных повторов; критичные шаблоны измерять на худших строках. Решение адресует следующий дефект: даже экранированный пользовательский фрагмент не спасает от катастрофического возврата, если окружающий шаблон сам содержит опасные вложенные квантификаторы. Для проверки полного значения использовать `\A` и `\z`, а многострочный поиск выделять в отдельную операцию. Решение адресует следующий дефект: даже экранированный пользовательский фрагмент не спасает от катастрофического возврата, если окружающий шаблон сам содержит опасные вложенные квантификаторы.

Вопрос 20 из 25

Какой рефакторинг переводит правило «Проверка допущений» из договорённости в проверяемый контракт? Сопоставьте не только итог, но и правило, риск или проверку, которые с ним связаны.

Для проверки полного значения использовать `\A` и `\z`, а многострочный поиск выделять в отдельную операцию. Именно эта мера закрывает риск: лишние захваты меняют номера групп после правки шаблона и ломают код, который обращается к `$1` и `$2`. Для проверки полного значения использовать `\A` и `\z`, а многострочный поиск выделять в отдельную операцию. Именно эта мера закрывает риск: проверка только формы регулярным выражением не подтверждает календарную допустимость даты вроде 2026-02-31. Оставлять lookaround коротким; сложную грамматику разделять на предварительный разбор и простые проверки. Именно эта мера закрывает риск: валидация токена через `^` и `$` может принять атакующий ввод с переводом строки и опасным хвостом. После структурного разбора передавать поля календарной или доменной библиотеке для семантической проверки. Именно эта мера закрывает риск: валидация токена через `^` и `$` может принять атакующий ввод с переводом строки и опасным хвостом. Для проверки полного значения использовать `\A` и `\z`, а многострочный поиск выделять в отдельную операцию. Именно эта мера закрывает риск: валидация токена через `^` и `$` может принять атакующий ввод с переводом строки и опасным хвостом.

Вопрос 21 из 25

Какой тест даст новую информацию о надёжности решения «Группы»? Смотрите на всю причинную связку, а не только на знакомую формулировку.

Проверить отсутствие совпадения: обращение к captures у nil должно быть обработано явно. Этот сценарий проверяет исправление: оставлять lookaround коротким; сложную грамматику разделять на предварительный разбор и простые проверки. Проверить флаги регистра и кодировку: буквальное экранирование не задаёт нужную политику сравнения. Этот сценарий проверяет исправление: использовать именованные группы для значимых полей и незахватывающие — только для структуры. Проверить отсутствие совпадения: обращение к captures у nil должно быть обработано явно. Этот сценарий проверяет исправление: использовать именованные группы для значимых полей и незахватывающие — только для структуры. Проверить завершающий перевод строки: `\Z` допускает его, тогда как `\z` требует абсолютного конца. Этот сценарий проверяет исправление: использовать именованные группы для значимых полей и незахватывающие — только для структуры. Проверить отсутствие совпадения: обращение к captures у nil должно быть обработано явно. Этот сценарий проверяет исправление: после структурного разбора передавать поля календарной или доменной библиотеке для семантической проверки.

Вопрос 22 из 25

Какую границу контракта «Контекстные проверки lookaround» нужно закрепить отдельным тестом? Одного совпавшего вывода недостаточно — проверьте также вторую часть ответа.

Проверить Unicode и границы слова: `\b` опирается на правила символов слова, которые могут не совпасть с предметным алфавитом. Так проверяется решение: для проверки полного значения использовать `\A` и `\z`, а многострочный поиск выделять в отдельную операцию. Проверить повторяющиеся имена и необязательные группы: значение может быть nil или выбрано из последнего совпавшего захвата. Так проверяется решение: оставлять lookaround коротким; сложную грамматику разделять на предварительный разбор и простые проверки. Проверить Unicode и границы слова: `\b` опирается на правила символов слова, которые могут не совпасть с предметным алфавитом. Так проверяется решение: после структурного разбора передавать поля календарной или доменной библиотеке для семантической проверки. Проверить Unicode и границы слова: `\b` опирается на правила символов слова, которые могут не совпасть с предметным алфавитом. Так проверяется решение: оставлять lookaround коротким; сложную грамматику разделять на предварительный разбор и простые проверки. Проверить флаги регистра и кодировку: буквальное экранирование не задаёт нужную политику сравнения. Так проверяется решение: оставлять lookaround коротким; сложную грамматику разделять на предварительный разбор и простые проверки.

Вопрос 23 из 25

Какой сценарий проверит не только результат, но и побочный эффект решения «Именованные захваты»? Ищите не знакомые слова, а технически непротиворечивую пару утверждений.

Проверить повторяющиеся имена и необязательные группы: значение может быть nil или выбрано из последнего совпавшего захвата. Проверка относится к изменению: после структурного разбора передавать поля календарной или доменной библиотеке для семантической проверки. Проверить завершающий перевод строки: `\Z` допускает его, тогда как `\z` требует абсолютного конца. Проверка относится к изменению: после структурного разбора передавать поля календарной или доменной библиотеке для семантической проверки. Проверить повторяющиеся имена и необязательные группы: значение может быть nil или выбрано из последнего совпавшего захвата. Проверка относится к изменению: оставлять lookaround коротким; сложную грамматику разделять на предварительный разбор и простые проверки. Проверить повторяющиеся имена и необязательные группы: значение может быть nil или выбрано из последнего совпавшего захвата. Проверка относится к изменению: для проверки полного значения использовать `\A` и `\z`, а многострочный поиск выделять в отдельную операцию. Проверить Unicode и границы слова: `\b` опирается на правила символов слова, которые могут не совпасть с предметным алфавитом. Проверка относится к изменению: после структурного разбора передавать поля календарной или доменной библиотеке для семантической проверки.

Вопрос 24 из 25

Какую границу контракта «Безопасность шаблона» нужно закрепить отдельным тестом? Не выбирайте ответ по одному точному фрагменту: вся формулировка должна выдерживать проверку.

Проверить завершающий перевод строки: `\Z` допускает его, тогда как `\z` требует абсолютного конца. Сценарий подтверждает надёжность решения: экранировать данные, ограничивать длину входа и избегать неоднозначных вложенных повторов; критичные шаблоны измерять на худших строках. Проверить отсутствие совпадения: обращение к captures у nil должно быть обработано явно. Сценарий подтверждает надёжность решения: экранировать данные, ограничивать длину входа и избегать неоднозначных вложенных повторов; критичные шаблоны измерять на худших строках. Проверить флаги регистра и кодировку: буквальное экранирование не задаёт нужную политику сравнения. Сценарий подтверждает надёжность решения: после структурного разбора передавать поля календарной или доменной библиотеке для семантической проверки. Проверить флаги регистра и кодировку: буквальное экранирование не задаёт нужную политику сравнения. Сценарий подтверждает надёжность решения: экранировать данные, ограничивать длину входа и избегать неоднозначных вложенных повторов; критичные шаблоны измерять на худших строках. Проверить флаги регистра и кодировку: буквальное экранирование не задаёт нужную политику сравнения. Сценарий подтверждает надёжность решения: для проверки полного значения использовать `\A` и `\z`, а многострочный поиск выделять в отдельную операцию.

Вопрос 25 из 25

Какой тест даст новую информацию о надёжности решения «Проверка допущений»? Ищите не знакомые слова, а технически непротиворечивую пару утверждений.

Проверить завершающий перевод строки: `\Z` допускает его, тогда как `\z` требует абсолютного конца. На этой границе проверяется мера: для проверки полного значения использовать `\A` и `\z`, а многострочный поиск выделять в отдельную операцию. Проверить завершающий перевод строки: `\Z` допускает его, тогда как `\z` требует абсолютного конца. На этой границе проверяется мера: после структурного разбора передавать поля календарной или доменной библиотеке для семантической проверки. Проверить завершающий перевод строки: `\Z` допускает его, тогда как `\z` требует абсолютного конца. На этой границе проверяется мера: оставлять lookaround коротким; сложную грамматику разделять на предварительный разбор и простые проверки. Проверить флаги регистра и кодировку: буквальное экранирование не задаёт нужную политику сравнения. На этой границе проверяется мера: для проверки полного значения использовать `\A` и `\z`, а многострочный поиск выделять в отдельную операцию. Проверить отсутствие совпадения: обращение к captures у nil должно быть обработано явно. На этой границе проверяется мера: для проверки полного значения использовать `\A` и `\z`, а многострочный поиск выделять в отдельную операцию.