Последнее обновление: 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;
Ну и также мы можем использовать сразу несколько свойств.
Класс RegExp в JavaScript представляет собой регулярные выражения – объект, описывающий символьный шаблон. Объекты RegExp , как правило, создаются с помощью специального синтаксиса литералов, представленного ниже, но так же могут быть созданы посредством конструктора RegExp().
Синтаксис // с помощью специального синтаксиса литералов var regex = /pattern /flags ; // с помощью конструктора var regex = new RegExp("pattern ", "flags "); var regex = new RegExp(/pattern /, "flags ");Значения параметров:
Флаги регулярных выражений| g | Позволяет найти все совпадения, а не останавливаться после первого совпадения (global match flag ). |
| i | Позволяет выполнить сопоставление без учета регистра (ignore case flag ). |
| m | Сопоставление производится по нескольким строкам. Обработка начальных и конечных символов (^ и $) производится по нескольким строкам, то есть сопоставление происходит с началом или концом каждой строки (разделители \n или \r), а не только с началом, или концом всей строки (multiline flag ). |
| u | Шаблон будет расценен как последовательность кодовых точек Юникода (unicode flag ). |
| y | Сопоставление происходит по индексу на который указывает свойство lastIndex этого регулярного выражения, при этом сопоставление не производиться по более позднему, или раннему индексу (sticky flag ). |
| . | Позволяет найти один символ, кроме символа новой строки, или символа конца строки (\n, \r, \u2028 или \u2029). |
| \d | Позволяет найти символ цифры в базовом латинском алфавите. Эквивалентин использованию набору символов . |
| \D | Позволяет найти любой символ, который не является цифрой в базовом латинском алфавите. Эквивалентен набору символов [^0-9]. |
| \s | Позволяет найти одиночный пробельный символ. Под пробельным символом понимается пробел, табуляция, перевод страницы, перевод строки и другие пробельные символы Юникода. Эквивалентен набору символов [\f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]. |
| \S | Позволяет найти одиночный символ, который не является пробельным. Под пробельным символом понимается пробел, табуляция, перевод страницы, перевод строки и другие пробельные символы Юникода. Эквивалентен набору символов [^ \f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]. |
| [\b] | Позволяет найти символ backspace (специальный символ \b, U+0008). |
| \0 | Позволяет найти символ 0 (ноль). |
| \n | Позволяет найти символ новой строки. |
| \f | Позволяет найти символ перевода страницы. |
| \r | Позволяет найти символ возврата каретки. |
| \t | Позволяет найти символ горизонтальной табуляции. |
| \v | Позволяет найти символ вертикальной табуляции. |
| \w | Позволяет найти любой буквенно-цифровой символ базового латинского алфавита, включая подчеркивание. Эквивалентен набору символов . |
| \W | Позволяет найти любой символ, который не является символом из базового латинского алфавита. Эквивалентен набору символов [^a-Za-z0-9_]. |
| \cX | Позволяет найти контрольный символ в строке. Где X - буква от A до Z. Например, /\cM/ обозначает символ Ctrl-M. |
| \xhh | Позволяет найти символ, используя шестнадцатеричное значение (hh - двухзначное шестнадцатеричное значение). |
| \uhhhh | Позволяет найти символ, используя кодировку UTF-16 (hhhh - четырехзначное шестнадцатеричное значение). |
| \u{hhhh} или \u{hhhhh} | Позволяет найти символ со значением Юникода U+hhhh или U+hhhhh (шестнадцатеричное значение). Только когда задан флаг u . |
| \ | Указывает, что следующий символ является специальным и не должен интерпретироваться буквально. Для символов, которые обычно трактуются специальным образом, указывает, что следующий символ не является специальным и должен интерпретироваться буквально. |
| n* | Сопостовление происходит с любой строкой, содержащей ноль или более вхождений символа n . |
| n+ | Сопостовление происходит с любой строкой, содержащей хотя бы один символ n . |
| n? | Сопостовление происходит с любой строкой с предшествующим элементом n ноль или один раз. |
| n{x} | Соответствует любой строке, содержащей последовательность символов n определенное количество раз x . X |
| n{x,} | x вхождений предшествующего элемента n . X должно быть целым положительным числом. |
| n{x, y} | Соответствует любой строке, содержащей по крайней мере x , но не более, чем с y вхождениями предшествующего элемента n . X и y должны быть целыми положительными числами. |
| n*? n+? n?? n{x}? n{x,}? n{x,y}? | Сопостовление происходит по аналогии с квантификаторами *, +, ? и {...}, однако при этом поиск идет минимально возможного сопоставления. По умолчанию используется "жадный" режим, ? в конце квантификатора позволяет задать "нежадный" режим при котором повторение сопоставления происходит минимально возможное количество раз. |
| x(?=y) | Позволяет сопоставить x , только если за x следует y . |
| x(?!y) | Позволяет сопоставить x , только если за x не следует y . |
| x|y | Сопоставление происходит с любой из указанных альтернатив. |
| (x) | Позволяет найти символ x и запомнить результат сопоставления ("захватывающие скобки"). Сопоставленная подстрока может быть вызвана из элементов результирующего массива ..., [n], или из свойств предопределенного объекта RegExp $1 ..., $9. |
| (?:x) | Позволяет найти символ x , но не запоминать результат сопоставления ("незахватывающие скобки"). Сопоставленная подстрока не может быть вызвана из элементов результирующего массива ..., [n], или из свойств предопределенного объекта RegExp $1 ..., $9. |
| \n | Обратная ссылка на последнюю подстроку, совпадающую с n-ой по счёту в круглых скобках в регулярном выражении (нумерация скобок идет слева направо). n должно быть целым положительным числом. |
Регулярное выражение – это объект, описывающий символьный шаблон. Класс RegExp в JavaScript представляет регулярные выражения, а объекты классов String и RegExp определяют методы, использующие регулярные выражения для выполнения поиска по шаблону и операций поиска в тексте с заменой.
Регулярные выражения – это мощное средство для обработки входящих данных. Задача, требующая замены или поиска текста, может быть красиво решена с помощью этого “языка внутри языка”.
СозданиеВ JavaScript регулярные выражения представлены объектами RegExp. Объекты RegExp могут быть созданы посредством конструктора RegExp(), но чаще они создаются с помощью специального синтаксиса литералов. Cпособы создания:
// Используя литерал регулярного выражения: var re = /ab+c/;
Литералы регулярных выражений вызывают предварительную компиляцию регулярного выражения при анализе скрипта.
// Вызывая функцию конструктор объекта RegExp var re = new RegExp("ab+c");
Использование конструктора влечет за собой компиляцию регулярного выражения во время исполнения скрипта. Использовать данный способ надо если известно что выражение будет изменяться.
Спецсимволы в регулярном выражении\ – Для обычных символов – делает их специальными. Например, выражение /s/ ищет просто символ ‘s’. А если поставить \ перед s, то /\s/ уже обозначает пробельный символ.
^ – Обозначает начало входных данных. Если установлен флаг многострочного поиска (“m”), то также сработает при начале новой строки.
$ – Обозначает конец входных данных. Если установлен флаг многострочного поиска, то также сработает в конце строки.
* – Обозначает повторение 0 или более раз. Например, /bo*/ найдет ‘boooo’ в “A ghost booooed” и ‘b’ в “A bird warbled”, но ничего не найдет в “A goat grunted”.
+ – Обозначает повторение 1 или более раз. Эквивалентно {1,}. Например, /a+/ найдет ‘a’ в “candy” и все ‘a’ в “caaaaaaandy”.
? – Обозначает, что элемент может как присутствовать, так и отсутствовать.
. – (Десятичная точка) обозначает любой символ, кроме перевода строки: \n \r \u2028 or \u2029. (можно использовать [\s\S] для поиска любого символа, включая переводы строк).
(x) – Находит x и запоминает. Это называется “запоминающие скобки”. Например, /(foo)/ найдет и запомнит ‘foo’ в “foo bar.” Найденная подстрока хранится в массиве-результате поиска или в предопределенных свойствах объекта RegExp: $1, …, $9.
(?:x) – Находит x, но не запоминает найденное. Это называется “незапоминающие скобки”. Найденная подстрока не сохраняется в массиве результатов и свойствах RegExp. Как и все скобки, объединяют находящееся в них в единый подпаттерн.
x(?=y) – Находит x, только если за x следует y. Например, /Jack(?=Sprat)/ найдет ‘Jack’, только если за ним следует ‘Sprat’. /Jack(?=Sprat|Frost)/ найдет ‘Jack’, только если за ним следует ‘Sprat’ или ‘Frost’. Однако, ни ‘Sprat’ ни ‘Frost’ не войдут в результат поиска.
x(?!y) – Находит x, только если за x не следует y. Например, /\d+(?!\.)/ найдет число, только если за ним не следует десятичная точка. /\d+(?!\.)/.exec(“3.141”) найдет 141, но не 3.141.
x|y – Находит x или y. Например, /green|red/ найдет ‘green’ в “green apple” и ‘red’ в “red apple.”
{n} – Положительное целое число. Находит ровно n повторений предшествующего элемента.
{n,} – Положительное целое число. Находит n и более повторений элемента.
{n,m} – Положительные целые числа. Находят от n до m повторений элемента.
– Набор символов. Находит любой из перечисленных символов. Можно указать промежуток, используя тире. Например, – то же самое, что .
[^xyz] – Любой символ, кроме указанных в наборе. Также можно указать промежуток. Например, [^abc] – то же самое, что [^a-c].
[\b] – Находит символ backspace.
\b – Находит границу слов (латинских).
\B – Обозначает не границу слов. Например, /\w\Bn/ найдет ‘on’ в “noonday”, а /y\B\w/ найдет ‘ye’ в “possibly yesterday.”
\cX – X – буква от A до Z. Обозначает контрольный символ в строке. Например, /\cM/ обозначает символ Ctrl-M.
\d – Находит цифру из любого алфавита.
\D – Найдет нецифровой символ (все алфавиты). [^0-9] – эквивалент для обычных цифр.
\f,\r,\n – Соответствующие спецсимволы form-feed, line-feed, перевод строки.
\s – Найдет любой пробельный символ, включая пробел, табуляцию, переводы строки и другие юникодные пробельные символы.
\S – Найдет любой символ, кроме пробельного.
\t – Символ табуляции.
\v – Символ вертикальной табуляции.
\w – Найдет любой (латинский) словесный символ, включая буквы, цифры и знак подчеркивания. Эквивалентно .
\W – Найдет любой (не латинский) словесный символ. Эквивалентно [^A-Za-z0-9_].
\0 – Найдет символ NUL.
\xhh – Найдет символ с кодом hh (2 шестнадцатиричных цифры).
\uhhhh – Найдет символ с кодом hhhh (4 шестнадцатиричных цифры).
ФлагиФлаги регулярных выражений задают высокоуровневые правила соответствия шаблонам. В отличие от остальной грамматики регулярных выражений, флаги указываются не между символами слэша, а после второго из них. В языке JavaScript поддерживается три флага.
Флаг i указывает, что поиск по шаблону должен быть нечувствителен к регистру символов, а флаг g – что поиск должен быть глобальным, т.е. должны быть найдены все соответствия в строке. Флаг m выполняет поиск по шаблону в многострочном режиме. Если строковое выражение, в котором выполняется поиск, содержит символы перевода строк, то в этом режиме якорные символы ^ и $, помимо того, что они соответствуют началу и концу всего строкового выражения, также соответствуют началу и концу каждой текстовой строки. Флаги могут объединяться в любые комбинации.
Методы класса StringСтроки поддерживают четыре метода, использующие регулярные выражения.
Метод search()Он принимает в качестве аргумента регулярное выражение и возвращает либо позицию первого символа найденной подстроки, либо -1, если соответствие не найдено. Например, следующий вызов вернет 4:
Var result = "JavaScript".search(/script/i); // 4
Если аргумент метода search() не является регулярным выражением, он сначала преобразуется путем передачи конструктору RegExp. Метод search() не поддерживает глобальный поиск и игнорирует флаг g в своем аргументе.
Метод replace()Он выполняет операцию поиска с заменой. Он принимает в качестве первого аргумента регулярное выражение, а в качестве второго – строку замены. Метод отыскивает в строке, для которой он вызван, соответствие указанному шаблону. Если регулярное выражение содержит флаг g, метод replace() заменяет все найденные совпадения строкой замены. В противном случае он заменяет только первое найденное совпадение.
Метод match()Он принимает в качестве единственного аргумента регулярное выражение (или преобразует свой аргумент в регулярное выражение, передав его конструктору RegExp()) и возвращает массив, содержащий результаты поиска. Если в регулярном выражении установлен флаг g, метод возвращает массив всех соответствий, присутствующих в строке. Например:
// вернет ["1", "2", "3"] var result = "1 плюс 2 равно 3".match(/\d+/g);
Если регулярное выражение не содержит флаг g, метод match() не выполняет глобальный поиск; он просто ищет первое совпадение. Однако match() возвращает массив, даже когда метод не выполняет глобальный поиск. В этом случае первый элемент массива – это найденная подстрока, а все оставшиеся элементы представляют собой подвыражения регулярного выражения.
Метод split()Этот метод разбивает строку, для которой он вызван, на массив подстрок, используя аргумент в качестве разделителя. Например:
"123,456,789".split(","); // Вернет ["123","456","789"]
Метод split() может также принимать в качестве аргумента регулярное выражение. Это делает метод более мощным.
Объект RegExpКонструктор RegExp() принимает один или два строковых аргумента и создает новый объект RegExp. Первый аргумент конструктора – это строка, содержащая тело регулярного выражения, т.е. текст, который должен находиться между символами слэша в литерале регулярного выражения. Второй аргумент RegExp() может отсутствовать. Если он указан, то определяет флаги регулярного выражения. Это должен быть один из символов g, i, m либо комбинация этих символов.
Свойства RegExpКаждый объект RegExp имеет пять свойств:
- source – строка, доступная только для чтения, содержащая текст регулярного выражения.
- global – логическое значение, доступное только для чтения, определяющее наличие флага g в регулярном выражении.
- ignoreCase i в регулярном выражении.
- multiline – это логическое значение, доступное только для чтения, определяющее наличие флага m в регулярном выражении.
- lastIndex – это целое число, доступное для чтения и записи. Для шаблонов с флагом g это свойство содержит номер позиции в строке, с которой должен быть начат следующий поиск.
Объекты RegExp определяют два метода, выполняющие поиск по шаблону.
Метод exec()Метод exec() выполняет регулярное выражение для указанной строки, т.е. ищет совпадение в строке. Если совпадение не найдено, метод возвращает null. Однако если соответствие найдено, он возвращает такой же массив, как массив, возвращаемый методом match() для поиска без флага g .
Нулевой элемент массива содержит строку, соответствующую регулярному выражению, а все последующие элементы – подстроки, соответствующие всем подвыражениям. В отличие от match(), метод exec() возвращает массив, структура которого не зависит от наличия в регулярном выражении флага g .
Когда метод exec() вызывается для того же регулярного выражения второй раз, он начинает поиск с символа, позиция которого указана в свойстве lastIndex. Если exec() не находит соответствия, свойство lastIndex получает значение 0.
Метод test()Он принимает строку и возвращает true, если строка соответствует регулярному выражению:
Var pattern = /java/i; pattern.test("JavaScript"); // Вернет true
Вызов test() эквивалентен вызову exec(), возвращающему true, если exec() возвращает не null. По этой причине метод test() ведет себя так же, как метод exec() при вызове для глобального регулярного выражения: он начинает искать указанную строку с позиции, заданной свойством lastIndex, и если находит соответствие, устанавливает свойство lastIndex равным номеру позиции символа, непосредственно следующего за найденным соответствием.
Написание шаблонаШаблон регулярного выражения состоит из обычных символов, например /abc/, или комбинаций обычных и специальных символов, например /ab*c/ или /Chapter (\d+)\.\d*/. Последний пример включает в себя скобки, которые используются как “запоминающий механизм”. Соответствие этой части шаблона запоминается для дальнейшего использования.
Использование простых шаблоновПростые шаблоны используются для нахождения прямого соответствия в тексте. Например, шаблон /abc/ соответствует комбинации символов в строке только когда символы ‘abc’ встречаются вместе и в том же порядке.
Синтаксис регулярных выражений является достаточно сложным и его изучение требует серьёзных усилий. Наилучшим руководством по регулярным выражением на сегодняшний день является книга Дж. Фридла "Регулярные выражения", позволяющая, по словам автора, "научиться мыслить регулярными выражениями".
Основные понятияРегулярное выражение (regular expression) - средство для обработки строк или последовательность символов, определяющая шаблон текста.
Модификатор - предназначен для "инструктирования" регулярного выражения.
Метасимволы - специальные символы, которые служат командами языка регулярных выражений.
Регулярное выражение задаётся как обычная переменная, только вместо кавычек используется слэш, например: var reg=/рег_выражение/
Под простейшими шаблонами будем понимать такие шаблоны, которые не нуждаются в каких-либо специальных символах.
Допустим, нашей задачей является замена всех букв "р" (малых и заглавных) на латинскую большую букву "R" в словосочетании Регулярные выражения
.
Создаём шаблон var reg=/р/ и воспользуясь методом replace осуществляем задуманное
var reg=/р/
document.write(result)
В результате получим строку - РегуляRные выражения , замена произошла только на первом вхождении буквы "р" с учётом регистра.
Но под условия нашей задачи этот результат не подходит... Тут нам понадобятся модификаторы
"g" и "i", которые могут использоваться как отдельно, так и совместно. Эти модификаторы ставятся в конце шаблона регулярного выражения, после слэша, и имеют следующие значения:
модификатор
"g" - задаёт поиск в строке как "глобальный", т.е. в нашем случае замена произойдет для всех вхождений буквы "р". Теперь шаблон выглядит так: var reg=/р/g
, подставив его в наш код
var str="Регулярные выражения"
var reg=/р/g
var result=str.replace(reg, "R")
document.write(result)
получим строку - РегуляRные выRажения .
модификатор "i"
- задаёт поиск в строке без учёта регистра, добавив этот модификатор в наш шаблон var reg=/р/gi
, после выполнения скрипта получим искомый результат нашей задачи - RегуляRные выRажения
.
Метасимволы задают тип символов искомой строки, способ окружения искомой строки в тексте, а так же количество символов отдельного типа в просматриваемом тексте. Поэтому метасимволы можно разделить на три группы:
- Метасимволы поиска совпадений.
- Количественные метасимволы.
- Метасимволы позиционирования.
Значение | Описание | ||
граница слова | задаёт условие, при котором шаблон должен выполняться в начале или конце слова | /\ber/
совпадает с error
, не совпадает с hero
или с player
|
|
не граница слова | задаёт условие, при котором шаблон не выполняется в начале или конце слова | /\Ber/
совпадает с hero
или с player
, не совпадает с error
|
|
цифра от 0 до 9 | /\d\d\d\d/ совпадает с любым четырёх значным числом |
||
/\D\D\D\D/ не совпадёт с 2005 или 05.г или №126 и т.д. |
|||
одиночный пустой символ | соответствует символу пробела | \over\sbyte\ совпадает только с over byte |
|
одиночный непустой символ | любой один символ за исключением пробела | \over\Sbyte\ совпадает с over-byte или с over_byte , не совпадает с over byte или over--byte |
|
буква, цифра или символ подчёркивания | /A\w/ совпадает с A1 или с AB , не совпадает с A+ |
||
не буква, цифра или символ подчёркивания | /A\W/ не совпадает с A1 или с AB , совпадает с A+ |
||
любой символ | любые знаки, буквы, цифры и т.д. | /.../ совпадает с любыми тремя символами ABC или !@4 или 1 q |
|
набор символов | задаёт условие, при котором шаблон должен выполняться при любом совпадении символов заключенных в квадратные скобки | /WERTY/ совпадает с QWERTY , с AWERTY |
|
набор не входящих символов | задаёт условие, при котором шаблон не должен выполняться при любом совпадении символов заключенных в квадратные скобки | /[^QA]WERTY/ не совпадает с QWERTY , с AWERTY |
Символы, приведенные в таблице "Метасимволы поиска совпадений" не надо путать с последовательностью знаков перехода используемых в строках, таких как \\t - табуляция, \\n - переход на новую строку и т.д.
Количественные метасимволыКоличество совпадений | ||
Ноль и большее количество раз | /Ja*vaScript/ совпадает с JvaScript или с JaavaScript или с JaaavaScript , не совпадает с JovaScript |
|
Ноль или один раз | /Ja?vaScript/ совпадает только с JvaScript или с JavaScript |
|
Один и большее количество раз | /Ja+vaScript/ совпадает с JavaScript или с JaavaScript или с JaaavaScript , не совпадает с JvaScript |
|
точно n раз | /Ja{2}vaScript/ совпадает только с JaavaScript |
|
n или большее количество раз | /Ja{2,}vaScript/ совпадает с JaavaScript или с JaaavaScript , не совпадает с JvaScript или с JavaScript |
|
по крайней мере, n раз, но не более чем m раз | /Ja{2,3}vaScript/ совпадает только с JaavaScript или с JaaavaScript |
Каждый символ, приведенный в таблице "Количественные метасимволы" применяется к одному предшествующему символу или метасимволу в регулярном выражении.
Метасимволы позиционированияПоследний набор метасимволов предназначен для обозначения, где искать (если это важно) подстроку в начале строки или в конце.
Некоторые методы для работы с шаблонамиreplace - данный метод мы уже использовали в самом начале статьи, он предназначен для поиска образца и замены найденной подстроки на новую подстроку.
exec - данный метод выполняет сопоставление строки с образцом, заданным шаблоном. Если сопоставление с образцом закончилось неудачей, то возвращается значение null . В противном случае результатом является массив подстрок, соответствующих заданному образцу. /*Первый элемент массива будет равен исходной строке удовлетворяющее заданному шаблону*/
например:
var reg=/(\d+).(\d+).(\d+)/
var arr=reg.exec("Я родился 15.09.1980")
document.write("Дата рождения: ", arr, "< br>")
document.write("День рождения: ", arr, "< br>")
document.write("Месяц рождения: ", arr, "< br>")
document.write("Год рождения: ", arr, "< br>")
в результате получим четыре строки:
Дата рождения: 15.09.1980
День рождения: 15
Месяц рождения: 09
Год рождения: 1980
В статье отображено далеко не все возможности и прелести регулярных выражений, для более глубокого изучения этого вопроса посоветую изучить объект RegExp. Так же хочу обратить внимание на то, что синтаксис регулярных выражений не чем не отличается как в JavaScript, так и в PHP. К примеру, для проверки правильности ввода e-mail, регулярное выражение, что для JavaScript, что для PHP будет выглядеть одинаково /+@+.{2,3}/i .
new RegExp(pattern[, flags])регелярное выражение ЗАРАНЕЕ
Известно, то предпочтительнее синтаксис литерала (/test/i).
Если же регулярное выражение заранее неизвестно, то предпочтительнее создавать регулярное выражение (в символьной строке) при помощи конструктора (new RegExp).
Но обратите внимание, так как "знак косой черты" \ играет роль переключения кода, то в строковом литереале (new RegExp) его приходится писать дважды: \\
Флагиi игнорирование регистра при сопоставлении
g глобальное сопоставление, в отличие от локального (по умолчанию, совпадение только с первым экземпляром шаблоном) допускает совпадения со всеми экземплярами шаблона
Операторы| флаг | делает рег. выражение не зависящим от регистра | /testik/i |
| флаг | глобальный поиск | /testik/g |
| флаг | допускает сопоставление со многими строками, которые могут быть получены из textarea | |
| оператор класса символов | сопоставление с набором символов | - любой символ в интервале от a до z; |
| оператор знак вставки | кроме | [^a-z] - любой символ КРОМЕ символов в интервале от a до z; |
| оператор дефис | указываем диапозон значений, включительно | - любой символ в интервале от a до z; |
| оператор экранирования | экранирует любой следующий символ | \\ |
| оператор начала сопоставления | сопоставление с шаблоном должно произойти в начале | /^testik/g |
| оператор конца сопоставления | сопоставление с шаблоном должно произойти в конце | /testik$/g |
| оператор? | делает символ необязательным | /t?est/g |
| оператор + | /t+est/g | |
| оператор + | символ должен присутстовать однократно или многократно | /t+est/g |
| оператор * | символ должен присутстовать однократно или многократно или вообще отсутствовать | /t+est/g |
| оператор {} | задаем фиксированное число повторений символа | /t{4}est/g |
| оператор {,} | задаем число повторений символа в определенных пределах | /t{4,9}est/g |
| горизонтальная табуляция |
| Перевод строки |
| Любой символ, кроме Перевода строки |
| Любая десят-я цифра, что равнозначно |
| Любой символ, кроме десят-я цифры, что равнозначно [^0-9] |
| Любой символ (цифры, буквы и знак подчеркивания) что равнозначно |
| Любой символ, кроме цифр, букв и знака подчеркивания, что равнозначно [^A-Za-z0-9] |
| Любой символ пробела |
| Любой символ, кроме пробела |
| Граница слова |
| НЕ Граница слова, а его внутр. часть |
Если оператор, например, + (/(abcd)+/) требуется применить к группе члеров, то можно воспользоваться круглыми скобками () .
ФиксацииЧасть регулярного выражения, заключенная в круглые скобки () , назывыется фиксацией .
Рассмотрим следующий пример:
/^()k\1/
\1 это не любой символ из a , b , c .
\1 это какой угодно символ, который инициирует совпадение с первым символом
. То есть символ совпавший с
\1 неизвестен до разрешения регулярного выражения.
Скобки () используются в 2-х случаях: для группирования и для обозначение фиксаций. Но бывают ситуации, когда нам нужно использовать () только для группирования, так как фиксация не требуется, кроме того, убирая лишние фиксации мы облегчаем работу механизму обработки регулярных выражений.
Итак, чтобы предотвратить фиксацию перед открывающей круглой скобкой необходимо поставить: ?:
Str = "Hello world!"; found = str.match(/]*?)>/i); console.log("found without fix: ", found); // [ "" ]
Функция test Regexp.test()Функция test проверяет, есть ли совпадение регулярного выражения со строкой (str). Возвращает или true или false .
Пример использования:
Javascript function codeF(str){ return /^\d{5}-\d{2}/.test(str); } //console.log(codeF("12345-12ss")); // true //console.log(codeF("1245-12ss")); // false Функция match str.match(regexp)Функция match возвращает массив значений или null , если совпадений не найдено. Отметьте : если в регулярном выражении отсутствует флаг g (для выполнения глобального поиска), то метод match вернет первое совпадение в строке, при этом, как видно из примера, в массив совпадений попадают ФИКСАЦИИ (часть регулярного выражения заключенная в круглые скобки).
Javascript str = "За информацией обратитесь: Глава 3.4.5.1"; re = /глава (\d+(\.\d)*)/i // с фиксациями (без глобального флажка) found = str.match(re) console.log(found); // ["Глава 3.4.5.1", "3.4.5.1", ".1"]Если же предоставить методу match() глобальное регулярное выражение (с флажком g), то будет возвращен также массив, но с ГЛОБАЛЬНЫМИ совпадениями . То есть зафиксированные результаты не возвращаются.
Javascript str = "За информацией обратитесь: Глава 3.4.5.1, Глава 7.5"; re = /глава (\d+(\.\d)*)/ig // без фиксаций - глобально found = str.match(re) console.log(found); // ["Глава 3.4.5.1", "Глава 7.5"] Функция exec regexp.exec(str)Функция exec проверяет, есть ли совпадение регулярного выражения со строкой (str). Возвращает массив результатов (с фиксациями) или null . При каждом последующем вызове метода exec (например, при использовании while) происходит (за счет автоматического обновления при выполнении exec индекса конца последнего поиска lastIndex) переход к следующему глобальному совпадению (если у казан флажок g).
Javascript var html = "BAM! BUM!"; var reg = /]*?)>/g; //console.log(reg.exec(html)); // ["", "", "div", " class="test""] while((match = reg.exec(html)) !== null){ console.log(reg.exec(html)); } /* ["", "", "b", ""] ["", "", "em", ""] ["", "/", "div", ""] */Без глобального флажка методы match и exec работают идентично. То есть возвращают массив с первым глобальным совпадением и фиксациями.
Javascript // match var html = "BAM! BUM!"; var reg = /]*?)>/; // без глобального console.log(html.match(reg)); // ["", "", "div", " class="test""] // exec var html = "BAM! BUM!"; var reg = /]*?)>/; // без глобального console.log(reg.exec(html)); // ["", "", "div", " class="test""] Функция replace str.replace(regexp, newSubStr|function)- regexp - рег. выражение;
- newSubStr - строка, на которую меняется найденное выражение в тексте;
- function - вызывается для каждого обнаруженного совпадения с переменным списком параметров (напомним, что при глобальном поиске в строке обнаруживаются все экземпляры совпадения с шаблоном).
Возвращаемое значение данной функции служит в качестве замены.
Параметры функции :
- 1 - Полная совпавшая подстрока.
- 2 - Значение скобочных групп (фиксаций).
- 3 - Индекс (позиция) совпадения в исходной строке.
- 4 - Исходная строка.
Mетод не меняет вызывающую строку, а возвращает новую, после замены совпадений. Чтобы произвести глобальный поиск и замену, используйте regexp c флагом g .
"GHGHGHGTTTT".replace(//g,"K"); //"KKKKKKKKKKK"
Javascript function upLetter(allStr,letter) { return letter.toUpperCase(); } var res = "border-top-width".replace(/-(\w)/g, upLetter); console.log(res); //borderTopWidth
