Регулярные выражения (RegExp ) - это очень эффективный способ работы со строками.
Составив регулярное выражение с помощью специального синтаксиса вы можете:
- искать текст в строке
- заменять подстроки в строке
- извлекать информацию из строки
Почти во всех языках программирования есть регулярные выражения. Есть небольшие различия в реализации, но общие концепции применяются практически везде.
Регулярные выражения относятся к 1950-м годам, когда они были формализованы как концептуальный шаблон поиска для алгоритмов обработки строк.
Регулярные выражения реализованные в UNIX, таких как grep, sed и популярных текстовых редакторах, начали набирать популярность и были добавлены в язык программирования Perl, а позже и в множество других языков.
JavaScript, наряду с Perl, это один из языков программирования в котором поддержка регулярных выражений встроена непосредственно в язык.
Сложно, по полезно
Новичкам регулярные выражения могут показаться абсолютной ерундой, а зачастую даже и профессиональным разработчикам, если не вкладывать время необходимое для их понимания.
Регулярные выражения сложно писать , сложно читать и сложно поддерживать/изменять .
Но иногда регулярные выражения это единственный разумный способ выполнить какие-то манипуляции над строками, поэтому они являются очень ценным инструментом.
Это руководство нацелено на то чтобы самым простым способом дать вам некоторое представление о регулярных выражениях в JavaScript и предоставить информацию о том как читать и создавать регулярные выражения.
Эмпирическое правило заключается в том, что простые регулярные выражения просты для чтения и записи , в то время как сложные регулярные выражения могут быстро превратиться в беспорядок , если вы не глубоко понимаете основы.
Как выглядят регулярные выражения
В JavaScript регулярные выражения это объект, который может быть определён двумя способами.
Первый способ заключается в создании нового объекта RegExp с помощью конструктора:
Const re1 = new RegExp("hey")
Второй способ заключается в использовании литералов регулярных выражений :
Const re1 = /hey/
Вы знаете что в JavaScript есть литералы объектов и литералы массивов ? В нём также есть литералы regexp .
В приведённом выше примере hey называется шаблоном . В литеральной форме он находится между двумя слэшами, а в случае с конструктором объекта, нет.
Это первое важное отличие между двумя способами определения регулярных выражений, остальные мы увидим позже.
Как они работают?
Регулярное выражение, которое мы определили выше как re1 , очень простое. Оно ищет строку hey без каки-либо ограничений: строка может содержать много текста, а слово hey находиться где-то в середине и регулярное выражение сработает. Строка может содержать только слово hey и регулярка опять сработает.
Это довольно просто.
Вы можете попробовать протестировать регулярное выражение с помощью метода RegExp.test(String) , который возвращает логическое (boolean) значение:
Re1.test("hey") // ✅ re1.test("blablabla hey blablabla") // ✅ re1.test("he") // ❌ re1.test("blablabla") // ❌
В примере выше мы просто проверили удовлетворяет ли "hey" шаблону регулярного выражения, который храниться в re1 .
Это проще простого, но вы уже знаете много о регулярных выражениях.
Закрепление
/hey/сработает независимо от того где находится hey внутри строки.
Если вы хотите найти строки, которые начинаются с hey , то используйте оператор ^ :
/^hey/.test("hey") // ✅ /^hey/.test("bla hey") // ❌
Если вы хотите найти строки, которые заканчиваются на hey , то используйте оператор $ :
/hey$/.test("hey") // ✅ /hey$/.test("bla hey") // ✅ /hey$/.test("hey you") // ❌
Объединяя два предыдущих оператора вы можете найти строку, которая полностью совпадает с hey:
/^hey$/.test("hey") // ✅
Чтобы найти строку начинающуюся с одной подстроки, а заканчивающуюся другой подстрокой вы можете использовать.* , который будет совпадать с любым символом повторяющимся 0 или более раз:
/^hey.*joe$/.test("hey joe") // ✅ /^hey.*joe$/.test("heyjoe") // ✅ /^hey.*joe$/.test("hey how are you joe") // ✅ /^hey.*joe$/.test("hey joe!") // ❌
Поиск элементов по диапазону
Вместо того чтобы искать определённую строку, вы можете указать диапазон символов, например:
// // a, b, c, ... , x, y, z // // A, B, C, ... , X, Y, Z // // a, b, c // // 0, 1, 2, 3, ... , 8, 9
Эти регулярные выражения ищут строки, которые содержат хотя бы один символ из выбранного диапазона:
//.test("a") // ✅ //.test("1") // ❌ //.test("A") // ❌ //.test("d") // ❌ //.test("dc") // ✅
Диапазоны можно комбинировать:
// //.test("a") // ✅ //.test("1") // ✅ //.test("A") // ✅
Поиск многократных совпадений элемента диапазона
Вы можете проверить содержит ли строка только один символ из диапазона с помощью символа - :
/^$/ /^$/.test("A") // ✅ /^$/.test("Ab") // ❌
Инверсия шаблона
Символ ^ в начале шаблона привязывает его к началу строки.
Использование этого символа внутри диапазона инвертирует диапазон, поэтому:
/[^A-Za-z0-9]/.test("a") // ❌ /[^A-Za-z0-9]/.test("1") // ❌ /[^A-Za-z0-9]/.test("A") // ❌ /[^A-Za-z0-9]/.test("@") // ✅
Метасимволы
- \d совпадает с любым числом, эквивалентно
- \D совпадает с любым символом, который не является числом, эквивалентно [^0-9]
- \w совпадает с любым буквенно-числовым символом, эквивалентно
- \W совпадает с любым символом, который не является буквенно-числовым значением, эквивалентно [^A-Za-z0-9]
- \s совпадает с любым пробельным символом: пробел, табуляция, символ новой строки и пробелы Unicode
- \S совпадает с любым символом, который не является пробелом
- \0 совпадает с null
- \n совпадает с символом новой строки
- \t совпадает с символом табуляции
- \uXXXX совпадает с символом Unicode с кодом XXXX (требуется флаг u)
- . совпадает с любым символовом, кроме символа новой строки (таким как \n) (если вы не используете флаг s , объясним позже)
- [^] совпадает с любым символом, включая символ новой строки. Полезно при работе с многострочными строками
Выбор в регулярных выражениях
Если вы хотите выбрать одну или другую строку, используйте оператор | .
/hey|ho/.test("hey") // ✅ /hey|ho/.test("ho") // ✅
Квантификаторы
Представьте что у вас есть регулярное выражение, которое проверяет строку на то чтобы она состояла только из одной цифры:
Вы можете использовать квантификатор ? , который сделает этот символ необязательным. В нашем случае цифра должна встречаться 0 или 1 раз:
но что если мы хотим чтобы регулярное выражение срабатывало на несколько цифр?
Вы можете сделать это 4 способами, используя + , * , {n} и {n,m} .
+
Совпадает с одним или более (>=1) элементами:
/^\d+$/ /^\d+$/.test("12") // ✅ /^\d+$/.test("14") // ✅ /^\d+$/.test("144343") // ✅ /^\d+$/.test("") // ❌ /^\d+$/.test("1a") // ❌
*
Совпадает с 0 или более (>=0) элементами:
/^\d+$/ /^\d*$/.test("12") // ✅ /^\d*$/.test("14") // ✅ /^\d*$/.test("144343") // ✅ /^\d*$/.test("") // ✅ /^\d*$/.test("1a") // ❌
{n}
Совпадает точно с n количеством элементов:
/^\d{3}$/ /^\d{3}$/.test("123") // ✅ /^\d{3}$/.test("12") // ❌ /^\d{3}$/.test("1234") // ❌ /^{3}$/.test("Abc") // ✅
{n,m}
Совпадает с диапазоном от n до m элементов:
/^\d{3,5}$/ /^\d{3,5}$/.test("123") // ✅ /^\d{3,5}$/.test("1234") // ✅ /^\d{3,5}$/.test("12345") // ✅ /^\d{3,5}$/.test("123456") // ❌
m можно опустить и оставить второй предел без ограничений, чтобы было минимум n элементов:
/^\d{3,}$/ /^\d{3,}$/.test("12") // ❌ /^\d{3,}$/.test("123") // ✅ /^\d{3,}$/.test("12345") // ✅ /^\d{3,}$/.test("123456789") // ✅
Опциональные элементы
Следующий за элементом знак? , сделает его необязательным:
/^\d{3}\w?$/ /^\d{3}\w?$/.test("123") // ✅ /^\d{3}\w?$/.test("123a") // ✅ /^\d{3}\w?$/.test("123ab") // ❌
Группы
Используя круглые скобки, вы можете создавать группы символов (...) .
Пример ниже ищет точное совпадение из 3 цифр за которым следует один или более буквенно-числовые символов:
/^(\d{3})(\w+)$/ /^(\d{3})(\w+)$/.test("123") // ❌ /^(\d{3})(\w+)$/.test("123s") // ✅ /^(\d{3})(\w+)$/.test("123something") // ✅ /^(\d{3})(\w+)$/.test("1234") // ✅
Повторяющиеся символы, которые находятся после закрывающей группу скобки, относятся ко всей группе:
/^(\d{2})+$/ /^(\d{2})+$/.test("12") // ✅ /^(\d{2})+$/.test("123") // ❌ /^(\d{2})+$/.test("1234") // ✅
Захват групп
До сих пор мы видели, как тестировать строки и проверять, содержат ли они определенный шаблон.
Крутая возможность регулярных выражений заключается в том, что можно захватывать определённые части строки и складывать их в массив.
Вы можете делать это с помощью групп, а точнее с помощью захвата групп .
По умолчанию, группы итак захватываются. Теперь вместо использования RegExp.test(String) , который просто возвращает логическое значение, мы будем использовать один из следующих методов:
- String.match(RegExp)
- RegExp.exec(String)
Они абсолютно одинаковые и оба возвращают массив с проверяемой строкой в качестве первого элемента, а в остальных элементах совпадения для каждой найденной группы.
Если совпадений не найдено, то он возвращает null .
"123s".match(/^(\d{3})(\w+)$/) //Array [ "123s", "123", "123s" ] /^(\d{3})(\w+)$/.exec("123s") //Array [ "123s", "123", "s" ] "hey".match(/(hey|ho)/) //Array [ "hey", "hey" ] /(hey|ho)/.exec("hey") //Array [ "hey", "hey" ] /(hey|ho)/.exec("ha!") //null
Когда группа совпадает несколько раз, то только последнее найденное значение будет добавлено в возвращаемый массив.
"123456789".match(/(\d)+/) //Array [ "123456789", "9" ]
Опциональные группы
Захват групп можно сделать опциональным с помощью (...)? . Если ничего не будет найдено, то в возвращаемый массив будет добавлен элемент undefined:
/^(\d{3})(\s)?(\w+)$/.exec("123 s") //Array [ "123 s", "123", " ", "s" ] /^(\d{3})(\s)?(\w+)$/.exec("123s") //Array [ "123s", "123", undefined, "s" ]
Ссылка на найденную группу
Каждой найденной группе присваивается число. $1 ссылается на первый элемент, $2 на второй, и так далее. Это полезно, когда мы будет говорить о замене части строки.
Именованный захват групп
Это новая возможность ES2018.
Группе можно назначить имя, а не просто слот в возвращаемом массиве:
Const re = /(?
Использование match и exec без групп
Существует разница при использовании match и exec без групп: в первом элементе массива будет находится не полностью найденная строка, а прямое совпадение:
/hey|ho/.exec("hey") // [ "hey" ] /(hey).(ho)/.exec("hey ho") // [ "hey ho", "hey", "ho" ]
Незахватываемые группы
Так как по умолчанию группы являются захватываемыми, нам нужен способ игнорировать некоторые группы в возвращаемом массиве. Это возможно с помощью незахватываемых групп , которые начинаются с (?:...) .
"123s".match(/^(\d{3})(?:\s)(\w+)$/) // null "123 s".match(/^(\d{3})(?:\s)(\w+)$/) // Array [ "123 s", "123", "s" ]
Флаги
Вы можете использовать следующие флаги на любых регулярных выражениях:
- g: ищет совпадения глобально
- i: делает регулярное выражение не чувствительным к регистру
- m: включает многострочный режим. В этом режиме ^ и $ совпадают с началом и концом всей строки. Без этого флага, с многострочными строками они совпадают с началом и концом каждой строки.
- u: включает поддержку Unicode (добавлено в ES6/ES2015)
- s: (новое в ES2018) сокращение от "single line", он позволяет. совпадать с символами новой строки
Флаги можно комбинировать, а также они добавляются в конец строки литерала:
/hey/ig.test("HEy") // ✅
или передаются вторым параметром в конструктор объекта RegExp:
New RegExp("hey", "ig").test("HEy") // ✅
Инспектирование регулярных выражений
Вы можете инспектировать свойства регулярных выражений:
- source - строка шаблона
- multiline - принимается значение true если установлен флаг m
- global - принимается значение true если установлен флаг g
- ignoreCase - принимается значение true если установлен флаг i
- lastIndex
Экранирование
Специальные символы:
Это специальные символы потому что они являются управляющими символами при составлении шаблонов регулярных выражений, поэтому если вы хотите использовать их для поиска совпадений внутри шаблона, то вам нужно экранировать их с помощью символа обратного слэша:
/^\\$/ /^\^$/ // /^\^$/.test("^") ✅ /^\$$/ // /^\$$/.test("$") ✅Границы строк
\b и \B позволяют определить находится ли строка в начале или конце слова:
- \b совпадает если набор символов находится в начале или конце слова
- \B совпадает если набор символов не находится в начале или конце слова
"I saw a bear".match(/\bbear/) //Array ["bear"] "I saw a beard".match(/\bbear/) //Array ["bear"] "I saw a beard".match(/\bbear\b/) //null "cool_bear".match(/\bbear\b/) //null
Замена с помощью регулярных выражений
Мы уже видели как нужно проверять строки на совпадение с шаблоном.
Также мы видели как можно извлекать часть строк соотвествующие шаблону в массив.
Теперь давайте рассмотрим как заменять части строки на основе шаблона.
У объекта String в JavaScript есть метод replace() , который можно использовать без регулярных выражений для одной замены в строке:
"Hello world!".replace("world", "dog") //Hello dog! "My dog is a good dog!".replace("dog", "cat") //My cat is a good dog!
Этот метод также может принимать и регулярное выражение в качестве аргумента:
"Hello world!".replace(/world/, "dog") //Hello dog!
Использование флага g - это единственный способ заменить несколько вхождений в строке на ванильном JavaScript:
"My dog is a good dog!".replace(/dog/g, "cat") //My cat is a good cat!
Группы позволяют нам делать больше причудливых вещей, менять местами части строк:
"Hello, world!".replace(/(\w+), (\w+)!/, "$2: $1!!!") // "world: Hello!!!"
Вместо строки можно использовать функцию, чтобы делать ещё более интересные вещи. В неё будет передан ряд аргументов, таких как возвращают методы String.match(RegExp) или RegExp.exec(String) , где количество аргументов зависит от количества групп:
"Hello, world!".replace(/(\w+), (\w+)!/, (matchedString, first, second) => { console.log(first); console.log(second); return `${second.toUpperCase()}: ${first}!!!` }) //"WORLD: Hello!!!"
Жадность
Регулярные выражения называются жадными по умолчанию.
Что это значит?
Возьмём например это регулярное выражение:
/\$(.+)\s?/
Предполагается, что нам нужно извлечь из строки сумму в долларах:
/\$(.+)\s?/.exec("This costs $100") //0
но что если у нас есть больше слов после числа, это отвлекает
/\$(.+)\s?/.exec("This costs $100 and it is less than $200") //100 and it is less than $200
Почему? Потому что регулярное выражение после знака $ совпадает с любым символом.+ и не останавливается пока не достигнет конца строки. Затем он останавливается, потому что \s? делает конечное пространство необязательным.
Чтобы исправить это, нам нужно указать что регулярное выражение должно быть ленивым и найти наименьшее количество совпадений. Мы можем сделать это с помощью символа? после квантификатора:
/\$(.+?)\s/.exec("This costs $100 and it is less than $200") //100
Итак, символ? может означать разные вещи в зависимости от своего положения, поэтому он может быть и квантификатором и индикатором ленивого режима.
Опережение: соответствие строки в зависимости от того что за ней следует
Используйет?= для поиска совпадений в строке за которой следует определённая подстрока
/Roger(?=Waters)/ /Roger(?= Waters)/.test("Roger is my dog") //false /Roger(?= Waters)/.test("Roger is my dog and Roger Waters is a famous musician") //true
Выполняет обратную операцию и находит совпадений в строке за которыми не следует определённая подстрока:
/Roger(?!Waters)/ /Roger(?! Waters)/.test("Roger is my dog") //true /Roger(?! Waters)/.test("Roger is my dog and Roger Waters is a famous musician") //false
Ретроспектива: соответствие строки в зависимости от того что ей предшествует
Это новая возможность ES2018.
Опережение использует символ?= . Ретроспектива использует?<= :
/(?<=Roger) Waters/ /(?<=Roger) Waters/.test("Pink Waters is my dog") //false /(?<=Roger) Waters/.test("Roger is my dog and Roger Waters is a famous musician") //true
Инверсия ретроспективы использует?
/(?
Регулярные выражения и Unicode
Флаг u является обязательным при работе с Unicode строками, в частности когда может понадобится обрабатывать строки в астральных плоскостях, которые не включены в первые 1600 символов Unicode.
Например эмодзи, но и только они.
/^.$/.test("a") // ✅ /^.$/.test("?") // ❌ /^.$/u.test("?") // ✅
Поэтому, всегда используйте флаг u .
Unicode, как и обычные символы, может обрабатывать диапазоны:
//.test("a") // ✅ //.test("1") // ✅ /[?-?]/u.test("?") // ✅ /[?-?]/u.test("?") // ❌
JavaScript проверяет внутренние коды представления, поэтому? < ? < ? на самом деле \u1F436 < \u1F43A < \u1F98A . Посмотрите полный список эмодзи чтобы увидеть коды и узнать их порядок.
Экранирование свойств Unicode
Как мы говорили выше, в шаблоне регулярного выражения вы можете использовать \d чтобы найти совпадение на любую цифру, \s чтобы найти совпадение на любой символ кроме пробела, \w чтобы найти совпадение на любой буквенно-числовой символ и т. д.
Экранирование свойств Unicode - это возможность ES2018, которая добавляет очень крутую функцию, расширяя эту концепцию на всех Unicode символы и добавляя \p{} и \P{} .
У любого Unicode символа есть набор свойств. Например Script определяет семейство языков, ASCII - это логическое значение равное true для ASCII символов и т.д. Вы можете положить это свойство в фигурные скобки и регулярное выражение будет проверять чтобы его значение было истинным:
/^\p{ASCII}+$/u.test("abc") // ✅ /^\p{ASCII}+$/u.test("ABC@") // ✅ /^\p{ASCII}+$/u.test("ABC?") // ❌
ASCII_Hex_Digit - это ещё одно логическое свойство, которое проверяет содержит ли строка тольк валидные шестнадцатеричные цифры:
/^\p{ASCII_Hex_Digit}+$/u.test("0123456789ABCDEF") //✅ /^\p{ASCII_Hex_Digit}+$/u.test("h")
Существует много других логических свойств, которые вы можете проверить просто добавив их имя в фигурные скобки, включая Uppercase , Lowercase , White_Space , Alphabetic , Emoji и другие:
/^\p{Lowercase}$/u.test("h") // ✅ /^\p{Uppercase}$/u.test("H") // ✅ /^\p{Emoji}+$/u.test("H") // ❌ /^\p{Emoji}+$/u.test("??") // ✅
В дополнении к этим бинарным свойствам, вы можете проверить любое свойство символа Unicode чтобы соответствовало конкретному значению. В примере ниже я проверяю, записана ли строка в греческом или латинском алфавите:
/^\p{Script=Greek}+$/u.test("ελληνικά") // ✅ /^\p{Script=Latin}+$/u.test("hey") // ✅
Примеры
Извлечение числа из строки
Предположим, что есть строка содержащая только одно число, которое нужно извлечь. /\d+/ должен сделать это:
"Test 123123329".match(/\d+/) // Array [ "123123329" ]
Поиск E-mail адреса:
Простейший подход заключается в проверке безпробельных символов до и после знака @ , с помощью \S:
/(\S+)@(\S+)\.(\S+)/ /(\S+)@(\S+)\.(\S+)/.exec("[email protected]") //["[email protected]", "copesc", "gmail", "com"]
Однако, это упрощенный пример, так как под него попадает множество не валидных E-mail адресов.
Захват текста между двойными кавычками
Представим, что у вас есть строка, которая содержит текст заключённый в двойные кавычки и вам нужно извлечь этот текст.
Лучший способ сделать это - использовать захват групп , потому то мы знаем что наше совпадение должно начинаться и заканчиваться символом " , поэтому мы можем легко настроить шаблон, но также мы хотим удалить эти кавычки из результата.
Мы найдём то что нам нужно в result :
Const hello = "Hello "nice flower"" const result = /"([^"]*)"/.exec(hello) //Array [ "\"nice flower\"", "nice flower" ]
Получение содержимого из HTML тега
Например получить содержимое из тега span , допуская при этом любое количество аргументов у тега:
/
В этой статье рассмотрены основы применения регулярного выражения в 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 ” в строке.
Регулярные выражения - это язык, который описывает шаблоны строк, основанные на метасимволах. Метасимвол – это символ в регулярном выражении, который описывает некоторый класс символов строки, указывает на положение подстроки, указывает количество повторений или группирует символы в подстроку. Например, метасимвол \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») так же одно и тоже.
З.Ы.
Регулярные выражения это очень мощный и удобный инструмент для работы со строками, позволяющий сократить сотни строк кода до одного выражения. К сожалению, их синтаксис иногда слишком сложен и трудночитаем и даже самый опытный разработчик может забыть, что означало достаточно сложное регулярное выражение, которое он писал пару дней назад, если он его не прокомментировал. По этим причинам иногда всё же стоит отказаться от регулярных выражений в пользу обычных методов для работы со строками.
Модификаторы
Символ «минус» (-) меред модификатором (за исключением U) создаёт его отрицание.
Спецсимволы
| Аналог | Описание | |
|---|---|---|
| () | подмаска, вложенное выражение | |
| групповой символ | ||
| {a,b} | количество вхождений от «a» до «b» | |
| | | логическое «или», в случае с односимвольными альтернативами используйте | |
| \ | экранирование спец символа | |
| . | любой сивол, кроме перевода строки | |
| \d | десятичная цифра | |
| \D | [^\d] | любой символ, кроме десятичной цифры |
| \f | конец (разрыв) страницы | |
| \n | перевод строки | |
| \pL | буква в кодировке UTF-8 при использовании модификатора u | |
| \r | возврат каретки | |
| \s | [ \t\v\r\n\f] | пробельный символ |
| \S | [^\s] | любой символ, кроме промельного |
| \t | табуляция | |
| \w | любая цифра, буква или знак подчеркивания | |
| \W | [^\w] | любой символ, кроме цифры, буквы или знака подчеркивания |
| \v | вертикальная табуляция |
Спецсимволы внутри символьного класса
Позиция внутри строки
| Пример | Соответствие | Описание | |
|---|---|---|---|
| ^ | ^a | a aa aaa | начало строки |
| $ | a$ | aaa aaa | конец строки |
| \A | \Aa | a
aa aaa aaa aaa | начало текста |
| \z | a\z | aaa aaa aaa aaa | конец текста |
| \b | a\b \ba | aaa
aaa
a aa a aa | граница слова, утверждение: предыдущий символ словесный, а следующий - нет, либо наоборот |
| \B | \Ba\B | aa a aa a | отсутствие границы слова |
| \G | \Ga | aaa aaa | Предыдущий успешный поиск, поиск остановился на 4-й позиции — там, где не нашлось a |
Якоря
Якоря в регулярных выражениях указывают на начало или конец чего-либо. Например, строки или слова. Они представлены определенными символами. К примеру, шаблон, соответствующий строке, начинающейся с цифры, должен иметь следующий вид:
Здесь символ ^ обозначает начало строки. Без него шаблон соответствовал бы любой строке, содержащей цифру.
Символьные классы
Символьные классы в регулярных выражениях соответствуют сразу некоторому набору символов. Например, \d соответствует любой цифре от 0 до 9 включительно, \w соответствует буквам и цифрам, а \W — всем символам, кроме букв и цифр. Шаблон, идентифицирующий буквы, цифры и пробел, выглядит так:
POSIX
POSIX — это относительно новое дополнение семейства регулярных выражений. Идея, как и в случае с символьными классами, заключается в использовании сокращений, представляющих некоторую группу символов.
Утверждения
Поначалу практически у всех возникают трудности с пониманием утверждений, однако познакомившись с ними ближе, вы будете использовать их довольно часто. Утверждения предоставляют способ сказать: «я хочу найти в этом документе каждое слово, включающее букву “q”, за которой не следует “werty”».
[^\s]*q(?!werty)[^\s]*
Приведенный выше код начинается с поиска любых символов, кроме пробела ([^\s]*), за которыми следует q . Затем парсер достигает «смотрящего вперед» утверждения. Это автоматически делает предшествующий элемент (символ, группу или символьный класс) условным — он будет соответствовать шаблону, только если утверждение верно. В нашем случае, утверждение является отрицательным (?!), т. е. оно будет верным, если то, что в нем ищется, не будет найдено.
Итак, парсер проверяет несколько следующих символов по предложенному шаблону (werty). Если они найдены, то утверждение ложно, а значит символ q будет «проигнорирован», т. е. не будет соответствовать шаблону. Если же werty не найдено, то утверждение верно, и с q все в порядке. Затем продолжается поиск любых символов, кроме пробела ([^\s]*).
Кванторы
Кванторы позволяют определить часть шаблона, которая должна повторяться несколько раз подряд. Например, если вы хотите выяснить, содержит ли документ строку из от 10 до 20 (включительно) букв «a», то можно использовать этот шаблон:
A{10,20}
По умолчанию кванторы — «жадные». Поэтому квантор + , означающий «один или больше раз», будет соответствовать максимально возможному значению. Иногда это вызывает проблемы, и тогда вы можете сказать квантору перестать быть жадным (стать «ленивым»), используя специальный модификатор. Посмотрите на этот код:
".*"Этот шаблон соответствует тексту, заключенному в двойные кавычки. Однако, ваша исходная строка может быть вроде этой:
Привет, Мир
Приведенный выше шаблон найдет в этой строке вот такую подстроку:
"helloworld.htm" title="Привет, Мир"
Он оказался слишком жадным, захватив наибольший кусок текста, который смог.
".*?"Этот шаблон также соответствует любым символам, заключенным в двойные кавычки. Но ленивая версия (обратите внимание на модификатор?) ищет наименьшее из возможных вхождений, и поэтому найдет каждую подстроку в двойных кавычках по отдельности:
"helloworld.htm" "Привет, Мир"
Экранирование в регулярных выражениях
Регулярные выражения используют некоторые символы для обозначения различных частей шаблона. Однако, возникает проблема, если вам нужно найти один из таких символов в строке, как обычный символ. Точка, к примеру, в регулярном выражении обозначает «любой символ, кроме переноса строки». Если вам нужно найти точку в строке, вы не можете просто использовать « . » в качестве шаблона — это приведет к нахождению практически всего. Итак, вам необходимо сообщить парсеру, что эта точка должна считаться обычной точкой, а не «любым символом». Это делается с помощью знака экранирования.
Знак экранирования, предшествующий символу вроде точки, заставляет парсер игнорировать его функцию и считать обычным символом. Есть несколько символов, требующих такого экранирования в большинстве шаблонов и языков. Вы можете найти их в правом нижнем углу шпаргалки («Мета-символы»).
Шаблон для нахождения точки таков:
\.Другие специальные символы в регулярных выражениях соответствуют необычным элементам в тексте. Переносы строки и табуляции, к примеру, могут быть набраны с клавиатуры, но вероятно собьют с толку языки программирования. Знак экранирования используется здесь для того, чтобы сообщить парсеру о необходимости считать следующий символ специальным, а не обычной буквой или цифрой.
Спецсимволы экранирования в регулярных выражениях
Подстановка строк
Подстановка строк подробно описана в следующем параграфе «Группы и диапазоны», однако здесь следует упомянуть о существовании «пассивных» групп. Это группы, игнорируемые при подстановке, что очень полезно, если вы хотите использовать в шаблоне условие «или», но не хотите, чтобы эта группа принимала участие в подстановке.
Группы и диапазоны
Группы и диапазоны очень-очень полезны. Вероятно, проще будет начать с диапазонов. Они позволяют указать набор подходящих символов. Например, чтобы проверить, содержит ли строка шестнадцатеричные цифры (от 0 до 9 и от A до F), следует использовать такой диапазон:
Чтобы проверить обратное, используйте отрицательный диапазон, который в нашем случае подходит под любой символ, кроме цифр от 0 до 9 и букв от A до F:
[^A-Fa-f0-9]
Группы наиболее часто применяются, когда в шаблоне необходимо условие «или»; когда нужно сослаться на часть шаблона из другой его части; а также при подстановке строк.
Использовать «или» очень просто: следующий шаблон ищет «ab» или «bc»:
Если в регулярном выражении необходимо сослаться на какую-то из предшествующих групп, следует использовать \n , где вместо n подставить номер нужной группы. Вам может понадобиться шаблон, соответствующий буквам «aaa» или «bbb», за которыми следует число, а затем те же три буквы. Такой шаблон реализуется с помощью групп:
(aaa|bbb)+\1
Первая часть шаблона ищет «aaa» или «bbb», объединяя найденные буквы в группу. За этим следует поиск одной или более цифр (+), и наконец \1 . Последняя часть шаблона ссылается на первую группу и ищет то же самое. Она ищет совпадение с текстом, уже найденным первой частью шаблона, а не соответствующее ему. Таким образом, «aaa123bbb» не будет удовлетворять вышеприведенному шаблону, так как \1 будет искать «aaa» после числа.
Одним из наиболее полезных инструментов в регулярных выражениях является подстановка строк. При замене текста можно сослаться на найденную группу, используя $n . Скажем, вы хотите выделить в тексте все слова «wish» жирным начертанием. Для этого вам следует использовать функцию замены по регулярному выражению, которая может выглядеть так:
Replace(pattern, replacement, subject)
Первым параметром будет примерно такой шаблон (возможно вам понадобятся несколько дополнительных символов для этой конкретной функции):
([^A-Za-z0-9])(wish)([^A-Za-z0-9])
Он найдет любые вхождения слова «wish» вместе с предыдущим и следующим символами, если только это не буквы или цифры. Тогда ваша подстановка может быть такой:
$1$2$3
Ею будет заменена вся найденная по шаблону строка. Мы начинаем замену с первого найденного символа (который не буква и не цифра), отмечая его $1 . Без этого мы бы просто удалили этот символ из текста. То же касается конца подстановки ($3). В середину мы добавили HTML тег для жирного начертания (разумеется, вместо него вы можете использовать CSS или ), выделив им вторую группу, найденную по шаблону ($2).
Модификаторы шаблонов
Модификаторы шаблонов используются в нескольких языках, в частности, в Perl. Они позволяют изменить работу парсера. Например, модификатор i заставляет парсер игнорировать регистры.
Регулярные выражения в Perl обрамляются одним и тем же символом в начале и в конце. Это может быть любой символ (чаще используется «/»), и выглядит все таким образом:
/pattern/
Модификаторы добавляются в конец этой строки, вот так:
/pattern/i
Мета-символы
Наконец, последняя часть таблицы содержит мета-символы. Это символы, имеющие специальное значение в регулярных выражениях. Так что если вы хотите использовать один из них как обычный символ, то его необходимо экранировать. Для проверки наличия скобки в тексте, используется такой шаблон:
Шпаргалка представляет собой общее руководство по шаблонам регулярных выражений без учета специфики какого-либо языка. Она представлена в виде таблицы, помещающейся на одном печатном листе формата A4. Создана под лицензией Creative Commons на базе шпаргалки, автором которой является Dave Child. Скачать в PDF , PNG .
Последнее обновление: 1.11.2015
Регулярные выражения представляют шаблон, который используется для поиска или модификации строки. Для работы с регулярными выражениями в JavaScript определен объект RegExp .
Определить регулярное выражение можно двумя способами:
Var myExp = /hello/; var myExp = new RegExp("hello");
Используемое здесь регулярное выражение довольно простое: оно состоит из одного слова "hello". В первом случае выражение помещается между двумя косыми чертами, а во втором случае используется конструктор RegExp, в который выражение передается в виде строки.
Методы RegExp
Чтобы определить, соответствует ли регулярное выражение строке, в объекте RegExp определен метод test() . Этот метод возвращает true , если строка соответствует регулярному выражению, и false , если не соответствует.
Var initialText = "hello world!";
var exp = /hello/;
var result = exp.test(initialText);
document.write(result + "
"); // true
initialText = "beautifull wheather";
result = exp.test(initialText);
document.write(result); // false - в строке initialText нет "hello"
Аналогично работает метод exec - он также проверяет, соответствует ли строка регулярному выражению, только теперь данный метод возвращает ту часть строки, которая соответствует выражению. Если соответствий нет, то возвращается значение null .
Var initialText = "hello world!";
var exp = /hello/;
var result = exp.exec(initialText);
document.write(result + "
"); // hello
initialText = "beautifull wheather";
result = exp.exec(initialText);
document.write(result); // null
Группы символов
Регулярное выражение не обязательно состоит из обычных строк, но также может включать специальные элементы синтаксиса регулярных выражений. Один из таких элементов представляют группы символов, заключенные в квадратные скобки. Например:
Var initialText = "обороноспособность";
var exp = /[абв]/;
var result = exp.test(initialText);
document.write(result + "
"); // true
initialText = "город";
result = exp.test(initialText);
document.write(result); // false
Выражение [абв] указывает на то, что строка должна иметь одну из трех букв.
Если нам надо определить наличие в строке буквенных символов из определенного диапазона, то можно разу задать этот диапазон:
Var initialText = "обороноспособность";
var exp = /[а-я]/;
var result = exp.test(initialText);
document.write(result + "
"); // true
initialText = "3di0789";
result = exp.test(initialText);
document.write(result); // false
В данном случае строка должна содержать хотя бы один символ из диапазона а-я.
Если, наоборот, не надо, чтобы строка имела только определенные символы, то необходимо в квадратных скобках перед перечислением символов ставить знак ^:
Var initialText = "обороноспособность";
var exp = /[^а-я]/;
var result = exp.test(initialText);
document.write(result + "
"); // false
initialText = "3di0789";
exp = /[^0-9]/;
result = exp.test(initialText);
document.write(result); // true
В первом случае строка не должна иметь только символы из диапазона а-я, но поскольку строка "обороноспособность" состоит только из символов из этого диапазона, то метод test() возвращает false, то есть регулярное выражение не соответствует стоке.
Во втором случае ("3di0789") строка не должна состоять только из цифровых символов. Но так как в строке также есть и буквы, то строка соответствует регулярному выражению, поэтому метод test возвращает значение true.
При необходимости мы можем собирать комбинации выражений:
Var initialText = "дома"; var exp = /[дт]о[нм]/; var result = exp.test(initialText); document.write(result); // true
Выражение [дт]о[нм] указывает на те строки, которые могут содержать подстроки "дом", "том", "дон", "тон".
Свойства выражений
Свойство global позволяет найти все подстроки, которые соответствуют регулярному выражению. По умолчанию при поиске подстрок регулярное выражение выбирает первую попавшуюся подстроку из строки, которая соответствует выражению. Хотя в строке может быть множество подстрок, которые также соответствуют выражению. Для этого применяется данное свойство в виде символа g в выражениях
Свойство ignoreCase позволяет найти подстоки, которые соответствуют регулярному выражению, вне зависимости от регистра символов в строке. Для этого в регулярных выражениях применяется символ i
Свойство multiline позволяет найти подстроки, которые соответствуют регулярному выражению, в многострочном тексте. Для этого в регулярных выражениях применяется символ m
Например:
Var initialText = "привет Мир"; var exp = /мир/; var result = exp.test(initialText); // false
Здесь совпадения строки с выражением нет, так как "Мир" отличается от "мир" по регистру. В этом случае надо изменить регулярное выражение, добавив в него свойство ignoreCase:
Var exp = /мир/i;
Ну и также мы можем использовать сразу несколько свойств.
Удаление вирусов
