JavaScript | Класс символа в регулярных выражениях

Вступление

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

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

 

Поиск проблемы. В чём суть?

Посмотрите на строку:

"НужноNeedкупитьtoпродуктыbuyвinмагазинеthe store"

Это две слепленные строки из разных символов двух языков:

• На русском языке — «Нужно купить продукты в магазине«
• На английском языке — «Need to buy groceries in the store«

Задача — Отобрать слова на русском языке в виде строки.

Решение при помощи класса символа:

"НужноNeedкупитьtoпродуктыbuyвinмагазинеthe store".replace(/[^А-яЁё]+/g," ")
"Нужно купить продукты в магазине "

Такое короткое регулярное выражение и такой впечатляющий результат!

Что произошло? Квадратными скобками [ и ] внутри регулярного выражения мы обозначили класс символа. Знак ^ в начале класса символа говорит об отрицании всего что справа от него до закрывающей квадратной скобки. А что у нас справа от ^? Справа мы перечисляем те символы, которые хотим отыскать внутри строки. Мы записали диапазон русских букв А-я, а также русские буквы Ё и ё. То есть мы хотим отыскать все НЕРУССКИЕ символы в строке и заменить их на один пробел.

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

Вот в этом и заключается магия использования класса символа!

 

Теория. Стандарт ECMAScript. Примеры.

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

Atom _{[UnicodeMode, N]} ::

PatternCharacter

.

\ AtomEscape _{[?UnicodeMode, ?N]}

CharacterClass _{[?UnicodeMode]}

( GroupSpecifier _{[?UnicodeMode]} Disjunction _{[?UnicodeMode, ?N]} )

( ? : Disjunction _{[?UnicodeMode, ?N]} )

Скриншот из стандарта:

 

В этой публикации нас интересует четвёртое производство — CharacterClass _{[?UnicodeMode]}

Его дословно можно перевести как Класс Символа. Именно одного символа. Это важно!

 

Производство CharacterClass

В свою очередь производство CharacterClass состоит из двух производств:

CharacterClass _{[UnicodeMode]} ::

[ [lookahead ≠ ^] ClassRanges _{[?UnicodeMode]} ]

[ ^ ClassRanges _{[?UnicodeMode]} ]

Скриншот из стандарта:

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

Оба производства оформляются квадратными скобками. Но есть один нюанс. Второе производство класса символа (CharacterClass) содержит символ ^, который обозначает отрицание. Предлагаю сразу рассмотреть два примера:

// ПРИМЕР № 1

/[аб]/.exec("спорт")

null

Мы получили null из метода exec(), потому что в строке «спорт» не встречается символ, который может быть равен «а» или «б«. Результат выполнения регулярного выражения не нашёл сопоставления внутри строки.

// ПРИМЕР № 2

/[^аб]/.exec("спорт")

На этот раз нам вернулся массив с результатом под нулевым индексом — буква «с«. Это первое сопоставление в строке слева-направо. Мы нашли то место в строке, где НЕ встречается символ, который может быть равен «а» или «б«.

В этих двух примерах мы использовали НЕ ПУСТОЙ диапазон класса из ClassRanges.

Рассмотрим ещё два примера, в которых будем использовать класс символа, с символами из строки:

// ПРИМЕР № 3

[..."спорт".matchAll(/[пт]/g)]

// Результат работы итератора регулярного выражения - массив из массивов

[
   ["п", index: 1, input: "спорт", groups: undefined],
   ["т", index: 4, input: "спорт", groups: undefined]
]

В этом случае мы получили массив, который состоит из двух массивов. Это результат работы объекта итератора регулярного выражения, извлечённого в массив при помощи оператора spread … . В получении итератора нам помог метод matchAll().

Глобальное сопоставление нашего класса символа по всей строке нашло два соответствия. Сначала мы нашли «п» под первым индексом, а потом мы нашли «т» под четвёртым индексом. То есть в каждом случае мы получали какой-то ОДИН символ на выбор, который присутствовал в классе.

// ПРИМЕР № 4

[..."спорт".matchAll(/[^пт]/g)]

// Результат работы итератора регулярного выражения - массив из массивов

[
   ["с", index: 0, input: "спорт", groups: undefined],
   ["о", index: 2, input: "спорт", groups: undefined],
   ["р", index: 3, input: "спорт", groups: undefined]
]

Сопоставление нашло 3 случая, когда в строке «спорт» встречается ОДИН символ, который не равен «п» или «т«.

 

 

Производство ClassRanges

ClassRanges _{[UnicodeMode]} ::

[empty]

NonemptyClassRanges _{[?UnicodeMode]}

Из производства диапазона класса видно, что он может быть всего в двух вариантах: ПУСТОЙ и НЕПУСТОЙ.

ПУСТОЙ диапазон класса

Диапазон класса (ClassRanges) присутствует в двух производствах класса символа (CharacterClass), поэтому мы можем сформировать два примера реализации (два выражения)

// Пример № 5 - Производство CharacterClass БЕЗ отрицания
[..."дом".matchAll(/[]/g)]
[]

В этом примере у нас регулярное выражение пытается сопоставить строку с ПУСТЫМ диапазоном класса для одного символа. Наборы символов не заданы, а значит и сопоставление производится по «НИЧЕМУ» то есть null.

«НИЧЕГО» — это не символ, а значит его точно нет в строке. В результате мы получим пустой массив.

Метод exec() более наглядный для этого результата:

/[]/.exec("дом")
null

 

В примере № 6 мы используем отрицание. То есть НЕ «НИЧЕГО» — то есть «ВСЁ».

//Пример № 6 - Производство CharacterClass С отрицанием
[..."дом".matchAll(/[^]/g)]
[
   ["д", index: 0, input: "дом", groups: undefined],
   ["о", index: 1, input: "дом", groups: undefined],
   ["м", index: 2, input: "дом", groups: undefined]
]

Под «ВСЁ» у нас попадает любой возможный символ. В результате мы видим массив, в котором перечислены все буквы из строки «дом»

НЕПУСТОЙ диапазон класса

В отличии от ПУСТОГО диапазона, НЕПУСТОЙ диапазон класса более насыщенный на производства. В стандарте ECMAScript их три.

 

Производство NonemptyClassRanges

NonemptyClassRanges _{[UnicodeMode]} ::

ClassAtom _{[?UnicodeMode]}

ClassAtom _{[?UnicodeMode]} NonemptyClassRangesNoDash _{[?UnicodeMode]}

ClassAtom _{[?UnicodeMode]} — ClassAtom _{[?UnicodeMode]} ClassRanges _{[?UnicodeMode]}

Скриншот из стандарта:

 

Производство ClassAtom

ClassAtom _{[UnicodeMode]} ::

—

ClassAtomNoDash _{[?UnicodeMode]}

Скриншот из стандарта:

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

 

Случай только с дефисом

[..."окно".matchAll(/[-]/g)]
[]

[..."окно".matchAll(/[^-]/g)]
(4) [Array(1), Array(1), Array(1), Array(1)]

В таком виде это ничем не отличается от ПУСТОГО диапазона класса.

 

Случай с дефисом и одним символом

Попробуем добавить какой-нибудь символ слева от дефиса:

[..."окно".matchAll(/[к-]/g)]

Попробуем добавить какой-нибудь символ справа от дефиса:

[..."окно".matchAll(/[-к]/g)]

Оба варианта ничем не отличаются от обычной дизъюнкции. Дефис в этом случае не отрабатывает никак.

 

Случай с дефисом, одним символом и отрицанием

[..."окно".matchAll(/[^к-]/g)]

[..."окно".matchAll(/[^-к]/g)]

Оба варианта ничем не отличаются от обычной дизъюнкции.

 

 

Случай с дефисом посередине между двух символов

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

[..."абвгдеёжзик".matchAll(/[в-е]/g)]

[..."абвгдеёжзик".matchAll(/[^в-е]/g)]

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

 

 

 

 

Заглавная буква «Ё» находится до основной последовательности русских букв в стандарте Unicode.

Строчная буква «ё» находится после основной последовательности русских букв в стандарте Unicode.

То есть все буквы русского алфавита не идут последовательно в стандарте Unicode.

 

Случай с дефисом и другим классом символа — Не работает в JavaScript

Это редкий пример. В основном им пользуются в именованных классах символа. Но для понимания мы рассмотрим простой пример:

[…»абвгдеёжзиклмнопрст».matchAll(/[г-к-[ёж]]/g)]

 

 

Производство ClassAtomNoDash

ClassAtomNoDash _{[UnicodeMode]} ::

SourceCharacter но не один из \ или ] или —

\ ClassEscape _{[?UnicodeMode]}

Случай с SourceCharacter — это любой символ Unicode, но не один из \ или ] или —. Мы рассмотрели это в самом начале публикации.

 

Альтернативный пример к публикации

Представьте, что у нас есть массив из строк:

["белый", "красный", "угрюмый", "выйди"]

Предположим у нас есть задача: отобрать слова, в которых есть последовательность символов «ый«. Это одно условие можно без проблем поместить в метод filter().

["белый", "красный", "угрюмый", "выйди"].filter(i=>/ый/g.exec(i))
["белый", "красный", "угрюмый", "выйди"]

Так как во всех строках из массива встречается сочетания символов «ый«, то мы обратно получим такой же массив.

Если мы захотим отобрать слова в которых есть последовательности символов «ный» и «мый«, то мы должны будем передать в метод filter() два условия.

["белый", "красный", "угрюмый", "выйди"].filter(i=>/ный|мый/g.exec(i))
["белый", "красный", "угрюмый", "выйди"]

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

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

/ный|мый/

Второй способ — это использование Класса Символа. Позволяет существенно сократить длину записи регулярного выражения и сделать её более читаемой и структурированной.

/[нм]ый/

 

Информационные ссылки

Производство Atom — https://tc39.es/ecma262/#prod-Atom