Полное руководство по regex

Регулярное выражение (или regex) — это синтаксис, позволяющий находить строки, соответствующие определенным шаблонам. Это что-то вроде функционала поиска в тексте, только regex позволяют использовать квантификаторы, специальные символы и группы захвата для создания по-настоящему продвинутых шаблонов поиска.

Regex можно использовать во всех случаях, когда вам нужно запросить строковые данные. Примеры юзкейсов:

• анализ вывода командной строки
• парсинг пользовательского ввода
• проверка логов сервера или программы
• управление текстовыми файлами с последовательным синтаксисом, такими, как CSV
• чтение файлов конфигурации
• поиск в коде и рефакторинг кода

Теоретически, делать все это можно и без regex, но использование регулярок дает вам суперсилу в решении подобных задач.

Как выглядят регулярные выражения?

В простейшей форме regex может выглядеть так:

От редакции Techrocks. О сайте regex101 и других сайтах для изучения regex можно почитать в статье «Как, наконец, выучить Regex?».

В примере «Test» буквы test образуют шаблон, как при обычном поиске. Но регулярные выражения далеко не всегда столь просты. Вот regex, означающий «3 цифры, за которыми следует дефис, за которым идут 3 цифры, после которых идет еще дефис, а в конце идут 4 цифры».

Т.е. это формат записи телефонного номера:

^(?:\d{3}-){2}\d{4}$

Это регулярное выражение может показаться сложным, но, во-первых, к концу этой статьи вы научитесь читать подобные шаблоны, а во-вторых, это действительно сложный способ написания шаблона.

Фактически, большинство регулярных выражений можно написать по-разному. Например, выражение, приведенное выше, можно переписать более длинно, но при этом более читабельно:

^[0-9]{3}-[0-9]{3}-[0-9]{4}$

Большинство языков программирования предоставляют встроенные методы для поиска и замены строк с использованием regex. Но при этом в каждом языке может быть собственный синтаксис регулярок.

В этой статье мы остановимся на варианте regex в ECMAScript, который используется в JavaScript и имеет много общего с реализациями регулярных выражений в других языках.

Как читать (и писать) регулярные выражения

Квантификаторы

В регулярных выражениях квантификаторы указывают, сколько раз должен встретиться символ. Вот список квантификаторов:

• a|b — или a, или b
• ? — ноль или один
• + — один или больше
• * — ноль или больше
• {N} — ровно N раз (здесь N — число)
• {N,} — N или больше раз (N — число)
• {N,M} — от N до M раз (N и M — числа, при этом N < M)
• *? — ноль или больше, но после первого совпадения поиск нужно прекратить

Например, следующее регулярное выражение соответствует и строке «Hello», и строке «Goodbye»:

Hello|Goodbye

В то время как

Hey?

может означать как отсутствие y, так и одно вхождение y, и таким образом весь шаблон может соответствовать и «He», и «Hey».

Еще пример:

Hello{1,3}

Этот шаблон соответствует «Hello», «Hellooo», но не «Helloooo», потому что буква «о» может встречаться от 1 до 3 раз.

Квантификаторы можно комбинировать:

He?llo{2}

Здесь мы ищем строки, в которых «e» нет или встречается 1 раз, а «o» встречается ровно 2 раза. Таким образом, этот шаблон соответствует словам «Helloo» и «Hlloo».

Жадное соответствие

В списке квантификаторов в предыдущем разделе мы познакомились со значением символа +. Этот квантификатор означает один или больше символов. Таким образом, шаблон

Hi+

будет соответствовать как «Hi», так и «Hiiiiiiiiiiiiiiii». Это потому, что все квантификаторы по умолчанию «жадные».

Но вы можете сменить их поведение на «ленивое» при помощи символа ?.

Hi+?

Теперь шаблон будет соответствовать как можно меньшему числу «i». Символ + означает «один или больше», что в «ленивом» варианте превращается в «один». То есть, в строке «Hiiiiiiiiiii» шаблон совпадет только с «Hi».

Само по себе это не слишком полезно, но в сочетании с таким символом, как точка, становится важным.

Точка в регулярных выражениях используется для поиска любого символа.

Например, следующий шаблон соответствует и «Hillo», и «Hello», и «Hellollollo»:

H.*llo

Но что если в строке «Hellollollo» вам нужно совпадение только с «Hello»?

Нужно просто сделать поиск ленивым:

H.*?llo

Наборы

Квадратные скобки позволяют искать совпадение по целому набору символов, указанному в скобках. Например, шаблон

My favorite vowel is [aeiou]

совпадет со строками:

My favorite vowel is a
My favorite vowel is e
My favorite vowel is i
My favorite vowel is o
My favorite vowel is u

И ни с чем другим. [aeiou] — это набор, в регулярном выражении означающий «любой из указанных символов».

Вот список самых распространенных наборов:

• [A-Z] — совпадает с любой буквой в верхнем регистре, от «A» до «Z»
• [a-z] — совпадает с любой буквой в нижнем регистре, от «a» до «z»
• [0-9] -любая цифра
• [asdf] — совпадает с «a», «s», «d» или «f»
• [^asdf] — совпадает с любым символом кроме «a», «s», «d» или «f»

Эти наборы можно комбинировать:

• [0-9A-Z] — любой символ, являющийся либо цифрой, либо буквой от A до Z
• [^a-z] — любой символ, не являющийся буквой латинского алфавита в нижнем регистре

Символьные классы

Не каждый символ можно так легко идентифицировать. Скажем, найти буквы с использованием regex легко, а как насчет символа новой строки?

Примечание. Символ новой строки — это символ, который вы вводите, когда нажимаете Enter и переходите на новую строку.

• . — любой символ
• \n — символ новой строки
• \t — символ табуляции
• \s — пробельный символ (включая \t, \n и некоторые другие)
• \S — не-пробельный символ
• \w — любой «словообразующий» символ (буквы латинского алфавита в верхнем и нижнем регистре, цифры 0-9 и символ подчеркивания _)
• \W — любой «несловообразующий» символ (класс символов, обратный классу \w)
• \b — граница слова, разделяет \w и \W, т. е. словообразующие и несловообразующие символы. Граница слова соответствует позиции, где за символом слова не следует другой символ слова.
• \B — несловообразующая граница (класс, обратный \b). Несловообразующая граница соответствует позиции, в которой предыдущий и следующий символы являются символами одного типа: либо оба должны быть словообразующими символами, либо несловообразующими. Начало и конец строки считаются несловообразующими символами.
• ^ — начало строки
• $ — конец строки
• \\ — символ «\» в буквальном значении

Допустим, вы хотите удалить каждый символ, с которого начинается новое слово в строке. Вы можете использовать следующее регулярное выражение для поиска этих символов:

\s.

А затем найденные символы можно заменить пустой строкой. Таким образом строка

Hello world how are you

превратится в

Helloorldowreou

Комбинирование наборов

Символьные классы сами по себе не слишком полезны, но их можно сочетать с наборами. Допустим, мы хотим удалить из строки любую букву в верхнем регистре или пробельный символ. Это можно написать так:

[A-Z]|\s

Но \s можно поместить и внутрь набора:

[A-Z\s]

Границы слова

В списке символьных классов вы видели символ \b, означающий границу слова. На нем стоит остановиться отдельно, потому что этот токен работает не как остальные.

Допустим, у вас есть строка «This is a string». Вы можете предположить, что символ границы слова соответствует пробелам между словами, но это не так. Он соответствует тому, что находится между буквой и пробелом.

Это может быть трудно понять. Но обычно никто и не ищет сами границы слов. Вместо этого можно написать, например, выражение для поиска целых слов:

\b\w+\b

Это регулярное выражение интерпретируется следующим образом: «Граница слова, за которой следует один или больше словообразующих символов, за которыми следует другая граница слова».

Начало и конец строки

Еще два важных токена — ^ и $. Они означают начало и конец строки соответственно.

То есть, если вы хотите найти первое слово в строке, вы можете написать следующее выражение:

^\w+

Оно соответствует одному или большему числу словообразующих символов, но только если они идут непосредственно в начале строки. Помните, что словообразующий символ это любая буква латинского алфавита в любом регистре, а также любая цифра и символ подчеркивания.

Аналогично, если вы хотите найти последнее слово в строке, ваше регулярное выражение может выглядеть так:

\w+$

Но то, что символ $ обычно заканчивает строку, не означает, что после него не может идти других символов.

Допустим, мы хотим найти каждый пробельный символ между новыми строками для создания базового минификатора JavaScript-кода.

Мы можем написать следующее выражение, чтобы найти все пробелы после конца строки:

$\s+

Экранирование символов

Хотя токены символьных классов очень полезны, иногда с ними возникают сложности. Например, когда нужно написать шаблон для поиска таких токенов в тексте.

Допустим, у вас есть строка в тексте статьи:

"Символ новой строки - '\n'"

Или вы хотите найти вообще все упоминания «\n» в тексте. Тогда в шаблоне символ \n нужно «экранировать»: поставить перед ним обратную косую черту:

\\n

Как использовать regex

Ценность регулярных выражений не только в том, что они позволяют находить строки. Вы также можете использовать их для модификации строк и других действий с ними.

В разных языках программирования есть похожие методы для работы с regex. Мы используем JavaScript в качестве примера.

Создание регулярных выражений и поиск с их помощью

Для начала давайте посмотрим, как строятся регулярные выражения.

В JavaScript (и в некоторых других языках) мы помещаем regex в блоки //. Регулярное выражение для поиска буквы в нижнем регистре будет выглядеть так:

/[a-z]/

Этот синтаксис генерирует объект RegExp, который можно использовать со встроенными методами типа exec для поиска соответствий в строках.

/[a-z]/.exec("a"); // Возвращает ["a"]
/[a-z]/.exec("0"); // Возвращает null

Затем мы можем использовать это истиноподобие для определения, есть ли совпадение с regex (как в строке 3 примера, доступного по ссылке ниже).

Запустить код в песочнице.

Или мы можем вызвать конструктор RegExp со строкой, которую хотим конвертировать в регулярное выражение:

const regex = new RegExp("[a-z]"); // То же самое, что /[a-z]/

Замена строк при помощи регулярных выражений

Вы можете использовать regex для поиска и замены содержимого файлов. Скажем, вы хотите заменить любое приветствие на прощание. Можно сделать это так:

function youSayHelloISayGoodbye(str) {
  str = str.replace("Hello", "Goodbye");
  str = str.replace("Hi", "Goodbye");
  str = str.replace("Hey", "Goodbye");  str = str.replace("hello", "Goodbye");
  str = str.replace("hi", "Goodbye");
  str = str.replace("hey", "Goodbye");
  return str;
}

Но можно и проще, с использованием regex:

function youSayHelloISayGoodbye(str) {
  str = str.replace(/[Hh]ello|[Hh]i|[Hh]ey/, "Goodbye");
  return str;
}

Запустить код в песочнице

Но вы можете заметить, что при запуске youSayHelloISayGoodbye с «Hello, Hi there» регулярное выражение совпадает не больше, чем с одним вхождением:

Регулярное выражение /[Hh]ello|[Hh]i|[Hh]ey/, примененное к строке «Hello, Hi there», по умолчанию совпадет только с «Hello».

Мы ожидаем, что оно совпадет и с «Hello», и с «Hi», но этого не происходит.

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

Флаги в regex

Флаг — это модификатор существующего регулярного выражения. При определении regex флаги всегда добавляются после замыкающего слэша.

Вот небольшой список доступных флагов:

• g — глобально, больше одного совпадения
• m — заставляет $ и ^ соответствовать каждой новой строчке отдельно
• i — делает regex нечувствительным к регистру

Мы можем взять наше регулярное выражение:

/[Hh]ello|[Hh]i|[Hh]ey/

и переписать его, применив флаг нечувствительности к регистру:

/Hello|Hi|Hey/i

Это регулярное выражение будет соответствовать следующим словам:

Hello
HEY
Hi
HeLLo

Также оно будет соответствовать любому другому варианту чередования заглавных и строчных букв.

Флаг глобального поиска для замены строк

Как уже говорилось, если вы производите замену при помощи regex без всяких флагов, заменен будет только первый результат поиска:

let str = "Hello, hi there!";
str = str.replace(/[Hh]ello|[Hh]i|[Hh]ey/, "Goodbye");
console.log(str); // В выводе будет "Goodbye, hi there"

Но если вы добавите флаг глобального поиска, будут найдены все соответствия шаблону:

let str = "Hello, hi there!";
str = str.replace(/[Hh]ello|[Hh]i|[Hh]ey/g, "Goodbye");
console.log(str); // В выводе будет "Goodbye, Goodbye there"

Использование флага глобального поиска в JavaScript

При использовании глобального поиска в JavaScript regex вы можете столкнуться со странным поведением.

Если вы многократно запустите exec с глобальным поиском, команда будет через раз возвращать null.

Как объясняет MDN,

«Объекты RegExp в JavaScript, когда у них установлены флаги global или sticky, являются stateful-объектами… Они хранят lastIndex из предыдущего сопоставления. Благодаря этому exec() может применяться для итерации по нескольким сопоставлениям в строке текста…»

Команда exec пытается начать поиск по lastIndex, продвигаясь вперед. Поскольку lastIndex имеет значение длины строки, exec будет пытаться сопоставить с вашим регулярным выражением "" — пустую строку, пока она не будет сброшена новой командой exec. Хотя эта особенность может быть полезна в определенных обстоятельствах, она часто сбивает с толку новичков.

Чтобы решить эту проблему, мы можем просто назначать значение 0 для lastIndex перед каждым запуском команды exec:

Группы в regex

При поиске совпадения с шаблоном может быть полезно искать больше одного сопоставляемого элемента за раз. Тут в игру вступают группы.

В примере ниже мы видим совпадение и с «Testing 123», и с «Tests 123» без дублирования «123» в выражении.

/(Testing|tests) 123/ig

Группы определяются при помощи скобок. Бывают они двух видов: группы захвата и незахватывающие группы (capture groups и non-capturing groups):

• (…) — группа, соответствующая любым 3 символам
• (?:…) — незахватывающая группа, соответствующая любым 3 символам

Разница между этими группами ощутима тогда, когда речь идет о замене символов.

Например, используя приведенное выше выражение, при помощи JavaScript можно заменить текст с «Testing 234» и «tests 234»:

const regex = /(Testing|tests) 123/ig;

let str = `
Testing 123
Tests 123
`;

str = str.replace(regex, '$1 234');
console.log(str); // Testing 234\nTests 234"

Мы используем $1 для обращения к первой группе захвата, (Testing|tests). Мы также можем сопоставить больше одной группы, скажем, сопоставлять одновременно (Testing|tests) и (123):

const regex = /(Testing|tests) (123)/ig;

let str = `
Testing 123
Tests 123
`;

str = str.replace(regex, '$1 #$2');
console.log(str); // Testing #123\nTests #123"

Но это работает только с группами захвата.

Давайте заменим вот это:

/(Testing|tests) (123)/ig

на это:

/(?:Testing|tests) (123)/ig;

Теперь у нас только одна группа захвата — (123), и код, который мы использовали ранее, произведет другой результат:

const regex = /(?:Testing|tests) (123)/ig;

let str = `
Testing 123
Tests 123
`;

str = str.replace(regex, '$1');
console.log(str); // "123\n123"

Запустить код в песочнице

Именованные группы захвата

Хотя группы захвата — отличная вещь, в них легко запутаться, когда их у вас несколько. Разница между $3 и $5 не всегда очевидна.

Для решения этой проблемы в регулярных выражениях есть концепция «именованных групп захвата».

(?<name>...) — здесь именованная группа с именем «name» соответствует любым 3 символам.

Например, можно создать группу с именем «num», которая будет соответствовать 3 цифрам:

Затем вы можете использовать эту группу для замены:

const regex = /Testing (?<num>\d{3})/
let str = "Testing 123";
str = str.replace(regex, "Hello $<num>")
console.log(str); // "Hello 123"

Именованные обратные ссылки

Иногда бывает полезно сослаться на именованную группу захвата внутри самого запроса. В этом вам помогут «обратные ссылки».

\k<name> — ссылка на именованную группу захвата «name» в поисковом запросе.

Скажем, вы хотите, чтобы выш шаблон совпадал со строкой

Hello there James. James, how are you doing?

но не со строкой

Hello there James. Frank, how are you doing?

Вы можете написать regex, где повторяется слово «James»:

/.*James. James,.*/

Но лучше написать так:

/.*(?<name>James). \k<name>,.*/

Теперь имя жестко прописано только в одном месте.

Запустить код в песочнице.

Опережающие и ретроспективные группы

Опережающие (lookahead) и ретроспективные (lookbehind) группы — очень мощный инструмент, который часто понимают превратно.

Есть четыре разных типа опережающих и ретроспективных проверок:

• (?!) — негативная опережающая проверка
• (?=) — позитивная опережающая проверка
• (?<=) — позитивная ретроспективная проверка
• (?<!) — негативная ретроспективная проверка

Суть lookahead — проверить, что за группой стоит или не стоит определенный шаблон (позитивная и негативная проверка).

Пример негативной опережающей проверки:

/B(?!A)/

Это выражение читается как «найди B, за которым НЕ следует A». Оно соответствует «В» в «BC», но не в «BA».

Это можно комбинировать с символами начала и конца строки, чтобы искать соответствия для целых строк. Например, следующее выражение соответствует любой строке, которая НЕ начинается с «Test»:

/^(?!Test).*$/gm

Мы можем изменить негативную опережающую проверку на позитивную и таким образом найти строки, которые начинаются с «Test»:

/^(?=Test).*$/gm

Итоги

Регулярные выражения — невероятно мощный инструмент, который можно использовать для всевозможных манипуляций со строками. Знание regex поможет вам проводить рефакторинг кодовых баз, вносить быстрые правки в скрипты и т. д.

Давайте вернемся к нашему regex, соответствующему номеру телефона. Попробуйте теперь прочитать это выражение:

^(?:\d{3}-){2}\d{4}$

Оно служит для поиска телефонных номеров:

555-555-5555

Здесь:

• ^ и $ используются для обозначения начала и конца строки
• Незахватывающая группа нужна для поиска трех цифр, за которыми следует дефис.
  • Эта группа повторяется дважды для соответствия 555-555-
• Дальше мы ищем последние 4 цифры телефонного номера.

Надеюсь, эта статья дала вам начальное представление о regex.

Перевод статьи «The Complete Guide to Regular Expressions (Regex)».

[customscript]techrocks_custom_after_post_html[/customscript]

[customscript]techrocks_custom_script[/customscript]