Регистрация Войти
Войти через VK




Поиск по сайту



PHP Поиск



Вот пример веб-разработки на сайте наших партнеров.

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

Общее описание

Регулярные выражения представляют собой образцы для поиска заданных комбинаций символов в текстовых строках (такой поиск называется сопоставлением с образцом). Существует два способа присваивания переменным регулярных выражений, а именно:
Использование инициализатора объекта: var re = /pattern/switch?.
Использование конструктора RegExp: var re = new RegExp("pattern"[,"switch"]?).
Здесь pattern - регулярное выражение, а switch - необязательные опции поиска.

Инициализаторы объекта, например, var re = /ab+c/, следует применять в тех случаях, когда значение регулярного выражения остается неизменным во время работы сценария. Такие регулярные выражения компилируются в процессе загрузки сценария и, следовательно, выполняются быстрее.

Вызов конструктора, например, var re = new RegExp("ab+c"), следует применять в тех случаях, когда значение переменной будет меняться. Если вы собираетесь использовать регулярное выражение несколько раз, то имеет смысл скомпилировать его методом compile для более эффективного поиска образцов.

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

var re = /\w+/g;
var re = new RegExp("\\w+", "g"); // В строке "\" должно заменяться на "\\"

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

Регулярные выражения используются методами exec и test объекта RegExp и методами match, replace, search и split объекта String. Если нам нужно просто проверить, содержит ли данная строка подстроку, соответствующую образцу, то используются методы test или search. Если же нам необходимо извлечь подстроку (или подстроки), соответствующие образцу, то нам придется воспользоваться методами exec или match. Метод replace обеспечивает поиск заданной подстроки и замены ее на другую строку, а метод split позволяет разбить строку на несколько подстрок, основываясь на регулярном выражении или обычной текстовой строке. Более подробные сведения о применении регулярных выражений приведены в описании соответствующих методов.

Синтаксис регулярных выражений

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

Специальные символы в регулярных выражениях:

\ - Для символов, которые обычно трактуются буквально, означает, что следующий символ является специальным. Например, /n/ соответствует букве n, а /\n/ соответствует символу перевода строки. Для символов, которые обычно трактуются как специальные, означает, что символ должен пониматься буквально. Например, /^/ означает начало строки, а /\^/ соответствует просто символу ^. /\\/ соответствует обратной косой черте \.

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

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

* - Соответствует повторению предыдущего символа нуль или более раз.

+ - Соответствует повторению предыдущего символа один или более раз.

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

. - Соответствует любому символу, кроме символа новой строки.

(pattern) - Соответствует строке pattern и запоминает найденное соответствие.

(?:pattern) - Соответствует строке pattern, но не запоминает найденное соответствие. Используется для группировки частей образца, например, /ко(?:т|шка)/ - это краткая запись выражения /кот|кошка/.

(?=pattern) - Соответствие с "заглядыванием вперед", происходит при соответствии строки pattern без запоминания найденного соответствия. Например, /Windows (?=95|98|NT|2000)/ соответствует "Windows " в строке "Windows 98", но не соответствует в строке "Windows 3.1". После сопоставления поиск продолжается с позиции, следующей за найденным соответствием, без учета заглядывания вперед.

(?!pattern) - Соответствие с "заглядыванием вперед", происходит при несоответствии строки pattern без запоминания найденного соответствия. Например, /Windows (?!95|98|NT|2000)/ соответствует "Windows " в строке "Windows 3.1", но не соответствует в строке "Windows 98". После сопоставления поиск продолжается с позиции, следующей за найденным соответствием, без учета заглядывания вперед.

x|y - Соответствует x или y.

{n} - n - неотрицательное число. Соответствует ровно n вхождениям предыдущего символа.

{n,} - n - неотрицательное число. Соответствует n или более вхождениям предыдущего символа. /x{1,}/ эквивалентно /x+/. /x{0,}/ эквивалентно /x*/.

{n,m} - n и m - неотрицательное числа. Соответствует не менее чем n и не более чем m вхождениям предыдущего символа. /x{0,1}/ эквивалентно /x?/.

[xyz] - Соответствует любому символу из заключенных в квадратные скобки.

[^xyz] - Соответствует любому символу, кроме заключенных в квадратные скобки.

[a-z] - Соответствует любому символу в указанном диапазоне.

[^a-z] - Соответствует любому символу, кроме лежащих в указанном диапазоне.

\b - Соответствует границе слова, т. е. позиции между словом и пробелом или переводом строки.

\B - Соответствует любой позиции, кроме границе слова.

\сX - Соответствует символу Ctrl+X. Например, /\cI/ эквивалентно /\t/.

\d - Соответствует цифре. Эквивалентно [0-9].

\D - Соответствует нецифровому символу. Эквивалентно [^0-9].

\f - Соответствует символу перевода формата (FF).

\n - Соответствует символу перевода строки (LF).

\r - Соответствует символу возврата каретки (CR).

\s - Соответствует символу пробела. Эквивалентно /[ \f\n\r\t\v]/.

\S - Соответствует любому непробельному символу. Эквивалентно /[^ \f\n\r\t\v]/.

\t - Соответствует символу табуляции (HT).

\v - Соответствует символу вертикальной табуляции (VT).

\w - Соответствует латинской букве, цифре или подчеркиванию. Эквивалентно /[A-Za-z0-9_] /.

\W - Соответствует любому символу, кроме латинской буквы, цифры или подчеркивания.
Эквивалентно /[^A-Za-z0-9_] /.

\nn - положительное число. Соответствует n-ной запомненной подстроке. Вычисляется путем подсчета левых круглых скобок. Если левых скобок до этого символа меньше, чем n, то эквивалентно \0n.

\0nn - восьмеричное число, не большее 377. Соответствует символу с восьмеричным кодом n. Например, /\011/ эквивалентно /\t/.

\xnn - шестнадцатеричное число, состоящее из двух цифр. Соответствует символу с шестнадцатеричным кодом n. Например, /\x31/ эквивалентно /1/.

\unn - шестнадцатеричное число, состоящее из четырех цифр. Соответствует символу Unicode с шестнадцатеричным кодом n. Например, /\u00A9/ эквивалентно /c/.

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

Операции:
\
() (?:) (?=) (?!) []
* + ? . {n} {n,} {n,m}
^ $ \метасимвол
|

Опции поиска

При создании регулярного выражения мы можем указать дополнительных опции поиска:
i (ignore case). Не различать строчные и прописные буквы.
g (global search). Глобальный поиск всех вхождений образца.
m (multiline). Многострочный ввод должен рассматриваться как несколько строк. Если используется флаг m, то ^ и $ совпадают в начале и в конце любой строки общей строки ввода, вместо начала и конца всей строки ввода.
Любые комбинации этих трех опций, например ig или gim.

Пример.

var s = "Изучаем язык JavaScript";
var re = /JAVA/;
var result = re.test(s) ? "" " : "" не ";
document.write("Строка "" + s + result + "соответствует образцу " + re);

Поскольку регулярные выражения различают строчные и прописные буквы, этот пример выведет в окно обозревателя текст:
Строка "Изучаем язык JavaScript" не соответствует образцу /JAVA/

Если мы теперь заменим вторую строку примера на var re = /JAVA/i;, то на экран будет выведен текст:
Строка "Изучаем язык JavaScript" соответствует образцу /JAVA/i


Теперь рассмотрим опцию глобального поиска. Она обычно применяется методом replace при поиске образца и замены найденной подстроки на новую. Дело в том, что по умолчанию этот метод производит замену только первой найденной подстроки и возвращает полученный результат. Рассмотрим следующий сценарий:

var s = "Мы пишем сценарии на JavaScript, " +
"но JavaScript - не единственный сценарный язык.";
var re = /JavaScript/;
document.write(s.replace(re, "VBScript"));

Он выводит в окно обозревателя текст, который явно не соответствует желаемому результату: Мы пишем сценарии на VBScript, но JavaScript - не единственный сценарный язык. Для того, чтобы все вхождения строки "JavaScript" были заменены на "VBScript", мы должны изменить значение регулярного выражения на var re = /JavaScript/g;. Тогда результирующая строка будет иметь вид:
Мы пишем сценарии на VBScript, но VBScript - не единственный сценарный язык.

Наконец, опция многострочного поиска позволяет проводить сопоставление с образцом строкового выражения, состоящего из нескольких строк текста, соединенных символами разрыва строки. По умолчанию, сопоставление с образцом прекращается, если найден символ разрыва строки. Данная опция преодолевает указанное ограничение и обеспечивает поиск образца по всей исходной строке. Она также влияет на интерпретацию некоторых специальных символов в регулярных выражениях, а именно: Обычно символ ^ сопоставляется только с первым элементом строки. Если же опция многострочного поиска включена, то он также сопоставляется с любым элементом строки, которому предшествует символ разрыва строки. Обычно символ $ сопоставляется только с последним элементом строки. Если же опция многострочного поиска включена, то он также сопоставляется с любым элементом строки, который является символом разрыва строки.

Запоминание найденных подстрок

Если часть регулярного выражения заключена в круглые скобки, то соответствующая ей подстрока будет запомнена для последующего использования. Для доступа к запомненным подстрокам используются свойства $1, :, $9 объекта RegExp или элементы массива, возвращаемого методами exec и match. В последнем случае количество найденных и запомненных подстрок не ограничено.

Следующий сценарий использует метод replace для перестановки слов в строке. Для замены найденного текста используются свойства $1 и $2.

var re = /(\w+)\s(\w+)/i;
var str = "Mikhail Bulgakov";
document.write(str.replace(re, "$2, $1"))
Этот сценарий выведет в окно обозревателя текст:
Bulgakov, Mikhail

т.к. \w = [A-Za-z0-9_] для многих браузеров, то русские буквы работать не будут. Если мы хотим гарантированно использовать русские буквы, то нам прийдется немножко модифицировать код:

var re = /([а-я]+)\s([а-я]+)/i;
var str = "Михаил Булгаков";
document.write(str.replace(re, "$2, $1")); // Булгаков, Михаил
Этот сценарий выведет в окно обозревателя текст:
Булгаков, Михаил

Введение

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

Основные понятия

Регулярное выражение (regular expression) - средство для обработки строк или последовательность символов, определяющая шаблон текста.

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

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

var reg=/рег_выражение/

Под простейшими шаблонами будем понимать такие шаблоны, которые не нуждаются в каких-либо специальных символах.

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

Создаём шаблон var reg=/р/ и воспользуясь методом replace осуществляем задуманное

<script language="JavaScript">
	var str="Регулярные выражения"
	var reg=/р/
	var result=str.replace(reg, "R")
	document.write(result)
</script>

В результате получим строку 'РегуляRные выражения', замена произошла только на первом вхождении буквы "р" с учётом регистра. Но под условия нашей задачи этот результат не подходит... Тут нам понадобятся модификаторы "g" и "i", которые могут использоваться как отдельно, так и совместно.
Эти модификаторы ставятся в конце шаблона регулярного выражения, после слэша, и имеют следующие значения: модификатор "g" - задаёт поиск в строке как "глобальный", т.е. в нашем случае замена произойдет для всех вхождений буквы "р". Теперь шаблон выглядит так: var reg=/р/g, подставив его в наш код

<script language="JavaScript">
	var str="Регулярные выражения"
	var reg=/р/g
	var result=str.replace(reg, "R")
	document.write(result)
</script>
получим строку 'РегуляRные выRажения'.

Модификатор "i" - задаёт поиск в строке без учёта регистра, добавив этот модификатор в наш шаблон var reg=/р/gi, после выполнения скрипта получим искомый результат нашей задачи - 'RегуляRные выRажения'.

Специальные символы (метасимволы)

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

Метасимволы поиска совпадений.
Количественные метасимволы.
Метасимволы позиционирования.
Метасимволы поиска совпадений



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

\B не граница слова, задаёт условие, при котором шаблон не выполняется в начале или конце слова.

\d цифра от 0 до 9.

\D не цифра.

\s одиночный пустой символ, соответствует символу пробела.

\S одиночный непустой символ, любой один символ за исключением пробела.

\w буква, цифра или символ подчёркивания.

\W не буква, цифра или символ подчёркивания.

. любой символ, любые знаки, буквы, цифры и т.д.

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

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

Количественные метасимволы

* ноль и большее количество раз.

? Ноль или один раз

+ Один и большее количество раз.

{n} точно n раз.

{n,} n или большее количество раз.

{n,m} по крайней мере, n раз, но не более чем m раз.

Метасимволы позиционирования

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

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

Некоторые методы для работы с шаблонами

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

test - данный метод проверяет, есть ли совпадения в строке относительно шаблона и возвращает false, если сопоставление с образцом закончилось неудачей, в противном случае true.

Пример:

<script language="JavaScript">
	var str="JavaScript"
	var reg=/PHP/
	var result=reg.test(str)
	document.write(result)
</script>

выведет в качестве результата false, т.к. строка "JavaScript" не равна строке "PHP".

Также метод test может возвращать вместо true или false любую другую строку заданную программистом.
например:

<script language="JavaScript">
	var str="JavaScript"
	var reg=/PHP/
	var result=reg.test(str) ? "Строка совпала" : "Строка не совпала"
	document.write(result)
</script>
в этом случае в качестве результата будет строка 'Строка не совпала'.

exec -- данный метод выполняет сопоставление строки с образцом, заданным шаблоном. Если сопоставление с образцом закончилось неудачей, то возвращается значение null. В противном случае результатом является массив подстрок, соответствующих заданному образцу. /*Первый элемент массива будет равен исходной строке удовлетворяющее заданному шаблону*/
например:

<script language="JavaScript">
	var reg=/(\d+).(\d+).(\d+)/
	var arr=reg.exec("Я родился 15.09.1980")
	document.write("Дата рождения: ", arr[0], "< br>")
	document.write("День рождения: ", arr[1], "< br>")
	document.write("Месяц рождения: ", arr[2], "< br>")
	document.write("Год рождения: ", arr[3], "< br>")
</script>

в результате получим четыре строки:
Дата рождения: 15.09.1980
День рождения: 15
Месяц рождения: 09
Год рождения: 1980

Заключение

В статье отображено далеко не все возможности и прелести регулярных выражений, для более глубокого изучения этого вопроса посоветую изучить объект RegExp. Так же хочу обратить внимание на то, что синтаксис регулярных выражений не чем не отличается как в JavaScript, так и в PHP. К примеру, для проверки правильности ввода e-mail, регулярное выражение, что для JavaScript, что для PHP будет выглядеть одинаково:

/[0-9a-z_]+@ [0-9a-z_^.]+.[a-z]{2,3}/i
Регулярные выражения - это своего рода шаблоны поиска определенных комбинаций символов в строках, при этом регулярные выражения заключаются в слэши. Ниже перечислены литералы регулярных выражений.

Литералы

Литерал Описание
\ Входит в состав специальных символов, а так же дает понять интерпретатору, что следующий символ - не литерал. Используется перед восьмеричными кодами символов для извлечения из памяти сохраненных подвыражений и для использования в регулярном выражении литерала.
^ Начало строки
$ Конец строки
* Означает, что предшествующий символ должен встретиться в строке много раз или не встретиться
+ Означает, что предшествующий символ должен встретиться в строке один или несколько раз
? Означает, что предшествующий символ должен встретиться в строке один раз или не встретиться
{число} Означает, что предшествующий символ должен встретиться в строке указаное число раз
{число, } Означает, что предшествующий символ должен встретиться в строке указаное число раз и более
{число1, число2} Означает, что предшествующий символ должен встретиться в строке от первого до второго числа раз
. Означает любой символ кроме \n (новая строка)
(подвыражение) Ищет подвыражение и сохраняет в памяти найденую группу символов
\номер группы Извлекает указанную группу символов, сохраненную с помощью предыдущего литерала
символ1|символ 2 Ищет один из двух символов
[набор символов] Ищет символ из заданого набора
[^набор символов] Ищет любой символ, не вошедший в набор
\b Означает границу слова, позицию между словом и пробелом
\B Означает границу пробела, позицию между пробелом и словом
\c Совпадает с управляющем символом вида "Ctrl"+"символ"
\d Любая цифра
\D Любой нецифровой символ
\f Символ перевода страницы
\n Символ новой строки
\r Символ возврата каретки
\s Пробел, табуляция, новая строка или перевод строки
\t Табуляция
\v Вертикальная табуляция
\w Буква, цифра или подчеркивание
\xКод Символ с указанным шеснадцатеричным кодом
\oКод Символ с указанным восмеричным кодом
\номер группы Извлекает из памяти, сохраненную ранее группу символов с заданным номером

Пример

/(\w+)@({\w\._}+)/

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


Операторы для работы с регулярными выражениями в Javascript

exec(regexp) - находит все совпадения (вхождения в шаблон "регулярки") в строке. Возвращает массив (при совпадении) и обновляет свойство regexp-а, или null - если ничего не найдено,. С модификатором g - при каждом вызове этой функции, она будет возвращать следующее совпадение после предыдущего найденного - это реализовано с помощью ведения индекса смещения последнего поиска.

match(regexp) - найти часть строки по шаблону. Если указан модификатор g, то функция match() возвращает массив всех совпадений или null (а не пустой массив). Без модификатора g эта функция работает как exec();

test(regexp) - функция проверяет строку на соответствие шаблону. Возвращает true - если есть совпадение, и false - если совпадения нет.

replace(regexp, mix) - метод возвращает строку изменную в соответствии с шаблоном (регуляррным выражением). Первый параметр regexp также может содержать строку, а не регулярное выражение. Без модификатора g - метод в строке заменяет только первое вхождение; с модификатором g - происходит глобальная замена, т.е. меняются все вхождения в данной строке. mix - шаблон замены, может принитать значения строки, шаблона замены, функции (имя функции).

Стоит подробнее остановиться на методе replace(), его второй параметр mix нужно описать более детально.

Если второй параметр mix содержит строку, то мы можем использовать следующие спецсимволы:

  • $$ - вставить $;
  • $& - совпавшая подстрока;
  • $` - часть строки перед совпавшей подстроки;
  • $' - часть строки после совпавшей подстроки;
  • $n ($nn) - значение n-ой запоминающей скобки (если первый аргумент - объект RegExp);

Если второй параметр mix содержит функцию, то она будет вызванна при каждом совпадении. Значением для замены будет результат работы функции, т.е. return '';

Примеры таких функции:

function replacer(sub, n1, n2, offset, str) {
// Что будет в параметрах функции:
// sub = 'my XXzz'; - полная совпавшая строка
// n1 = 'XX';
// n2 = 'zz';
/* n1, n2 - если первым параметром метода replace() указать регулярное выражение,
   то в этих переменных будут находится порядковые значения запоминающих скобок.
   Этих параметров будет столько же, сколько и запоминающих скобок.
   Последние два параметра сдвигаются в конец. */
// offset = 3; - позиция совпадения в строке, с нуля.
// str = 'my XXzz'; - полная обрабатываемая строка.</p>
return n1 + ", " + n2;
}
newString = "my XXzz".replace(/(X+)(z+)/, replacer)

Следующий вызов replace возвратит XXzzzz - XX , zzzz.

function replacer(str, p1, p2, offset, s)
{
return str + " - " + p1 + " , " + p2;
}
var newString = "XXzzzz".replace(/(X*)(z*)/, replacer)

Как видите, тут две скобки в регулярном выражении, и потому в функции два параметра p1, p2. Если бы были три скобки, то в функцию пришлось бы добавить параметр p3.

Следующая функция заменяет слова типа borderTop на border-top:

function styleHyphenFormat(propertyName)
{
  function upperToHyphenLower(match)
  {
    return '-' + match.toLowerCase();
  }
  return propertyName.replace(/[A-Z]/, upperToHyphenLower);
}

Таким блоком кода я разбираю javascript вхождения в html:

<script>
var t='',text;
data=data.replace(new RegExp("<script([^>]*)>([\\s\\S]*?)<\/script>", "igm"),
    function(str, p1, p2, offset, s){
        if(p1.indexOf('src=')>0){
        var re2=new RegExp("src=[\'\"](.*?)[\'\"]","i"); var te2=re2.exec(p1);
        if(te2!=null)
            t=t+"\r\nLoadScript('"+te2[1]+"');";
        }else{ t=t+"\r\n"+p2.replace(/<!\-\-/g,"").replace(/\/\/\-\->/g,"");}
        return "";
    });
</script>

Класс RegExp

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

RegExp(Регулярное выражение, Флаги)

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

  • g - задается глобальный поиск, если этот флаг установлен, то выражение возвратит все подходящие слова.
  • i - игнорирование регистра символов
  • m - многострочный поиск

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

  • match - выполняет поиск в строке, используя регулярное выражение, переданное в качестве параметра и возвращает массив с результатами поиска. Если ничего не найдено, возвращается null.
  • replace - выполняет поиск и замену в строке, используя регулярные выражения, и возвращает полученную строку.
  • search - выполняет поик в строке, используя регулярное выражение, переданное в качестве параметра, и возвращает позицию первой подстроки, совпадающей с регулярным выражением.

Свойства

Свойство Описание
lastIndex Задает позицию начала поиска в строке
sourse Возвращает строку регулярного выражения (только чтение)
global Определяет наличие флага g и возвращает соответсявенно true или false
ignoreCase Определяет наличие флага i и возвращает соответсявенно true или false
multilane Определяет наличие флага m и возвращает соответсявенно true или false

Методы

Метод Описание
compile (Регулярное выражение g,i,m) Компилирует регулярное выражение во внутренний формат для ускорения работы, может использоваться для изменения регулярного выражения
exec(строка) Аналогичен методу match класса String, но строка, где нужно произвести поиск, передается в качестве параметра
test(строка) Аналогичен методу search класса String, возвращает true или false в зависимости о результатов поиска

Пример

var result, re, str;
str="http://www.netscape.com";
re=new RegExp ("w{3}","i");
result=str.match(re)

Здесь этот участок скрипта производит поиск текста "www" в строке, которая была присвоена переменной "str" без учета регистра, а метод match возвращает массив result, содержащий результаты поиска.


Глобальный объект RegExp

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

RegExp.свойство

Свойства

Свойство Описание
$номер подвыражения Возвращает одно из последних найденых подвыражений (зависит от номера). Номер может быть 1-9, т.к.интерпретатор хранит в этом свойстве только девять последних найденых подвыражений, для доступа к остальным используется массив, возвращенный методами match или exec
index Возвращает позицию в строке найденой подстроки
input|&_ Возвращает строку, где производится поиск
lastIndex Задает позицию начала поиска в строке
lastMatch|$& Возвращает последнюю найденую подстроку
lastParent|$+ Возвращает последнюю найденую группу символов, если в регулярном выражении использовались подвыражения
leftContext|$' Возвращает строку, составленую из всех символов от начала строки до последней найденой подстроки, не включая ее
rightContext|$' Возвращает строку, составленую из всех символов от последней найденой подстроки, не включая ее, до конца исходной строки

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

Жадность - это стремление интерпретатора захватить максимально длинную строку, которая соответствует шаблону. Например, у нас есть строка:

    z = 2 * (x + y) * (x - y)

Если мы хотим получить выражение в первых скобках, то попробуем задать вот такую маску: /\(.*\)/. Результат будет таким:

(x + y) * (x - y)

Обуздать жадность интерпретатора можно двумя способами:
1. В маске запретить двигаться дальше одной закрывающей скобки - /\([^\)]*\)/.
2. Воспользоваться ленивым квантификатором, добавив знак вопроса после звездочки - /\(.*?\)/.

После чего результат будет таким как мы и хотели:

(x + y)

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

ЖадныйЛенивый
* *?
+ +?
{n,} {n,}?

К сожалению, алгоритм поиск последовательностей в регулярных выражениях очень громоздкий - он имеет рекурсивный вид. Чтобы избежать ненужных итераций обычно используют ревнивые квантификаторы (сверхжадные). Но JavaScript, почему-то, их не поддерживает.

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

Разбор URL

var re, str, protocol, address, filename, result;
str="http//www.somedomain.ru/index2.html";
re=new RegExp("((\w+): \/\/)?([^/]+) (.*)?","i");
result=re.exec(str);
if (result !=null)
{
	protocol=RegExp.$2;
	address=RegExp.$3;
	filename=RegExp.$4;
}

Данный скрипт разбивает интернет адрес на несколько составных частей. В регелярном выражении использовалось несколько подвыражений, которые сохраняются интерпритатором следующим образом: сначала сохраняется внешнее выражение, а затем внутренее. После регулярного выражения следует строка (result=re.exec(str);), которая начинает разбивание адреса, а далее проверяется правильность адреса и, в случае положительного результата, происходит присваивание переменным соответствующих частей адреса.

Функция удаления пробелов в начале и конце строки

function trim(str)
{
  return str.toString().replace(/^[ ]+/, '').replace(/[ ]+$/, '');
}
Другой вариант:
function trim(str) {
    return str.replace(/^\s+|\s+$/g, '');
 }

Поиск музыки на странице

var mmReg = /(?:http:\/\/[\w.]+\/)?(?!:\/\/)[^<^>^"^'^\s]+\.(?:aiff|au|avi|flv|mid|mov|mp3|ogg|ra|rm|spl|swf|wav|wma|wmv)(?!\w)/ig;
this.tmp = this.allText.match(mmReg);
if (this.tmp && this.search_common_embeds)
   if ((this.tmp.length > 1))
      if((this.tmp.length > 2) || (this.tmp[0]!=this.tmp[1])) ...

Использование g для глобального последовательного поиска

var str = "Кошка покормила своих котят";
var pattern = /ко./gi;
var result = '';

while((find = pattern.exec(str)) != null) {
result += find + " - начинается с " + find.index + "-го символа<br/>";
result += "Дальше поиск начнется с " + pattern.lastIndex + "-го символа<br/><br/>";
}
document.write(result);

В браузере мы увидим такой результат:

Кош - начинается с 0-го символа Дальше поиск начнется с 3-го символа кор - начинается с 8-го символа Дальше поиск начнется с 11-го символа кот - начинается с 22-го символа Дальше поиск начнется с 25-го символа

Маску поиска и её параметры можно также указывать через конструктор объекта RegExp:

var pattern = new RegExp("ко.","gi");

Проверить регулярным выражением кириллическую (русскую) строку:

var regexp = /^[а-яё]+$/i;

Разбиваем числа на троичные (тысячные) группы:

$1 - эта переменная содержит значение первого соответствия (первые "запоминающие" скобки в регулярном выражении)

// Рецепт от Джеффри Фриддла
var regexp = '1234567890'.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1,');

Еще про регулярные выражения:


Читать дальше: Условная компиляция в JavaScript
.

Популярное:


Содержание:


Новое за неделю



Сейчас на сайте: 1253