Node js регулярные выражения. Регулярные выражения в JavaScript. Циклы по вхождениям

The RegExp constructor creates a regular expression object for matching text with a pattern.

For an introduction to regular expressions, read the Regular Expressions chapter in the JavaScript Guide .

The source for this interactive example is stored in a GitHub repository. If you"d like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.

Syntax

Literal, constructor, and factory notations are possible:

/ pattern / flags new RegExp(pattern [, flags ]) RegExp(pattern [, flags ])

Parameters

pattern The text of the regular expression; or as of ES5, another RegExp object or literal (for the two RegExp constructor notations only). Patterns can include so they can match a wider range of values than would a literal string. flags

If specified, flags is a string that contains the flags to add; or if an object is supplied for the pattern, the flags string will replace any of that object"s flags (and lastIndex will be reset to 0) (as of ES2015). If flags is not specified and a regular expressions object is supplied, that object"s flags (and lastIndex value) will be copied over.

flags may contain any combination of the following characters:

G global match; find all matches rather than stopping after the first match. i ignore case; if u flag is also enabled, use Unicode case folding. m multiline; treat beginning and end characters (^ and $) as working over multiple lines (i.e., match the beginning or end of each line (delimited by \n or \r), not only the very beginning or end of the whole input string). s "dotAll"; allows . to match newlines. u Unicode; treat pattern as a sequence of Unicode code points. (See also Binary strings). y sticky; matches only from the index indicated by the lastIndex property of this regular expression in the target string (and does not attempt to match from any later indexes).

Description

There are two ways to create a RegExp object: a literal notation and a constructor .

• The literal notation"s parameters are enclosed between slashes and do not use quotation marks.
• The constructor function"s parameters are not enclosed between slashes, but do use quotation marks.

The following expressions create the same regular expression:

/ab+c/i new RegExp(/ab+c/, "i") // literal notation new RegExp("ab+c", "i") // constructor

The literal notation provides a compilation of the regular expression when the expression is evaluated. Use literal notation when the regular expression will remain constant. For example, if you use literal notation to construct a regular expression used in a loop, the regular expression won"t be recompiled on each iteration.

The constructor of the regular expression object, for example, new RegExp("ab+c") , provides runtime compilation of the regular expression. Use the constructor function when you know the regular expression pattern will be changing, or you don"t know the pattern and are getting it from another source, such as user input.

Starting with ECMAScript 6, new RegExp(/ab+c/, "i") no longer throws a TypeError ("can"t supply flags when constructing one RegExp from another") when the first argument is a RegExp and the second flags argument is present. A new RegExp from the arguments is created instead.

When using the constructor function, the normal string escape rules (preceding special characters with \ when included in a string) are necessary. For example, the following are equivalent:

Let re = /\w+/ let re = new RegExp("\\w+")

Properties

RegExp.prototype Allows the addition of properties to all objects. RegExp.length The value of RegExp.length is 2 . get RegExp[@@species] The constructor function that is used to create derived objects. RegExp.lastIndex The index at which to start the next match.

Methods

The global RegExp object has no methods of its own. However, it does inherit some methods through the prototype chain.

RegExp prototype objects and instances

Properties

Examples

Using a regular expression to change data format

let str = "#foo#" let regex = /foo/y regex.lastIndex = 1 regex.test(str) // true regex.lastIndex = 5 regex.test(str) // false (lastIndex is taken into account with sticky flag) regex.lastIndex // 0 (reset after match failure)

Regular expression and Unicode characters

As mentioned above, \w or \W only matches ASCII based characters; for example, a to z , A to Z , 0 to 9 , and _ .

To match characters from other languages such as Cyrillic or Hebrew, use \uhhhh , where hhhh is the character"s Unicode value in hexadecimal. This example demonstrates how one can separate out Unicode characters from a word.

Let text = "Образец text на русском языке" let regex = /[\u0400-\u04FF]+/g let match = regex.exec(text) console.log(match) // logs "Образец" console.log(regex.lastIndex) // logs "7" let match2 = regex.exec(text) console.log(match2) // logs "на" console.log(regex.lastIndex) // logs "15" // and so on

Extracting sub-domain name from URL

let url = "http://xxx.domain.com" console.log(/[^.]+/.exec(url).substr(7)) // logs "xxx"

Specifications

Specification	Status	Comment
ECMAScript 3rd Edition (ECMA-262)	Standard	Initial definition. Implemented in JavaScript 1.1.
ECMAScript 5.1 (ECMA-262)	Standard
ECMAScript 2015 (6th Edition, ECMA-262) The definition of "RegExp" in that specification.	Standard	The RegExp constructor no longer throws when the first argument is a RegExp and the second argument is present. Introduces Unicode and sticky flags.
ECMAScript Latest Draft (ECMA-262) The definition of "RegExp" in that specification.	Draft

Browser compatibility

The compatibility table on this page is generated from structured data. If you"d like to contribute to the data, please check out https://github.com/mdn/browser-compat-data and send us a pull request.

Регулярные выражения - это язык, который описывает шаблоны строк, основанные на метасимволах. Метасимвол – это символ в регулярном выражении, который описывает некоторый класс символов строки, указывает на положение подстроки, указывает количество повторений или группирует символы в подстроку. Например, метасимвол \d описывает цифры, а $ обозначает конец строки. В регулярном выражении могут присутствовать и обычные символы, которые описывают самих себя. Набор и значение метасимволов в регулярных выражениях описывает стандарт PCRE, большинство возможностей которого поддерживается в JS.

Область применения регулярных выражений

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

• Сопоставление . Целью этой задачи будет выяснить, соответствует ли определённый текст заданному регулярному выражению.
• Поиск . С помощью регулярных выражений удобно находить соответствующие им подстроки и извлекать их из текста.
• Замена . Регулярные выражения часто помогают не только найти, но и заменить в тексте подстроку, соответствующую регулярному выражению.

В конечном счёте при помощи регулярных выражений можно, например:

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

Особенности регулярных выражений в JS. Литералы регулярных выражений

Главной особенностью регулярных выражений в JS является то, что для них существует отдельный вид литералов. Так же как строковые литералы обрамляются кавычками, литералы регулярных выражений обрамляются слешами (/). Таким образом JS-код может содержать выражения вида:

console.log(typeof /tcoder/); // object

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

var pattern = new RegExp("tcoder");

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

Символы в регулярных выражениях

Все алфавитно-цифровые символы в регулярных выражениях не являются метасимволами и описывают самих себя. Это значит, что регулярному выражению /tcoder/ будет соответствовать подстрока tcoder. В регулярных выражениях так же можно указывать не алфавитные символы, такие как: перевод строки (\n), табуляция (\t) и так далее. Все эти символы так же соответствуют сами себе. Поставленный перед алфавитным символом обратный слеш (\) сделает его метасимволом, если такой имеется. Например, алфавитный символ «d» станет метасимволом, описывающим цифры, если его предварить слешем (\d).

Классы символов

Одиночные символы в регулярных выражениях можно группировать в классы при помощи квадратных скобок. Созданному таким образом классу соответствует любой из включённых в него символов. Например, регулярному выражению // будут соответствовать буквы «t», «c», «o», «d», «e», «r».

В классах также можно задавать диапазон символов при помощи дефиса. Например, классу соответствует класс . Заметим, что некоторые метасимволы в регулярных выражениях уже описывают классы символов. Например, метасимвол \d эквивалентен классу . Заметим, что метасимволы, описывающие классы символов, также могут включаться в классы. Например, классу [\da-f] соответствуют цифры и буквы «a», «b», «d», «e», «f», то есть любой шестнадцатеричный символ.

Существует, также, возможность описать класс символов, указав символы, которые не должны в него входить. Делается это при помощи метасимвола ^. Например, классу [^\d] будет соответствовать любой символ кроме цифры.

Повторения

Теперь мы можем описать, скажем, десятичное число любой заданной длины, просто написав подряд столько метасимволов \d, сколько цифр в этом числе. Согласитесь, что такой подход не очень удобен. К тому же, мы не можем описать диапазон необходимого количества повторений. Например, мы не можем описать число из одной или двух цифр. К счастью, в регулярных выражениях существует возможность описывать диапазоны повторений при помощи метасимволов. Для этого после символа достаточно просто указать диапазон повторений в фигурных скобках. Например, регулярному выражению /tco{1, 3}der/ будут соответствовать строки «tcoder», «tcooder» и «tcooоder». Если опустить максимальное количество повторений, оставив запятую и минимальное количество повторений, то можно указать количество повторений больше заданного. Например, регулярному выражению /bo{2,}bs/ будут соответствовать строки «boobs», «booobs», «boooobs» и так далее с любым количеством букв «о» не меньше двух.

Если в фигурных скобках опустить и запятую, просто указав одно число, то оно будет обозначать точное количество повторений. Например, регулярному выражению /\d{5}/ соответствуют пятизначные числа.

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

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

Приведённый выше синтаксис описывает максимальное количество повторений, то есть из всех возможных количеств повторений, количество которых лежит в указанном диапазоне — выбирается максимальное. Такие повторения называют жадными. Это значит, что регулярному выражению /\d+/ в строке yeah!!111 будет соответствовать подcтрока «111», а не «11» или «1», хотя метасимвол «+» описывает одно и более повторений.

Если вы хотите реализовать нежадное повторение, то есть выбирать минимальное возможное количество повторений из указанного диапазона, то просто поставьте символ «?» после диапазона повторений. Например, регулярному выражению /\d+?/ в строке «yeah!!111» будет соответствовать подстрока «1», а регулярному выражению /\d{2,}/ в той же строке будет соответствовать подстрока «11».

Стоит обратить внимание на важную особенность нежадного повторения. Рассмотрим регулярное выражение /bo{2,}?bs/ . В строке «i like big boooobs» ему будет соответствовать, как и при жадном повторении, подстрока boooobs, а не boobs, как можно было подумать. Дело в том, что регулярному выражению при одном сопоставлении не может соответствовать несколько подстрок, расположенных в разных местах строки. То есть, нашему регулярному выражению не могут соответствовать подстроки «boo» и «bs», склеенные в одну строку.

Альтернативы

В регулярных выражениях так же можно использовать альтернативы — описывать множество строк, которое соответствует либо одной, либо другой части регулярного выражения. Такие части и называются альтернативами и разделяются при помощи вертикальной черты. Например, регулярному выражению /two|twice|\2/ может соответствовать либо подстрока «two», либо подстрока «twice», либо подстрока «2». Цепочка альтернатив обрабатывается слева на право до первого совпадения и ей может соответствовать только подстрока, которую описывает только одна альтернатива. Например, регулярному выражению /java|script/ в строке «I like javascript» будет соответствовать только подстрока «java».

Группировки

Чтобы рассматривать несколько символов как единое целое при использовании диапазонов повторений, классов символов и всего прочего, достаточно просто взять их в круглые скобки. Например, регулярному выражению /true(coder)?/ будут соответствовать строки «truecoder» и «true».

Ссылки

Кроме того, что круглые скобки объединяют символы в регулярном выражении в единое целое, на соответствующею им подстроку можно ссылаться, просто указав после слеша номер левой скобки из пары обрамляющих его скобок. Скобки нумеруются с лева на право начиная с единицы. Например, в регулярном выражении /(one(two)(three))(four)/ \1 ссылается на one, \2 на «two», \3 на «three», \4 на «four». В качестве примера использования таких ссылок приведём регулярное выражение /(\d)\1/ , которому соответствуют двухзначные числа с одинаковыми цифрами. Важным ограничением использования обратных ссылок является невозможность их использования в классах, то есть, например, описать двухзначное число с различными цифрами регулярным выражением /(\d)[^\1]/ нельзя.

Незапоминающие скобки

Часто бывает необходимо просто сгруппировать символы, но нет необходимости создавать ссылку. В этом случае можно сразу после левой группирующей скобки можно написать?:. Например, в регулярном выражении /(one)(?:two)(three)/ \2 будет указывать на «three».

Такие скобки иногда называют незапоминающими. Они имеют ещё одну важную особенность, о которой мы поговорим в следующем уроке.

Указание позиции

В регулярных выражениях так же существуют метасимволы, которые указывают на некоторую позицию в строке. Чаще всех остальных используются символы ^, $ указывающие на начало и конец строки. Например, регулярному выражению /\..+$/ будут соответствовать расширения в названиях файлов, а регулярному выражению /^\d/ первая цифра в строке, если она есть.

Позитивная и негативная опережающие проверки

При помощи регулярных выражений так же можно описать подстроку, за которой следует или не следует подстрока, описанная другим шаблоном. Например, нам необходимо найти слово java только если за ним следует «script». Эту задачу можно решить при помощи регулярного выражения /java(?=script)/ . Если же нам нужно описать подстроку «java» за которой не следует script можно воспользоваться регулярным выражением /java(?!script)/ .

Соберём всё то, о чём мы говорили выше в одну табличку.

Символ	Значение
a|b	Соответствует либо а, либо и.
(…)	Группирующие скобки. Так же на подстроку, соотвествующую шаблону в скобках можно ссылаться.
(?:…)	Только группировка, без возможности ссылаться.
\n	Ссылка на подстроку, соответствующею n-ому шаблону.
^	Начало входных данных или начало строки.
$	Конец входных данных или конец строки.
a(?=b)	Соответствует подстроке, которую описывает шаблон a, только если за ней следует подстрока, описанная шаблоном b.
a(?!b)	Соответствует подстроке, которую описывает шаблон a, только если за ней не следует подстрока, описанная шаблоном b.

Флаги

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

В JavaScript существуют всего три флага регулярных выражений:

i – при указании этого флага регистр не учитывается, то есть, например, регулярному выражению \javascript\i будут соответствовать строки «javascript», «JavaScript», «JAVASCRIPT», «jAvAScript» и т.д.

m – этот флаг включает многострочный поиск. Это значит, что если в тексте есть символы перевода строк и этот флаг поставлен, то символы ^ и $ кроме начала и конца всего текста будут соответствовать так же ещё началу и концу каждой строки в тексте. Например, регулярному выражению /line$/m соответствует подстрока «line», как в строке «first line», так и в строке «one\nsecond line\ntwo».

g – включает глобальный поиск, то есть регулярному выражению, если этот флаг включен, будут соответствовать все совпавшие с ним подстроки, а не только первая, как в случае, если этого флага нет.

Флаги можно комбинировать между собой в произвольном порядке, то есть \tcoder\mig , \tcоder\gim , \tocder\gmi и т.д., это одно и тоже. Порядок флагов так же не имеет значения, если их передавать в строке в качестве второго аргумента конструктору объекта RegExp , то есть new RegExp(«tcoder», «im») и new RegExp(«tcoder», «im») так же одно и тоже.

З.Ы.

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

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

Когда вам нужно что-то найти в каком-то тексте, то для описания того, что вы ищите, и используется шаблон поиска.

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

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

Синтаксис:

/шаблон/модификаторы;

Var patt = /msiter/i;

Объяснение примера:

• /msiter/i - регулярное выражение.
• msiter – шаблон, используемый в операции поиска.
• i - модификатор (определяет, что поиск должен быть регистронезависимым).

Использование методов строки

В JavaScript регулярные выражения часто используют в двух методах строки: search() и replace() .

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

Метод replace() возвращает измененную строку, где произведена замена шаблона.

Метод search() с регулярным выражением

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

Var str = "Посетите сайт MSiter"; var n = str.search(/msiter/i);

В результате в переменную n будет возвращено 14.

Метод search() со строкой

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

В следующем примере для поиска используется строка "MSiter":

Var str = "Посетите сайт MSiter!"; var n = str.search("MSiter");

Метод replace() с регулярным выражением

В следующем примере, чтобы заменить подстроку "Microsoft" на "Msiter" без учета регистра, используется регулярное выражение:

Var str = "Посетите сайт Microsoft!"; var res = str.replace(/microsoft/i, "MSiter");

В результате в переменной res будет строка "Посетите сайт MSiter!".

Метод replace() со строкой

Метод replace() в качестве параметра также может принимать строку:

Var str = "Посетите сайт Microsoft!"; var res = str.replace("Microsoft", "MSiter");

А вы заметили, что

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

Модификаторы регулярного выражения

Модификаторы позволяют расширить область поиска:

Шаблоны регулярных выражений

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

Метасимволы - это символы со специальным значением:

Квантификаторы определяют количество повторений:

Объект RegExp

В JavaScript объект RegExp - это объект регулярного выражения с предопределенными свойствами и методами.

Метод test()

Метод test() объекта RegExp используется для поиска шаблона в заданной строке. В зависимости от результата он возвращает true или false.

Var patt = /e/; patt.test("The best things in life are free!");

Так как в этом примере строка содержит символ "e", результат будет true.

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

/e/.test("The best things in life are free!");

Метод exec()

Метод exec() объекта RegExp используется для поиска шаблона в заданной строке. Он возвращает найденный текст. Если ничего не было найдено, то возвращается null.

В следующем примере в строке ищется символ "e":

/e/.exec("The best things in life are free!");

Так как в этом примере строка содержит символ "e", результат будет - e.

В этой статье рассмотрены основы применения регулярного выражения в Javascript .

Введение

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

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

В Javascript регулярные выражения также являются объектами. Это шаблоны, использующиеся для сопоставления последовательностей символов в строках. Они используются в методах exec() и test() объекта RegExp , а также в методах match() , replace() , search и split() объекта String .

Пример

var pattern = /example/i

/example/i – это регулярное выражение. example – это шаблон (который будет использоваться в поиске ). i – это модификатор, указывающий на чувствительность к регистру.

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

JS регулярные выражения состоят из шаблона и модификатора. Синтаксис будет примерно следующим:

/pattern/modifiers;

Шаблон задает правило поиска. Он состоит из простых символов наподобие /abc/ либо комбинации простых и специальных символов: /abc/ или /Chapter (d+).d/ .

Таблица шаблонов

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

Таблица модификаторов

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

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

Создаем объект регулярного выражения

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

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

var reg = /ab+c/;

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

Способ 2: вызывая функцию-конструктор объекта RegExp , например:

var reg = new RegExp("ab+c");

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

Методы объекта регулярного выражения

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

• compile() (устарел в версии 1.5 ) – компилирует регулярное выражение;
• exec() – производит сопоставление в строке. Возвращает первое совпадение;
• test() – производит сопоставление в строке. Возвращает значение true или false ;
• toString() – возвращает строчное значение регулярного выражения.

Примеры

Применение test()

Метод test() – регулярное выражение объекта RegExp . Он производит поиск строки шаблона, и в зависимости от полученного результата возвращает значение true или false . Следующий JS регулярного выражения пример показывает, как происходит поиск в строке символа “e ”:

var patt = /e/; patt.test("Лучшие в мире вещи – бесплатны!");

Так как здесь в строке имеется “e ”, результатом данного кода будет значение true .

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

/e/.test("Лучшие в мире вещи – бесплатны!");

Применение exec()

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

Посмотрим на метод в действии, на примере того же символа “e ”:

/e/.exec("Лучшие в мире вещи – бесплатны!");

Так как в строке имеется “e ”, результатом данного кода будет .e .

Применение регулярного выражения для строки

В Javascript эти выражения также можно использовать с двумя методами объекта String : search() и replace() . Они нужны для выполнения поиска и замены в тексте.

• Метод search() — использует выражение для поиска соответствия, и возвращает информацию о расположении соответствия;
• Метод replace() — возвращает модифицированную строку с замененным шаблоном.

Примеры

Применение регулярного выражения JS для осуществления чувствительного к регистру поиска фразы “w3schools ” в строке:

var str = "Visit W3Schools"; var n = str.search(/w3schools/i);

Результатом в n будет 6.

Метод search также принимает строку в качестве аргумента. Аргумент string будет преобразован в регулярное выражение:

Применение string для поиска фразы “W3schools ” в строке.

JavaScript regexp – это тип объекта, который используется для сопоставления последовательности символов в строках.

Создаем первое регулярное выражение

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

// литерал регулярного выражения заключается в слэши (/) var option1 = /cat/; // Конструктор регулярнго выражения var option2 = new RegExp("cat");

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

Метод RegExp.prototype.test()

Помните, я говорил, что регулярные выражения являются объектами? Это означает, что у них есть ряд методов. Самый простой метод – это JavaScript regexp test , который возвращает логическое значение:

True (истина ): строка содержит шаблон регулярного выражения.

False (ложь ): совпадения не найдено.

console.log(/cat/.test(“the cat says meow”)); // верно console.log(/cat/.test(“the dog says bark”)); // неверно

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

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

Символы

• . – (точка ) соответствует любому одиночному символу за исключением переноса строки;
• *  –  соответствует предыдущему выражению, которое повторяется 0 или более раз;
• +  –  соответствует предыдущему выражению, которое повторяется 1 или более раз;
• ? –  предыдущее выражение является необязательным (соответствует 0 или 1 раз );
• ^ – соответствует началу строки;
• $ – соответствует концу строки.

Группы символов

• d –  соответствует любому одиночному цифровому символу.
• w –  соответствует любому символу (цифре, букве или знаку подчёркивания).
• [XYZ ]   –  набор символов. Соответствует любому одиночному символу из набора, заданного в скобках. Также можно задавать и диапазоны символов, например, .
• [XYZ ]+   –  соответствует символу из набора, повторяемого один или более раз.
• [^A —Z ]   –  внутри набора символов «^ » используется как знак отрицания. В данном примере шаблону соответствует всё, что не является буквами в верхнем регистре.

Флаги :

В JavaScript regexp существует пять необязательных флагов. Они могут использоваться отдельно или вместе, и размещаются после закрывающего слеша. Например: /[A —Z ]/g . Здесь я приведу только два флага.

g –  глобальный поиск.

i   –  поиск, нечувствительный к регистру.

Дополнительные конструкции

(x )   –   захватывающие скобки. Это выражение соответствует x и запоминает это соответствие, поэтому им можно воспользоваться позже.

(?:x )   –  незахватывающие скобки. Выражение соответствует x , но не запоминает это соответствие.

Соответствует x , только если за ним следует y .

Протестируем изученный материал

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

console.log(/d/.test("12-34")); // верно

Приведенный выше код возвращает значение true , если в строке есть хотя бы одна цифра. Что делать, если нужно проверить строку на соответствие формату? Можно использовать несколько символов «d », чтобы определить формат:

console.log(/dd-dd/.test("12-34")); //верно console.log(/dd-dd/.test("1234")); //неверно

Если неважно, как в JavaScript regexp online идут цифры до и после знака «— », можно использовать символ «+ », чтобы показать, что шаблон «d » встречается один или несколько раз:

console.log(/d+-d+/.test("12-34")); // верно console.log(/d+-d+/.test("1-234")); // верно console.log(/d+-d+/.test("-34")); // неверно

Для простоты можно использовать скобки, чтобы сгруппировать выражения. Допустим, у нас есть мяуканье кошки, и мы хотим проверить соответствие шаблону «meow » (мяу ):

console.log(/me+(ow)+w/.test("meeeeowowoww")); // верно

Теперь давайте разберемся.

m => соответствие одной букве ‘m ‘;

e + => соответствие букве «e» один или несколько раз;

(ow) + => соответствие буквам «ow» один или несколько раз;

w => соответствие букве ‘w ’;

‘m’ + ‘eeee’ + ‘owowow’ + ‘w’ .

Когда операторы типа «+ » используются сразу после скобок, они влияют на все содержимое скобок.

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

console.log(/cats? says?/i.test("the Cat says meow")); //верно console.log(/cats? says?/i.test("the Cats say meow")); //верно

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

var slashSearch = ///; var questionSearch = /?/;

• d – это то же самое, что и : каждая конструкция соответствует цифровому символу.
• w – это то же самое, что [A —Za —z 0-9_] : оба выражения соответствуют любому одиночному алфавитно-цифровому символу или подчеркиванию.

Пример: добавляем пробелы в строки, написанные в «верблюжьем» стиле

В этом примере мы очень устали от «верблюжьего » стиля написания и нам нужен способ добавить пробелы между словами. Вот пример:

removeCc("camelCase") // => должен вернуть "camel Case"

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

Это соответствует символу «C » в «camelCase »

Теперь, как добавить пробел перед «C »?

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

Получить доступ к захваченному значению позднее можно так:

Выше мы используем $1 для доступа к захваченному значению. Кстати, если бы у нас было два набора захватывающих скобок, мы использовали бы $1 и $2 для ссылки на захваченные значения и аналогично для большего количества захватывающих скобок.

Если вам нужно использовать скобки, но не нужно фиксировать это значение, можно использовать незахватывающие скобки: (?: x ). В этом случае находится соответствие x , но оно не запоминается.

Вернемся к текущей задаче. Как мы реализуем захватывающие скобки? С помощью метода JavaScript regexp replace ! В качестве второго аргумента мы передаем «$1 ». Здесь важно использовать кавычки.

function removeCc(str){ return str.replace(/()/g, "$1"); }

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

function removeCc(str){ return str.replace(/()/g, " $1"); } removeCc("camelCase") // "camel Case" removeCc("helloWorldItIsMe") // "hello World It Is Me"

Пример: удаляем заглавные буквы

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

Мы снова будем использовать метод replace , но как в этот раз сделать строчной символ?

function lowerCase(str){ return str.replace(//g, ???); }

Подсказка : в методе replace () в качестве второго параметра можно указать функцию.

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

function lowerCase(str){ return str.replace(//g, (u) => u.toLowerCase()); } lowerCase("camel Case") // "camel case" lowerCase("hello World It Is Me") // "hello world it is me"