Рассказываем про 7 команд, влияющие на скорость работы в терминале. Вы узнаете:

• про встроенные bash-операции, которые заменяют пайплайны,
• про способы работы с файловыми дескрипторами,
• про wildcards, которые избавляют от сложных конструкций с find.

Каждая команда в подборке решает конкретную проблему:

• массовая обработка файлов,
• отладка скриптов,
• работа с длинными путями.

1. Bash variable expansions

Вместо basename, cut для простых операций со строками можно использовать встроенные возможности Bash:

% режет справа до первого совпадения, %% — до последнего. Символ # работает слева направо.

В реальной работе это помогает при массовой обработке файлов. Например, есть 1000 логов, и нужно каждый переименовать.

Если использовать basename, запустится 1000 отдельных процессов. Variable expansions работают без fork/exec, без задержек на создание процессов.

Bash variable expansions используют в циклах с файлами и при работе с массивами. Когда скрипт обрабатывает сотни файлов, разница в скорости становится заметной. Еще и код выглядит чище.

2. Here-string (<<<)

Here-string упрощает передачу строковых данных в команды без создания временных файлов или использования echo с пайпом.

Реальная экономия времени проявляется при отладке и модификации скриптов. Например, когда SQL-запрос или конфигурация зашиты в here-документ. С here-string данные собраны в одном месте, легко редактируются и переиспользуются.

Работает не только с базами данных. Отправка в API, конфигурирование сетевых устройств через expect, передача команд в Docker — через <<< код будет понятнее, а сопровождение проще.

3. /proc/$$/fd

Каждый процесс имеет стандартные дескрипторы 0 (stdin), 1 (stdout), 2 (stderr), которые представлены как символические ссылки. Директория /proc/$$/fd предоставляет доступ к файловым дескрипторам текущего процесса:

Переменная $$ содержит PID текущего процесса, поэтому /proc/$$/fd ведет к дескрипторам именно вашего шелла.

Практическое применение — отладка перенаправлений и работа с дескрипторами в сложных скриптах:

4. Wildcards с диапазонами

Про * и ? говорят чаще, чем про диапазоны в квадратных скобках. Такие маски используют реже, а зря — они решают массу задач по отбору файлов.

Wildcards автоматически раскрываются шеллом в список подходящих файлов — это их основная функция. Кавычки нужны только когда передаете символы [, ] как литеральные:

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

5. sudo !!

Набрали длинную команду, нажали Enter, получили «Permission denied». Рука на рефлексе тянется к стрелке вверх и Home, чтобы добавить sudo в начало.

Вот способ в разы быстрее:

Двойное восклицание !! — это ссылка на предыдущую команду целиком. Bash подставит всю строку со всеми аргументами и ключами. Кажется мелочью, но для админа, который 10 раз в день забывает sudo, это серьезная оптимизация.

Двойное восклицание универсально и работает не только с sudo:

• time !! для замера времени выполнения,
• nohup !! & для запуска в фоне,
• strace !! для отладки.

Если между командой и sudo !! выполнялись другие команды, восклицание сработает для последней из них. Для поиска конкретной команды в истории используйте !строка.

6. ^старое^новое

Основной способ исправления опечатки — стрелка вверх, поиск ошибки, исправление. Смотрите, как можно сделать это побыстрее:

Символ ^ ищет первое вхождение слова и заменяет его. Работает с последней командой.

Заменяется только первое вхождение. Если ошибочное слово встречается несколько раз, способ не сработает. В таких случаях придется использовать классическое редактирование или history expansion.

7. Alt+.

Создали файл с длинным именем — теперь его нужно отредактировать, переместить, изменить права. Каждый раз перепечатывать путь утомительно и чревато ошибками.

Комбинация Alt+. (Alt + точка) вставляет последний аргумент предыдущей команды в текущую позицию курсора. Повторное нажатие перебирает аргументы из более ранних команд.

Экономия времени проявляется при работе с файлами и директориями. Например: распаковали архив, теперь нужно зайти в созданную папку, затем посмотреть содержимое, потом изменить права. Вместо того, чтобы 3 раза печатать один путь, можно 3 раза нажать Alt+.

Еще этой комбинацией вставляются:

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

Alt + точка работает в большинстве шеллов. Привыкнув к ней, начинаешь использовать на автомате.

Что запомнить

• ${filename%.*} и встроенные операции со строками работают быстрее внешних утилит. % режет справа, # — слева. Полезно при работе с циклами для массовой обработки файлов.
• <<< — here-string удобен для передачи коротких строковых данных в команды. С многострочными данными лучше использовать here-document или переменные.
• /proc/$$/fd — доступ к файловым дескрипторам текущего процесса. Ускоряет отладку перенаправлений и работу с дескрипторами.
• file[1-5] и [^b]* — диапазоны в wildcards для точного отбора файлов. Кавычки нужны только для передачи литеральных символов.
• sudo !! — повторяет последнюю команду с sudo. Также работает с time !!, nohup !! &. Если между нужной командой и !! выполнялись другие операции, используйте !строка для поиска конкретной команды в истории.
• ^старое^новое — заменяет первое вхождение в предыдущей команде. Работает только с последней командой и заменяет первое совпадение.
• Alt+. — вставляет последний аргумент предыдущей команды. Повторное нажатие перебирает аргументы из истории команд. Экономит время при работе с длинными путями.

База и теория

1. Event loop для чайников: простыми словами о сложном механизме браузера — В статье разбираем, что такое Event Loop, очередь задач и стек вызовов. Простыми словами о том, как браузер выполняет JavaScript-код и обрабатывает события.
2. Чек-лист по Node.js для новичков: обработка ошибок — Показываем основные подходы к обработке ошибок для Node.js. Рассматриваем пошаговую инструкцию и практические примеры.
3. Что нужно учить JavaSript-разработчикам в 2024 году — Разбираем, какие технологии и навыки нужно знать JS-разработчику, в том числе и в 2025. От фреймворков до подходов к архитектуре.
4. Декларативные языки на примерах с JavaScript — Рассказываем, что значит декларативный стиль программирования. Сравниваем с императивным на примерах JavaScript.
5. JavaScript localStorage: Полное руководство — Разбираем, как работает localStorage. Учим сохранять данные на клиенте с помощью JavaScript.
6. Как работает режим strict в JavaScript — Объясняем, что делает режим strict и почему он помогает писать более безопасный код на JavaScript.
7. Как бесплатно выучить JavaScript и не идти в онлайн-школы — Рассказываем, как самостоятельно освоить JavaScript. Бесплатные ресурсы, полезные советы и личный план обучения.
8. Какие JS-библиотеки использовать для анимаций на сайте в 2024 году — Актуальные JavaScript-библиотеки для веб-анимации. Рассматриваем лучшие инструменты для красивых и быстрых интерфейсов.

Практикуемся

1. 10 реальных вопросов с собеседования JavaScript-разработчика с ответами — Подборка реальных вопросов с собеседований для JavaScript-разработчиков. Даем ответы и объясняем, как правильно мыслить на интервью.
2. Приложение прогноза погоды с использованием Vue JS — Пошаговое руководство по созданию погодного приложения на Vue.js. Обучаем взаимодействию с API и построению интерфейса.
3. Математика в программировании: реализуем уравнения на JavaScript — Объясняем, как реализовать математические уравнения на JavaScript. Практика для программистов, которые не боятся формул.
4. Регулярные выражения в JavaScript: разбираемся в создании — Учим создавать и использовать RegExp в JavaScript. Поясняем синтаксис, паттерны и типовые ошибки.
5. Решаем популярные задачи с асинхронным кодом на JavaScript: часть первая — Практика асинхронного программирования на JavaScript. Решаем задачи с API, задержками и промисами.
6. Асинхронный JavaScript: изучаем Async/Await, Callbacks и Promises — Учим писать асинхронный код в JavaScript: от колбэков до современного async/await. Понятно, на примерах и без лишнего.
7. Задачи по асинхронному программированию на JS — Упражнения на асинхронный JavaScript. От простых примеров до сложных сценариев.

Предыдущие подборки лежат здесь: React, мобильная разработка, С++, инструменты.

Кстати! Забрать все самые топовые нейронки для айтишников можно в нашем большом гайде с 70+ ИИ-инструментами

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

Что такое регулярные выражения

Регулярные выражения (ещё их называют Regular Expressions, сокращённо regex или regexp, регулярки) — специальные шаблоны, которые используют для поиска и обработки текста. Для поиска в них можно задавать дополнительные команды, например игнорирование регистра.

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

А ещё регулярки экономят очень много кода. Но есть один недостаток — они часто выглядят пугающе, запутанно и странно, особенно если шаблон сложный.

Например, этот шаблон ищет email-адреса:

/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/

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

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

Например, нам нужно проверить номер телефона в форме регистрации:

В этом примере мы создали функцию validatePhoneNumber, которая принимает номер телефона в качестве аргумента и возвращает true, если номер телефона является действительным номером для России, и false в противном случае.

В регулярном выражении phoneRegex мы использовали символ ^, чтобы указать, что номер телефона должен начинаться с «+7» или «8» (возможно, без плюса). Затем мы использовали символы \d для указания цифр и {10} для указания количества цифр в номере телефона (10 цифр).

В примере использования мы передали строку «+79123456789» функции validatePhoneNumber и проверили результат.

Как создать регулярное выражение в JavaScript

Есть два способа создания регулярок — разберём каждый.

1. Конструктор RegExp()

Конструктор RegExp() позволяет создавать регулярные выражения на основе строки, передаваемой ему в качестве аргумента. Формат конструктора RegExp() выглядит следующим образом:

const regex = new RegExp("pattern", "flags");

Где «pattern» — это строка, содержащая регулярное выражение, а «flags» — дополнительные флаги, определяющие, как будет работать регулярное выражение. Например, флаг i указывает, что регулярное выражение должно игнорировать регистр символов.

Вот пример использования конструктора RegExp() для создания регулярного выражения, которое ищет все цифры в строке:

const regex = new RegExp("\\d", "g");

Здесь мы передаём строку \d в качестве первого аргумента, что означает «любая цифра». Флаг g указывает, что регулярное выражение должно искать все совпадения в строке.

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

2. Литералы

Литерал регулярного выражения, так же как и конструктор, состоит из двух частей. Первая часть — шаблон, который необходимо описать, он заключается в слеши (//). Вторая часть, после закрывающего слеша, — флаги, но их использование также необязательно.

Вот как он выглядит:

const regex = /pattern/flags;

Разберём на примере использования литерала для создания того же регулярного выражения, которое ищет все цифры в строке:

const regex = /\d/g;

Здесь мы используем литерал /\d/g, который означает «любая цифра» с флагом g, указывающим, что регулярное выражение должно искать все совпадения в строке.

Обратите внимание: если вы планируете создавать регулярные выражения при помощи литералов, такой подход не позволяет изменять задаваемые значения динамически — литералы регулярных выражений компилируются заранее при анализе скрипта. Зато если ваше регулярное выражение постоянно, то литералы позволяют увеличить производительность.

Оба эти способа создания регулярных выражений в JavaScript эквивалентны друг другу — выбирайте тот, который вам удобнее.

Базовый синтаксис регулярных выражений в JavaScript

Разберём основу синтаксиса регулярных выражений в JavaScript.

Шаблоны и метасимволы

Шаблоны — набор символов, которые используют для поиска определённых сочетаний символов в тексте. Метасимволы — специальные символы, которые используют для составления шаблонов.

Вот несколько примеров шаблонов и метасимволов:

. — соответствует любому одиночному символу, кроме символа новой строки.

* — соответствует нулю или более повторениям предыдущего символа.

+ — соответствует одному или более повторениям предыдущего символа.

? — соответствует нулю или одному повторению предыдущего символа.

^ — соответствует началу строки.

$ — соответствует концу строки.

() — определяет группу символов, которые могут быть повторены.

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

Квантификаторы — метасимволы, которые определяют количество повторений предыдущего символа.

Некоторые квантификаторы:

{n} — соответствует ровно n повторениям предыдущего символа.

{n,m} — соответствует от n до m повторений предыдущего символа.

{n,} — соответствует n или более повторениям предыдущего символа.

? — делает предыдущий квантификатор ленивым, т. е. соответствует наименьшему возможному количеству повторений.

Пример использования квантификатора:

const pattern = /a{3}/; // соответствует трём символам "a" подряд

В тексте, который будет обрабатываться с помощью этого регулярного выражения, будут найдены все вхождения трёх символов a подряд. Например, строка «baaaad» будет соответствовать шаблону, а строка «abaa» — нет.

Модификаторы — специальные флаги, которые можно добавить к регулярному выражению для изменения его поведения.

Некоторые модификаторы:

g — глобальный поиск, ищет все совпадения в строке.

i — игнорирование регистра, игнорирует различия между верхним и нижним регистром.

m — многострочный поиск, позволяет искать совпадения в нескольких строках.

Пример использования модификатора:

const pattern = /test/gi; // соответствует строкам "test" или "Test" или "TEST" глобально и без учёта регистра

Группы и обратные ссылки

Группы — последовательности символов, заключённые в скобки (), которые могут повторяться с помощью квантификаторов. Группы также позволяют использовать обратные ссылки, которые ссылаются на результат совпадения группы в регулярном выражении. Обратная ссылка обозначается символом \ и номером группы, например, \1 ссылается на первую группу.

Пример использования групп и обратных ссылок:

​​const pattern = /(\w+)\s\1/; // соответствует повторяющейся последовательности символов, разделённой пробелом

В этом примере группа (\w+) соответствует любой последовательности символов, состоящей из буквенно-цифровых символов и подчёркивания. Затем \s соответствует пробелу, а \1 обратно ссылается на первую группу (\w+), так что регулярное выражение соответствует только тем строкам, в которых последовательность символов повторяется через пробел.

Экранирование в регулярных выражениях

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

Для экранирования символа используется обратный слеш \.

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

Примеры:

• Поиск всех цифр в тексте.

• Замена всех пробелов на символ подчёркивания.

• Замена всех точек в тексте на запятые, кроме точек, которые находятся внутри чисел.

Как использовать регулярки с методами объекта RegExp и String

После того как базовый синтаксис и способы написания шаблонов усвоены, перейдём к использованию регулярок в работе. Для работы с регулярными выражениями в JavaScript есть несколько методов — рассмотрим каждый.

Метод test()

Метод test() проверяет, соответствует ли регулярное выражение заданной строке. Метод возвращает true, если строка соответствует регулярному выражению, и false, если не соответствует.

Пример использования метода test():

В этом примере мы используем метод test() для проверки, содержит ли строка str подстроку «Hello». Регулярное выражение /Hello/ соответствует строке «Hello», и метод test() вернёт true.

Метод exec()

Метод exec() используется для поиска совпадений регулярного выражения в заданной строке. Метод возвращает массив, содержащий найденное совпадение и дополнительную информацию о нём.

Пример использования метода exec():

В этом примере мы используем метод exec() для поиска совпадений регулярного выражения /Hello/ в строке str. Метод exec() возвращает массив, содержащий найденное совпадение «Hello», индекс первого символа совпадения в исходной строке и саму исходную строку.

Метод match()

Метод match() используется для поиска всех совпадений регулярного выражения в заданной строке. Метод возвращает массив, содержащий все найденные совпадения.

Пример использования метода match():

В этом примере мы используем метод match() для поиска всех совпадений регулярного выражения /the/gi в строке str. Метод match() возвращает массив, содержащий все найденные совпадения, включая повторения.

Метод replace()

Метод replace() принимает два аргумента: регулярное выражение и строку, на которую нужно заменить найденное совпадение. Этот метод ищет все совпадения с заданным регулярным выражением в исходной строке и заменяет их на указанную строку.

Пример использования метода replace():

В этом примере мы используем метод replace() для замены слова «мир» на «земля» в строке «Привет, мир!» Регулярное выражение /мир/ ищет все совпадения со словом «мир» в строке, и метод replace() заменяет их на слово «земля». Результатом работы метода является новая строка «Привет, земля!»

Метод search()

Метод search() принимает один аргумент — регулярное выражение. Он ищет первое совпадение с заданным регулярным выражением в исходной строке и возвращает индекс первого символа совпадения. Если совпадение не найдено, метод возвращает -1.

Например:

В этом примере мы используем метод search() для поиска первого совпадения со словом «текст» в строке «Это текст для примера». Регулярное выражение /текст/ ищет первое совпадение со словом «текст» в строке, и метод search() возвращает индекс первого символа этого совпадения, который равен 4.

Метод split()

Метод split() принимает один аргумент — регулярное выражение. Он разбивает исходную строку на массив подстрок, используя заданное регулярное выражение как разделитель.

Пример использования метода split():

В этом примере мы используем метод split() для разделения строки «Это текст для примера» на массив слов, используя регулярное выражение / / в качестве разделителя. Регулярное выражение / / ищет все пробелы в строке, и метод split() использует их в качестве разделителя для разделения строки на массив слов. Результатом работы метода является массив [«Это», «текст», «для», «примера»].

Когда и как использовать регулярки на практике

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

Разберём подробнее несколько вариантов использования.

Валидация email-адресов

Один из популярных примеров использования регулярных выражений — валидация email-адресов.

Шаблон будет выглядеть так:

/^[^\s@]+@[^\s@]+\.[^\s@]+$/, где

^ — начало строки

@ — символ «@»

\. — символ «.» (экранированный с помощью слеша)

$ — конец строки

Таким образом, этот паттерн соответствует любому email-адресу, который состоит из локальной части (часть до символа «@») и доменной части (часть после символа «@» и до символа «.») с верным форматом.

Для проверки email-адреса на соответствие шаблону можно использовать метод test():

В этом примере функция validateEmail() принимает email-адрес в качестве аргумента и использует регулярное выражение для проверки его соответствия формату. Метод test() возвращает true, если email-адрес соответствует паттерну, и false в противном случае.

Форматирование текста

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

Рассмотрим пример форматирования даты с использованием регулярных выражений.

Допустим, у нас есть дата в формате «гггг-мм-дд» (например, «2023-03-29»), а мы хотим преобразовать её в формат «дд.мм.гггг» (например, «29.03.2023»). Для этого мы можем использовать регулярное выражение, чтобы разделить дату на отдельные части, а затем использовать эти части для создания новой строки в нужном формате.

Давайте разберём это регулярное выражение:

^ — начало строки

(\d{4}) — группа, соответствующая 4 цифрам (год)

— — символ «-«

(\d{2}) — группа, соответствующая 2 цифрам (месяц)

— — символ «-«

(\d{2}) — группа, соответствующая 2 цифрам (день)

$ — конец строки

В этом примере мы используем метод match() для поиска соответствия регулярному выражению в строке date. Если соответствие найдено, метод match() возвращает массив, содержащий соответствующие группы в порядке их появления в регулярном выражении. Затем мы используем эти группы для создания новой строки в нужном формате.

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

Извлечение номеров телефонов из строки

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

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

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

Для этого вы можете использовать следующий код:

В этом примере мы используем регулярное выражение /\+\d\s?\(\d{3}\)\s?\d{3}-\d{2}-\d{2}/g, чтобы извлечь номера телефонов из строки string.

Регулярное выражение ищет символ «+», и за ним следует одна или несколько цифр, за которыми следует необязательный пробел. Затем идут открывающая и закрывающая скобки, за которыми следуют три цифры, после чего снова идёт необязательный пробел. Далее идут три цифры, тире, две цифры, тире и ещё две цифры. В результате, если в строке есть номер телефона в формате, соответствующем регулярному выражению, он будет извлечён и сохранён в массиве phoneNumbers.

Ещё несколько советов по использованию регулярок

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

• Тестируйте регулярные выражения перед использованием. Это позволит выявить возможные ошибки или проблемы в выражении и сделать необходимые исправления. Используйте онлайн-сервисы, такие как regex101.com, regexr.com, regexplanet.com и подобные.
• Не злоупотребляйте использованием регулярок. Иногда другие простые методы могут оказаться более эффективными и лёгкими в понимании.

• Используйте комментарии и форматирование кода, чтобы облегчить его чтение и обслуживание. Регулярные выражения могут быть очень сложными для понимания.
• Используйте библиотеки. Есть множество библиотек уже готовых шаблонов — часто этого достаточно для решения задачи.

Заключение

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

1. Основы регулярных выражений
2. Регулярные выражения в Java
3. Примеры использования регулярных выражений в Java

Основы регулярных выражений

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

Определение

Регулярные выражения представляют собой формальный язык поиска и редактирования подстрок в тексте. Допустим, нужно проверить на валидность e-mail адрес. Это проверка на наличие имени адреса, символа @, домена, точки после него и доменной зоны.

Вот самая простая регулярка для такой проверки:

В коде регулярные выражения обычно обозначается как regex, regexp или RE.

Синтаксис RegEx

Символы могут быть буквами, цифрами и метасимволами, которые задают шаблон:

Есть и другие конструкции, с помощью которых можно сокращать регулярки:

• \d — соответствует любой одной цифре и заменяет собой выражение [0-9];
• \D — исключает все цифры и заменяет [^0-9];
• \w — заменяет любую цифру, букву, а также знак нижнего подчёркивания;
• \W — любой символ кроме латиницы, цифр или нижнего подчёркивания;
• \s — поиск символов пробела;
• \S — поиск любого непробельного символа.

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

Это специальные ограничители, с помощью которых определяется частота появления элемента — символа, группы символов, etc:

• ? — делает символ необязательным, означает 0 или 1. То же самое, что и {0,1}.
• * — 0 или более, {0,}.
• + — 1 или более, {1,}.
• {n} — означает число в фигурных скобках.
• {n,m} — не менее n и не более m раз.
• *? — символ ? после квантификатора делает его ленивым, чтобы найти наименьшее количество совпадений.

Примеры использования квантификаторов в регулярных выражениях

Обратите внимание, что квантификатор применяется только к символу, который стоит перед ним.

Также квантификаторов есть три режима:

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

Примеры их использования рассмотрим чуть дальше.

Регулярные выражения в Java

Поскольку мы говорим о регекспах в Java, то следует учитывать спецификации данного языка программирования.

Экранирование символов в регулярных выражениях Java

В коде Java нередко можно встретить обратную косую черту \: этот символ означает, что следующий за ним символ является специальным, и что его нужно особым образом интерпретировать. Так, \n означает перенос строки. Посмотрим на примере:

Результат:

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

Ключевые классы

Java RegExp обеспечиваются пакетом java.util.regex. Здесь ключевыми являются три класса:

1. Matcher — выполняет операцию сопоставления в результате интерпретации шаблона.
2. Pattern — предоставляет скомпилированное представление регулярного выражения.
3. PatternSyntaxException — предоставляет непроверенное исключение, что указывает на синтаксическую ошибку, допущенную в шаблоне RegEx.

Также есть интерфейс MatchResult, который представляет результат операции сопоставления.

Примеры использования регулярных выражений в Java

e-mail адрес

В качестве первого примера мы упомянули регулярку, которая проверяет e-mail адрес на валидность. И вот как эта проверка выглядит в Java-коде:

Результат:

Телефонный номер

Регулярное выражение для валидации номера телефона:

Эта регулярка ориентирована на российские мобильные номера, а также на городские с кодом из трёх цифр. Попробуйте написать код самостоятельно по принципу проверки e-mail адреса.

IP адрес

А вот класс для определения валидности IP адреса, записанного в десятичном виде:

Правильное количество открытых и закрытых скобок в строке

На каждую открытую должна приходиться одна закрытая скобка:

Извлечение даты

Теперь давайте извлечём дату из строки:

Проверка:

Результат:

А вот использование различных режимов квантификаторов, принцип работы которых мы рассмотрели чуть ранее.

Жадный режим

Результат:

В заданном шаблоне первый символ – a. Matcher сопоставляет его с каждым символом текста, начиная с нулевой позиции и захватывая всю строку до конца, в чём и проявляется его «жадность». Вот и получается, что заданная стартовая позиция – это 0, а последняя – 2.

Сверхжадный режим

Результат:

Принцип, как и в жадном режиме, только поиск заданного символа в обратном направлении не происходит. В приведённой строке всё аналогично: заданная стартовая позиция – это 0, а последняя – 2.

Ленивый режим

Результат:

Здесь всё просто: самое короткое совпадение находится на первой, второй и третьей позиции заданной строки.

Выводы

Общий принцип использования регулярных выражений сохраняется от языка к языку, однако если мы всё-таки говорим о RegEx в конкретном языке программирования, следует учитывать его спецификации. В Java это экранирование символов, использование специальной библиотеки java.util.regex и её классов.

А какие примеры использования регулярных выражений в Java хотели бы видеть вы? Напишите в комментариях.

В этой статье мы рассмотрим инструмент, с помощью которого можно прорываться через мусор в тексте.  А также фильтровать контент и названия файлов, отлавливать запрещённые/разрешенные команды, парсить SQL-запросы и выпендриваться перед коллегами. Это регулярные выражения ?

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

В начале было слово…

И слово это – паника. Давайте сперва запомним, как надёжней начинать работу с регулярными выражениями. Рассмотрим простейший пример:

Запустив сей код легким мановением руки… получим то, что всей душой ненавидят пишущие на golang люди — панику. Дело в том, что MustCompile паникует вместо возврата ошибки, как это сделано, например, в методе Compile из того же пакета.

Поэтому MustCompile рекомендуется использовать только в тех случаях, когда:

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

В остальных случаях лучше подойдёт вариант с возвратом ошибки.

Простой пример проверки соответствия (который можно скопировать и поломать):

Общая информация

• Немного общих сведений о регулярных выражениях в Golang (regexp пакет):
• синтаксис RE2 (библиотека регулярок от Google);
• кодировка UTF-8 и классы символов Unicode;
• время выполнения линейно зависимо от размера ввода;
• обратные ссылки не поддерживаются (не думайте об этом, просто положите на полочку в своих «чертогах разума», чуть позже будет объяснение);
• для регулярных выражений лучше использовать (аккуратно, ведь там своя специфика) необработанные строки (raw strings, строки без интерпретации экранированных литералов).

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

Простые совпадения

Простые совпадения не несут в себе никакого тайного смысла. Что написано – то и ищем.

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

• MatchString (проверяет, есть ли в строке вхождения регулярного выражения);
• FindAllString (ищет все последовательные непересекающиеся повторения в
  строке).

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

Совпадение не полное, в последнем слове лишняя «t».

«Banana» полностью совпадает со строкой.

«сat» встречается в строке.

Находятся два вхождения.

Якори границ

Якори границ позволяют нам делить текст на отдельные слова, явно задавать привязку к началу или концу строки/текста.

Ищем текст, начинающийся с «I am here», но есть пробел перед «I» – не подходит.

Ищем строку, состоящую только из кота — но он в середине.

Ищем кота отдельным словом — находим.

Ищем что-то, заканчивающееся котом — находим.

Классы символов (воин, маг, лучник)

Классы — это краткая запись перечисления символов, объединённых по какому-либо признаку. Также можно использовать posix классы ([:digit:], [:space:], etc.), если так удобней.

Ищем вхождение пяти любых символов.

Ищем вхождения сочетаний: «ow<цифра><конец слова>» через два символа слова с начала строки, любой символ, затем две НЕ цифры, затем снова «ow», цифра, конец.

Ищем начало текста, три любых символа, «@_», два символа слова, «D», конец.

Ищем начало текста, «GO», один пробельный символ, одну цифру, любой символ, две цифры, конец.

Специальные символы и escape

Что нужно знать про специальные символы:

• список спецсимволов: ^ $ * + ? { } [ ] \ | ( )
• их нужно экранировать с помощью `\`, т.е.  `\+` = просто +

Ищем «I» в начале текста, перенос, «am», перенос, «here», конец текста.

Ищем «I» (в виде 16-ричного кода символа), в начале текста, перенос, «am», перенос, «here», конец текста.

Ищем… не «a+b=c», а одно и более повторение «a», «b=c», ибо «+» не экранирован.

Ищем «a|b=c», символ «|» экранирован, всё в порядке.

Повторение (жабное, не жабное)

Повторения являются, пожалуй, одной из важнейших фич при работе с регулярными выражениями. Как минимум, из-за того, что дают возможность исключать некоторые подвыражения из обязательных (при использовании?). ЖаБным оно стало в связи со случайной опечаткой и осознанием, что так запоминается лучше.

Ищем все вхождения чисел из одной и более цифр.

Ищем начало текста, одно повторение «А», от одного до 3 повторений «G», одно и более повторение «А», от 0 до 2 повторений «!».

Пытаемся найти все вхождения тегов — из-за жадного повторения получаем весь текст как первое вхождение, ибо весь текст также соответствует выражению <.*> — начинается скобкой, дальше имеет 0 и более любых символов, заканчивается скобкой.

Пытаемся найти все вхождения тегов, используя не жадное повторение — происходит магия, все срабатывает.

Квадратные скобки, ИЛИ и НЕ

Квадратные скобки эквивалентны перечислению (перечислению с отрицанием при использовании ^). Прямая черта | равнозначна набору альтернативных вариантов из слов. Крышечкой ^ обозначается отрицание при использовании внутри квадратных скобок.

Ищем либо «good», либо «bad», либо один символ в конце текста, не являющийся пробельным, «i», «c» или «e».

Ищем начало текста, ноль или более (лучше меньше, не жадное повторение) символов из перечня [a, A , u , U , f ,F], «go» или «python», пробел, от одной до трех цифр, точку, одну цифру и конец текста).

Ищем начало текста, один и более символов из перечня [h, a, H, A], конец текста.

Ищем начало текста, один и более символов из перечня [h, a, H, A] либо ноль и более символов из перечня [g, o, G, O], конец текста – пустая строка соответствует второму варианту после прямой черты.

Группы

Важное о группах:

• позволяют поместить часть совпадения в отдельный массив;
• квантификатор после скобок группы применяется ко всей группе (под квантификаторами подразумеваются такие товарищи, как: +, *, {min, max}, etc.);
• группа 0 всегда относится ко всему выражению;
• группа 1 — к подвыражению, начинающемуся с “(“ и заканчивающемуся “)”  (и так далее);
• при повторении группы в качестве «группы 1» берется последнее совпадение.

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

Тема групп совсем не проста, поэтому пробуйте разное, ломайте, дебажьте.

Ищем все подсовпадения с выражением «любой символ, одна и более цифра», находим три вхождения, в каждом из которых есть группа 0 – всё вхождение целиком – и группа 1 – часть с «одна и более цифра».

Выделяем год, месяц и день в отдельные группы, ищем (4 цифры), тире, (2 цифры), тире, (2 цифры).  Получаем одно подсовпадение, где группа 0 — вся дата, группа 1 — год, группа 2 — месяц, группа 3 — день.

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

Как ни странно, в группе может быть внутренняя подгруппа (а в ней ещё одна…и ещё…). Здесь мы ищем ноль и более (лучше меньше) любых символов, одно и более повторение символа из перечня [a-zA-Z\-0-9], слэш, любой символ, 2 и более повторения символов из перечня [a-zA-Z]. В итоге находим одно вхождение, где группа 0 – все выражение, группа 1, как внешняя, целиком соответствует части «одно и более повторение символа из перечня [a-zA-Z\-0-9], слэш, любой символ, 2 и более повторения символов из перечня [a-zA-Z]», а группа 2 – части «одно и более повторение символа из перечня [a-zA-Z\-0-9]».

Вспоминается мем (в нём, кстати, есть мааленькая опечатка :), кто отыщет?):

С группами, как и с математическим анализом, нужно сесть, поплакать, хорошо разобраться один раз и работать на автомате в дальнейшем…

Именованные и необязательные группы

Еще один факт о регулярных выражениях в Golang:

• обратных ссылок тут нет (!) (запоминание встретившейся группы для повторного использования в том же выражении).

Иногда этот факт вызывает головную боль.

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

Пытаемся выловить из мусорного текста дату, разделив её на год, месяц, день. В группу Year попадают первые 4 цифры до тире, группу Month — 2 цифры до следующего тире, Day — последние 2 цифры. Доступ к разделенным по названиям групп подсовпадениям получаем при помощи прохождения по re.SubexpNames()

Ищем go либо Go (группа, которая не попадает в список подсовпадений благодаря ?: после открывающей скобки группы), py либо Py — находим два подсовпадения, где группа 0 — вхождение целиком, группа 1 – вторая группа
(которая «py либо Py»).

Другие функции для работы с регулярными выражениями

Формула функций работы с регулярными выражениями:

Также рассмотрим несколько иных функций на примерах.

Дальше будет сложно. Слабонервным рекомендуется закрыть статью, отойти от экранов и уехать жить в Лондон (почему бы и нет).

Большие примеры с кейсами применения регулярных выражений

Валидация логина:

Фильтрация трафика syslog (привет работающим с logstash и его фильтрами):

Парсинг имен таблиц и баз данных, к которым идет обращение, из SELECT SQL-запроса:

Маленькое заключение

Регулярные выражения — достаточно полезная штука при анализе текста, парсинге потокаданных, когда необходимо вытащить оттуда нечто действительно важное…ну и вообще для всякого рода магии ?

Разбирайтесь, не бойтесь экспериментировать и развлекайтесь!

• Регулярные выражения в Python работают через модуль re — достаточно одного import re для начала работы • re.match() ищет совпадение только в начале строки, re.search() — по всей строке, re.findall() — возвращает все совпадения • Метасимволы \d, \w, \s и квантификаторы *, +, ? позволяют описать практически любой текстовый шаблон • re.compile() экономит ресурсы при многократном использовании одного и того же шаблона • Группировка через круглые скобки () позволяет извлекать конкретные части совпадения — например, домен из email или год из даты

Примечание Вы читаете улучшенную версию некогда выпущенной нами статьи.

1. Основы регулярных выражений
2. Регулярные выражения в Python
3. Задачи

Основы регулярных выражений

Регулярками в Python называются шаблоны, которые используются для поиска соответствующего фрагмента текста и сопоставления символов.

Грубо говоря, у нас есть input-поле, в которое должен вводиться email-адрес. Но пока мы не зададим проверку валидности введённого email-адреса, в этой строке может оказаться совершенно любой набор символов, а нам это не нужно.

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

По сути, наш шаблон — это набор символов, который проверяет строку на соответствие заданному правилу. Давайте разберёмся, как это работает.

Синтаксис RegEx

Синтаксис у регулярок необычный. Символы могут быть как буквами или цифрами, так и метасимволами, которые задают шаблон строки:

Также есть дополнительные конструкции, которые позволяют сокращать регулярные выражения:

• \d — соответствует любой одной цифре и заменяет собой выражение [0-9];
• \D — исключает все цифры и заменяет [^0-9];
• \w — заменяет любую цифру, букву, а также знак нижнего подчёркивания;
• \W — любой символ кроме латиницы, цифр или нижнего подчёркивания;
• \s — соответствует любому пробельному символу;
• \S — описывает любой непробельный символ.

Для чего используются регулярные выражения

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

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

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

Хотите узнать больше? Обратите внимание на статью о регулярках для новичков.

Регулярные выражения в Python

В Python для работы с регулярками есть модуль re. Его нужно просто импортировать:

А вот наиболее популярные методы, которые предоставляет модуль:

• re.match()
• re.search()
• re.findall()
• re.split()
• re.sub()
• re.compile()

Рассмотрим каждый из них подробнее.

re.match(pattern, string)

Этот метод ищет по заданному шаблону в начале строки. Например, если мы вызовем метод match() на строке «AV Analytics AV» с шаблоном «AV», то он завершится успешно. Но если мы будем искать «Analytics», то результат будет отрицательный:

Искомая подстрока найдена. Чтобы вывести её содержимое, применим метод group() (мы используем «r» перед строкой шаблона, чтобы показать, что это «сырая» строка в Python):

Теперь попробуем найти «Analytics» в данной строке. Поскольку строка начинается на «AV», метод вернет None:

Также есть методы start() и end() для того, чтобы узнать начальную и конечную позицию найденной строки.

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

re.search(pattern, string)

Метод похож на match(), но ищет не только в начале строки. В отличие от предыдущего, search() вернёт объект, если мы попытаемся найти «Analytics»:

Метод search() ищет по всей строке, но возвращает только первое найденное совпадение.

re.findall(pattern, string)

Возвращает список всех найденных совпадений. У метода findall() нет ограничений на поиск в начале или конце строки. Если мы будем искать «AV» в нашей строке, он вернет все вхождения «AV». Для поиска рекомендуется использовать именно findall(), так как он может работать и как re.search(), и как re.match().

re.split(pattern, string, [maxsplit=0])

Этот метод разделяет строку по заданному шаблону.

В примере мы разделили слово «Analytics» по букве «y». Метод split() принимает также аргумент maxsplit со значением по умолчанию, равным 0. В данном случае он разделит строку столько раз, сколько возможно, но если указать этот аргумент, то разделение будет произведено не более указанного количества раз. Давайте посмотрим на примеры Python RegEx:

Мы установили параметр maxsplit равным 1, и в результате строка была разделена на две части вместо трех.

re.sub(pattern, repl, string)

Ищет шаблон в строке и заменяет его на указанную подстроку. Если шаблон не найден, строка остается неизменной.

re.compile(pattern, repl, string)

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

До сих пор мы рассматривали поиск определенной последовательности символов. Но что, если у нас нет определенного шаблона, и нам надо вернуть набор символов из строки, отвечающий определенным правилам? Такая задача часто стоит при извлечении информации из строк. Это можно сделать, написав выражение с использованием специальных символов. Вот наиболее часто используемые из них:

Больше информации по специальным символам можно найти в документации для регулярных выражений в Python 3.

Перейдём к практическому применению Python регулярных выражений и рассмотрим примеры.

Задачи

Вернуть первое слово из строки

Сначала попробуем вытащить каждый символ (используя .)

Для того, чтобы в конечный результат не попал пробел, используем вместо . \w.

Теперь попробуем достать каждое слово (используя * или +)

И снова в результат попали пробелы, так как * означает «ноль или более символов». Для того, чтобы их убрать, используем +:

Теперь вытащим первое слово, используя ^:

Если мы используем $ вместо ^, то мы получим последнее слово, а не первое:

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

Вариант 1: используя \w, вытащить два последовательных символа, кроме пробельных, из каждого слова:

Вариант 2: вытащить два последовательных символа, используя символ границы слова (\b):

Вернуть домены из списка email-адресов

Сначала вернём все символы после «@»:

Как видим, части «.com», «.in» и т. д. не попали в результат. Изменим наш код:

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

Извлечь дату из строки

Используем \d для извлечения цифр.

Для извлечения только года нам опять помогут скобки:

Извлечь слова, начинающиеся на гласную

Для начала вернем все слова:

А теперь — только те, которые начинаются на определенные буквы (используя []):

Выше мы видим обрезанные слова «argest» и «ommunity». Для того, чтобы убрать их, используем \b для обозначения границы слова:

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

В результат попали слова, «начинающиеся» с пробела. Уберем их, включив пробел в диапазон в квадратных скобках:

Проверить формат телефонного номера

Номер должен быть длиной 10 знаков и начинаться с 8 или 9. Есть список телефонных номеров, и нужно проверить их, используя регулярки в Python:

Разбить строку по нескольким разделителям

Возможное решение:

Также мы можем использовать метод re.sub() для замены всех разделителей пробелами:

Извлечь информацию из html-файла

Допустим, нужно извлечь информацию из html-файла, заключенную между <td> и </td>, кроме первого столбца с номером. Также будем считать, что html-код содержится в строке.

Пример содержимого html-файла:

С помощью регулярных выражений в Python это можно решить так (если поместить содержимое файла в переменную test_str):

Часто задаваемые вопросы

Что такое регулярные выражения в Python?

Регулярные выражения (Regular Expressions, RegEx) — это специальный язык шаблонов для поиска, сопоставления и замены текста. В Python для работы с ними используется встроенный модуль re, который предоставляет функции match, search, findall, sub и другие. Регулярки применяются для валидации данных, парсинга логов, извлечения информации из строк и многих других задач обработки текста.

Чем отличается re.match() от re.search()?

re.match() ищет совпадение с шаблоном только в начале строки. Если шаблон не найден в самом начале — возвращается None, даже если совпадение есть дальше. re.search() просматривает всю строку и возвращает первое найденное совпадение в любой позиции. Для поиска всех вхождений используйте re.findall().

Как проверить email с помощью регулярного выражения?

Базовый шаблон для проверки email выглядит так: r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)+$'. Он проверяет наличие символов до @, доменного имени и хотя бы одной точки с доменной зоной после неё. Для продакшен-валидации рекомендуется дополнительно проверять длину и использовать специализированные библиотеки, так как полная спецификация email-адресов значительно сложнее.

Какие самые полезные спецсимволы в регулярках?

Наиболее используемые спецсимволы: \d (любая цифра), \w (буква, цифра или подчёркивание), \s (пробельный символ), . (любой символ кроме переноса строки). Квантификаторы + (один или более), * (ноль или более) и ? (ноль или один) управляют количеством повторений. Символы ^ и $ обозначают начало и конец строки, а квадратные скобки [] задают набор допустимых символов.

1. Шпаргалка по основам Python
2. Регулярные выражения в Python
3. Шпаргалка по pandas
4. Шпаргалка по Django
5. Виртуальное окружение Python

Шпаргалка по основам Python

Здесь собраны переменные, методы, индексы и срезы, а также форматирование дат с соответствующими подсказками в сносках. Если вы только начали изучать программирование на языке Python, смело обращайтесь к этой шпаргалке:

Регулярные выражения в Python

Шпаргалка собрала большое количество информации о регулярках, включая:

• специальные символы;
• объекты Match;
• методы модуля re;
• escape-символы;
• Raw String Notation;
• расширения;
• объекты;
• флаги;
• ссылки на документацию: Regular Expression HOWTO и Regular expression operations.

Шпаргалка по pandas

Эта библиотека для анализа данных прекрасно себя зарекомендовала в Data Science. Такая шпаргалка поможет в построении различных диаграмм с использованием pandas:

Шпаргалка по Django

Будет полезна тем, кто желает освоить веб-разработку на Python. Здесь вы найдёте базовую информацию по работе с фреймворком — от его установки и до операций с Git:

Виртуальное окружение Python

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

• Регулярные выражения (RegExp) — язык шаблонов для поиска, валидации и замены текста • Базовые элементы: символьные классы (\d, \w, \s), наборы [abc], диапазоны [a-z] и квантификаторы (+, *, ?, {n,m}) • Скобочные группы позволяют запоминать совпадения и ссылаться на них через \1, \2 • Три режима квантификации: жадный (по умолчанию), ленивый (*?) и ревнивый (*+)

Давайте разберёмся, что же собой представляют регулярные выражения. Если вам когда-нибудь приходилось работать с командной строкой, вы, вероятно, использовали маски имён файлов. Например, чтобы удалить все файлы в текущей директории, которые начинаются с буквы "d", можно написать rm d*.

Регулярные выражения представляют собой похожий, но гораздо более сильный инструмент для поиска строк, проверки их на соответствие какому-либо шаблону и другой подобной работы. Англоязычное название этого инструмента — Regular Expressions или просто RegExp. Строго говоря, регулярные выражения — специальный язык для описания шаблонов строк.

Реализация этого инструмента различается в разных языках программирования, хоть и не сильно. В данной статье мы будем ориентироваться в первую очередь на реализацию Perl Compatible Regular Expressions.

Основы синтаксиса

В первую очередь стоит заметить, что любая строка сама по себе является регулярным выражением. Так, выражению Хаха, очевидно, будет соответствовать строка "Хаха" и только она. Регулярки являются регистрозависимыми, поэтому строка "хаха" (с маленькой буквы) уже не будет соответствовать выражению выше.

Однако уже здесь следует быть аккуратным — как и любой язык, регекспы имеют спецсимволы, которые нужно экранировать. Вот их список: . ^ $ * + ? { } [ ] \\ | ( ). Экранирование осуществляется обычным способом — добавлением \\ перед спецсимволом.

Набор символов

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

Здесь нам на помощь придут наборы — вместо указания конкретного символа, мы можем записать целый список, и если в исследуемой строке на указанном месте будет стоять любой из перечисленных символов, строка будет считаться подходящей. Наборы записываются в квадратных скобках — паттерну [abcd] будет соответствовать любой из символов "a", "b", "c" или "d".

Внутри набора большая часть спецсимволов не нуждается в экранировании, однако использование \\ перед ними не будет считаться ошибкой. По прежнему необходимо экранировать символы "\\" и "^", и, желательно, "]" (так, [][] обозначает любой из символов "]" или «[», тогда как [[]х] — исключительно последовательность "[х]"). Необычное на первый взгляд поведение регулярок с символом "]" на самом деле определяется известными правилами, но гораздо легче просто экранировать этот символ, чем их запоминать. Кроме этого, экранировать нужно символ «-», он используется для задания диапазонов (см. ниже).

Если сразу после [ записать символ ^, то набор приобретёт обратный смысл — подходящим будет считаться любой символ кроме указанных. Так, паттерну [^xyz] соответствует любой символ, кроме, собственно, "x", "y" или "z".

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

Предопределённые классы символов

Для некоторых наборов, которые используются достаточно часто, существуют специальные шаблоны. Так, для описания любого пробельного символа (пробел, табуляция, перенос строки) используется \\s, для цифр — \\d, для символов латиницы, цифр и подчёркивания "_" — \\w.

Если необходимо описать вообще любой символ, для этого используется точка — .. Если указанные классы написать с заглавной буквы (\\S, \\D, \\W) то они поменяют свой смысл на противоположный — любой непробельный символ, любой символ, который не является цифрой, и любой символ кроме латиницы, цифр или подчёркивания соответственно.

Также с помощью регулярных выражений есть возможность проверить положение строки относительно остального текста. Выражение \\b обозначает границу слова, \\B — не границу слова, ^ — начало текста, а $ — конец. Так, по паттерну \\bJava\\b в строке "Java and JavaScript" найдутся первые 4 символа, а по паттерну \\bJava\\B — символы c 10-го по 13-й (в составе слова "JavaScript").

Диапазоны

У вас может возникнуть необходимость обозначить набор, в который входят буквы, например, от "б" до "ф". Вместо того, чтобы писать [бвгдежзиклмнопрстуф] можно воспользоваться механизмом диапазонов и написать [б-ф]. Так, паттерну x[0-8A-F][0-8A-F] соответствует строка "xA6", но не соответствует "xb9" (во-первых, из-за того, что в диапазоне указаны только заглавные буквы, во-вторых, из-за того, что 9 не входит в промежуток 0-8).

Механизм диапазонов особенно актуален для русского языка, ведь для него нет конструкции, аналогичной \\w. Чтобы обозначить все буквы русского алфавита, можно использовать паттерн [а-яА-ЯёЁ]. Обратите внимание, что буква "ё" не включается в общий диапазон букв, и её нужно указывать отдельно.

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

Вернёмся к нашему примеру. Что, если в "смеющемся" междометии будет больше одной гласной между буквами "х", например "Хаахаааа"? Наша старая регулярка уже не сможет нам помочь. Здесь нам придётся воспользоваться квантификаторами.

Обратите внимание, что квантификатор применяется только к символу, который стоит перед ним.

Некоторые часто используемые конструкции получили в языке RegEx специальные обозначения:

Таким образом, с помощью квантификаторов мы можем улучшить наш шаблон для междометий до [Хх][аоеи]+х[аоеи]*, и он сможет распознавать строки "Хааха", "хееееех" и "Хихии".

Ленивая квантификация

Предположим, перед нами стоит задача — найти все HTML-теги в строке

Очевидное решение <.*> здесь не сработает — оно найдёт всю строку целиком, т.к. она начинается с тега абзаца и им же заканчивается. То есть содержимым тега будет считаться строка

Это происходит из-за того, что по умолчанию квантификатор работают по т.н. жадному алгоритму — старается вернуть как можно более длинную строку, соответствующую условию. Решить проблему можно двумя способами. Первый — использовать выражение <[^>]*>, которое запретит считать содержимым тега правую угловую скобку. Второй — объявить квантификатор не жадным, а ленивым. Делается это с помощью добавления справа к квантификатору символа ?. Т.е. для поиска всех тегов выражение обратится в <.*?>.

Ревнивая квантификация

Иногда для увеличения скорости поиска (особенно в тех случаях, когда строка не соответствует регулярному выражению) можно использовать запрет алгоритму возвращаться к предыдущим шагам поиска для того, чтобы найти возможные соответствия для оставшейся части RegExp. Это называется ревнивой квантификацией. Квантификатор делается ревнивым с помощью добавления к нему справа символа +. Ещё одно применение ревнивой квантификации — исключение нежелательных совпадений. Так, паттерну ab*+a в строке "ababa" будут соответствовать только первые три символа, но не символы с третьего по пятый, т.к. символ "a", который стоит на третьей позиции, уже был использован для первого результата.

Чуть больше о жадном, сверхжадном и ленивом режимах квантификации вы сможете узнать из статьи о регулярных выражениях в Java.

Скобочные группы

Для нашего шаблона "смеющегося" междометия осталась самая малость — учесть, что буква "х" может встречаться более одного раза, например "Хахахахааахахооо", а может и вовсе заканчиваться на букве "х". Вероятно, здесь нужно применить квантификатор для группы [аиое]+х, но если мы просто напишем [аиое]х+, то квантификатор + будет относиться только к символу "х", а не ко всему выражению. Чтобы это исправить, выражение нужно взять в круглые скобки: ([аиое]х)+.

Таким образом, наше выражение превращается в [Хх]([аиое]х?)+ — сначала идёт заглавная или строчная "х", а потом произвольное ненулевое количество гласных, которые (возможно, но не обязательно) перемежаются одиночными строчными "х". Однако это выражение решает проблему лишь частично — под это выражение попадут и такие строки, как, например, "хихахех" — кто-то может быть так и смеётся, но допущение весьма сомнительное. Очевидно, мы можем использовать набор из всех гласных лишь единожды, а потом должны как-то опираться на результат первого поиска. Но как?…

Запоминание результата поиска по группе

Оказывается, результат поиска по скобочной группе записывается в отдельную ячейку памяти, доступ к которой доступен для использования в последующих частях регэкспа. Возвращаясь к задаче с поиском HTML-тегов на странице, нам может понадобиться не только найти теги, но и узнать их название. В этом нам может помочь регулярное выражение <(.*?)>.

Результат поиска по всему регексу: "", "", "", "", "", "".
Результат поиска по первой группе: "p", "b", "/b", "i", "/i", "/i", "/p".

На результат поиска по группе можно ссылаться с помощью выражения \\n, где n — цифра от 1 до 9. Например выражению (\\w)(\\w)\\1\\2 соответствуют строки "aaaa", "abab", но не соответствует "aabb".

Если выражение берётся в скобки только для применения к ней квантификатора (не планируется запоминать результат поиска по этой группе), то сразу после первой скобки стоит добавить ?:, например (?:[abcd]+\\w).

С использованием этого механизма мы можем переписать наше выражение к виду [Хх]([аоие])х?(?:\\1х?)*.

Перечисление

Чтобы проверить, удовлетворяет ли строка хотя бы одному из шаблонов, можно воспользоваться аналогом булевого оператора OR, который записывается с помощью символа |. Так, под шаблон Анна|Одиночество попадают строки "Анна" и "Одиночество" соответственно. Особенно удобно использовать перечисления внутри скобочных групп. Так, например (?:a|b|c|d) полностью эквивалентно [abcd] (в данном случае второй вариант предпочтительнее в силу производительности и читаемости).

С помощью этого оператора мы сможем добавить к нашему регулярному выражению для поиска междометий возможность распознавать смех вида "Ахахаах" — единственной усмешке, которая начинается с гласной: [Хх]([аоие])х?(?:\\1х?)*|[Аа]х?(?:ах?)+

Полезные сервисы

Потренироваться и/или проверить регулярное выражение на каком-либо тексте без написания кода можно с помощью таких сервисов, как RegExr, Regexpal или Regex101. Последний вдобавок приводит краткие пояснения к тому, как работает регулярка.

Разобраться, как работает регулярное выражение, которое попало к вам в руки, можно с помощью сервиса Regexper — он умеет строить понятные диаграмы по регуляркам.

RegExp Builder — визуальный конструктор функций JavaScript для работы с регулярными выражениями.

Больше инструментов можно найти в нашей подборке.

Задания для закрепления

Найдите время

Время имеет формат часы:минуты. И часы, и минуты состоят из двух цифр, пример: 09:00. Напишите RegEx выражение для поиска времени в строке: "Завтрак в 09:00". Учтите, что "37:98" — некорректное время.

Java[^script]

Найдет ли регулярка Java[^script] что-нибудь в строке Java? А в строке JavaScript?

Цвет

Напишите регулярное выражение для поиска HTML-цвета, заданного как #ABCDEF, то есть # и содержит затем 6 шестнадцатеричных символов.

Разобрать арифметическое выражение

Арифметическое выражение состоит из двух чисел и операции между ними, например:

• 1 + 2
• 1.2 *3.4
• -3/ -6
• -2-2

Список операций: "+", «-», "*" и "/".

Также могут присутствовать пробелы вокруг оператора и чисел.

Напишите регулярку, которая найдёт, как всё арифметическое действие, так и (через группы) два операнда.

Кроссворды из регулярных выражений

Такие кроссворды вы можете найти у нас.

Часто задаваемые вопросы

Чем регулярные выражения отличаются от обычного поиска по строке?

Обычный поиск ищет точное совпадение подстроки, тогда как регулярные выражения позволяют описывать шаблоны с переменными частями. Например, RegExp может найти все email-адреса в тексте, все даты определённого формата или все слова, начинающиеся с заглавной буквы — то, что невозможно сделать простым поиском по подстроке.

Какие языки программирования поддерживают RegExp?

Практически все современные языки: Python (модуль re), JavaScript (встроенный объект RegExp), Java (пакет java.util.regex), C# (System.Text.RegularExpressions), PHP (функции preg_*), Go, Ruby, Rust и другие. Синтаксис в большинстве языков основан на стандарте PCRE (Perl Compatible Regular Expressions).

Как проверить регулярное выражение без написания кода?

Используйте онлайн-сервисы: Regex101 подсвечивает совпадения и объясняет каждую часть выражения, RegExr предоставляет интерактивный редактор с подсказками, а Regexper строит наглядные диаграммы. Все инструменты работают прямо в браузере и не требуют установки.

Когда не стоит использовать регулярные выражения?

RegExp не подходят для парсинга вложенных структур (HTML, XML, JSON) — для этого лучше использовать специализированные парсеры. Также не стоит применять регулярки для валидации email по полному стандарту RFC 5322. Если задача решается простым поиском подстроки или методами split/replace — регулярные выражения будут избыточны.

Удачи и помните — не всегда задачу стоит решать именно с помощью регекспов ("У программиста была проблема, которую он начал решать регэкспами. Теперь у него две проблемы"). Иногда лучше, например, написать развёрнутый автомат конечных состояний.

Этот кроссворд был представлен на мероприятии MIT Puzzle Hunt, прошедшем в 2013 году. Для его решения в сети можно найти как минимум две странички с удобным интерфейсом (от Rampion и от Jimbly).

Ещё один кроссворд, на этот раз в более привычном формате.

Regex Crossword — сайт, где представлены целых 10 кроссвордов, которые можно решать, соревнуясь с другими пользователями. Чем еще удобен сайт, так это инструкцией по решению таких задачек.

Если вас заинтересовали регулярные выражения и эти интересные задачки, то вот ещё два ресурса, которые могут вам пригодиться:

• Программа на Python для генерации и решения regex-кроссвордов;
• Сборник различных материалов (от документации и библиотек до статей и книг) для изучения регулярных выражений.

Если же вы нашли ещё какой-то кроссворд или другую задачку, связанную с “регулярками”, делитесь ими в комментариях, и мы добавим их в этот пост!

Как же выглядит e-mail адрес? Интуитивно можно предположить, что так:

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

Конечно, и тут можно обойтись с помощью регулярного выражения:

Но с этим есть несколько проблем:

• Как вы будете проверять правильность этого монстра? Такие регулярные выражения переходят «из уст в уста» на форумах, и каждый добавляет в них функциональность до тех пор, пока работа с выражением становится невозможной. И это именно тот случай.
• Я бы не сказал, что регулярные выражения такой длины эффективнее, чем другие методы. Чем длиннее выражение, тем дольше оно будет компилироваться (сравнение всегда происходит за O(n)).
• С помощью регулярного выражения можно сделать только проверку на соответствие. Выполнить проверку на то, находится ли домен в чёрном списке, у вас уже, увы, не получится.

Давайте пойдём другим путём

Вот основа нашей проверки:

А вот диаграмма, описывающая алгоритм, по которому наша программа будет работать:

Если вы заметили, что тут не все правила соблюдаются — не волнуйтесь, мы вернёмся к этому позже. Если вы не заметили, и вообще не понимаете, что тут происходит, то сейчас объясню.

Вершина графа — состояние проверки. Ребро графа — прочитанный символ. Если в результате считывания символа невозможно перейти ни по одному ребру, значит, адрес не валиден. Вот, например, как будет реализована первая часть этого алгоритма:

Теперь о проверках, которые мы сделаем, после того, как код пройдёт по этой диаграмме:

Собираем всё вместе

Причиной нестабильности сервиса стала повышенная нагрузка на сервера, связанная с обработкой одного из опубликованных вопросов. Дело в том, что публикуемые на Stack Overflow вопросы перед отображением на странице анализируются набором регулярных выражений, в числе которых следующее: ^[\s\u200c]+|[\s\u200c]+$ — оно служит для обрезания пробелов (в том числе в Unicode) с концов строки. И камнем преткновения стал пост, который содержал в середине текста последовательность из 20 000 (!) пробелов.

Вышеупомянутое регулярное выражение обрабатывало такую строку следующим образом: найдя первый пробел, оно переходил к следующему, затем к следующему и т.д. до самого последнего пробела в последовательности. После ожидался конец строки, однако строка из пробелов оказалась в середине поста, поэтому движок конец строки там, естественно, не обнаруживал. Тогда предпринималась попытка найти соответствие в следующей возможной последовательности символов, и движок принимался анализировать ту же строку, начиная со второго пробела, затем переходя к третьему, затем — к четвертому и т.д. до конца. Его поиск, естественно, снова не увенчивался успехом и на очереди оказывалась подстрока, начиная с третьего символа и т.д. В итоге движку пришлось анализировать 20 000 + 19 999 + 19 998 + … + 1 = 199 990 000 символов!

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

Сложность такого действия составляет O(N²) — и хотя, как отмечает автор публикации, это, конечно, не экспоненциальная сложность, но так вышло, что пост-вредитель попал на домашнюю страницу сервиса и вынудил сервера обрабатывать текст регулярным выражением для огромного числа посетителей сервиса, заходящих на него через главную страницу. Это привело к тому, что домашняя страница стала с большими задержками отвечать на запросы. Балансировщик нагрузки Stack Overflow, в свою очередь, оценивает доступность сервиса по доступности домашней страницы, и поэтому воспринял задержку в ответах на запросы как знак того, что работу сервиса необходимо приостановить.

К слову, исправлена ситуация была очень быстро: 10 минут потребовалось на поиск причины, 14 — на написание кода для ее исправления, и 10 — на внедрение фикса.

Они бывают совершенно различных форматов: в виде онлайн-ресурса, плагина к IDE или браузеру или в виде самостоятельной программы. Первые удобны для разового или редкого использования. Хотя некоторые онлайн-тестеры имеют возможность сохранения шаблона в виде постоянной ссылки или в аккаунте, для регулярного использования больше подойдут плагины или десктопные приложения.

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

Онлайн-приложения

regex101.com

Пожалуй, лучший вариант веб-приложения для разработки регулярных выражений. Поддерживает форматы PCRE (PHP), JavaScript и Python. Есть возможность получить постоянную ссылку на ваш код, сгенерировать код для PHP, JavaScript или Python, создать юнит-тесты, запустить регулярку пошагово и воспользоваться большой библиотекой готовых регулярных выражений.

Debuggex

Ограничен по функционалу, не поддерживает замену по шаблону. Но взамен предоставляет визуализацию вашего регулярного выражения в виде конечного автомата, что заметно упрощает понимание работы и отладку. Также, как и regex101.com, поддерживает синтаксис PCRE, JavaScript или Python. Есть платная подписка с расширенными возможностями, такими как оценка производительности или юнит-тесты с просмотром покрытием кода.

RegExr 2.0

Онлайн-тестер с открытым исходным кодом и приятным дизайном. Хотя по функционалу уступает regex101.com — только один вариант синтаксиса, нет генерации кода и тестов — для простых задач его вполне достаточно. В отличие от Debuggex, поддерживает замену по шаблону.

Плагины для IDE

Regex Util (IDEA plugin)

Плагин для IntelliJ IDEA и других IDE от JetBrains. Минималистичный интерфейс, поддержка замен и разделений по шаблону и всплывающие подсказки с объяснением элементов. Нет возможности сохранения регулярных выражений. Отлично подходит для проверки регулярок перед добавлением в код.

Regex Util (Eclipse plugin)

Аналог плагина для IntelliJ IDEA с тем же функционалом.

Десктопные приложения

Expresso

Одна из лучших программ под Windows для написания и проверки регулярных выражений. Огромное количество возможностей: визуальный редактор, генерация кода, библиотека шаблонов. Программа бесплатная, но после 60 дней использования требует регистрации.

The Regex Coach

Для тех, кому Expresso кажется слишком сложным. Маленькая утилита с возможностью пошагового выполнения регулярного выражения. Поддерживает синтаксис PCRE, который используется в Perl, PHP и очень похож на синтаксис регулярных выражений Java и XML Schema. Программа примечательна тем, что написана на Common Lisp.

Regexbuddy

Достойный конкурент Expresso с большой библиотекой готовых примеров. Платная ($39.95). Кроме того, на сайте разработчика есть отличные программы PowerGrep (для сложного поиска по текстовым файлам) и RegexMagic (визуальный редактор регулярных выражений).

Oyster

Платная ($3.99) утилита под OS X. Отличная программа с большим количеством возможностей, интеграцией с Dash и CodeBox, генерацией кода на Java, JavaScript, Objective-C, Python и других языках.

Что выбрать?

Если вам необходимо часто писать регулярные выражения для обработки текста или других задач, лучший вариант — самостоятельное приложение вроде Expresso или Oyster. Если задача разовая, или вы хотите просто потренироваться, вам помогут онлайн-приложения, такие как regex101.com. Следует заметить, что список выше далеко не полный, и есть еще много программ, которые помогут вам в вашей работе.

Кроме того, возможно, вашу задачу кто-то уже решил и поделился решением с сообществом. Обратите внимание на regexlib.com и RexEgg.