Краткое обсуждение использования объектов и скобок Regexp для регулярных выражений JS

Создание объекта regexp:

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

var reg1 =/'/w+'/g;

var reg2 = new Regexp ('/' // w+/'', 'g');

Сравнивая два метода создания, первый параметр в REGEXP - это обычная строка, которая будет создана. С одной стороны, это не прямое представление количества, поэтому оно не покрывается чертой "/"; Вместо этого кавычка "" "" и «Символ побега»/«» должен быть квадратичный сбег в строке.

Кроме того, будь то прямое количество или конструктор regexp (), новый объект Regexp генерируется и присваивается переменной.

Сходства и различия между match () и exec ():

Матч и EXEC являются общими способами соответствия строк для регулярных выражений. Функции, реализованные двумя, похожи, с некоторыми тонкими различиями:

1. Как использовать

Матч - это метод обертывания объектов с помощью струн, использование: string.match (regexp);

EXEC - это метод регулярного объекта выражения, использование: regexp.exec (String);

2. Возвращенные результаты

Когда regexp не устанавливает глобальный флаг "G":

Результаты возврата обоих одинаковы. То есть, когда нет соответствующего значения, оно возвращает ноль, а когда есть соответствующее значение, оно возвращает массив (давайте массив). Массив [0] - это соответствующая строка, массив [1], массив [2] ... соответствует подстрокам, соответствующим скобки в регулярных выражениях. В то же время, массив имеет два свойства. Array.index представляет начальную позицию соответствующей строки, а Array.Input представляет собой извлекаемую строку.

Когда у Regexp есть набор глобального флага "G":

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

Exec ничем не отличается от производительности без глобального лейбла "G". Возвращенный массив, массив [0] - это текущая соответствующая строка, массив [1], массив [2] ... это текущая соответствующая строка. В настоящее время обратите внимание на свойство FantIndex объекта REGEXP, которое представляет последнюю позицию в конце соответствующей строки в исходной строке. Когда дальнейшее соответствующий результат не будет, свойство LastIndex устанавливается на 0. Следовательно, вы можете использовать цикл LastIndex, чтобы найти все соответствующие строки.

Поддержите несколько методов сопоставления:

JS -код

 var teststr = "Теперь тест 001 test002"; var re =/test (/d+)/ig; var r = ""; while (r = re.exec (teststr)) {alert (r [0] + "" + r [1]); }

Кроме того, вы также можете использовать teststr.match (re), но таким образом, нет возможности G, и вы можете получить только первый матч.

1. Правила регулярного выражения

1.1 Обычные символы

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

Пример 1: Когда выражение «c» при сопоставлении строки «Abcde» результатом соответствующего: успех; Соответствующий контент: «C»; Соответствующая позиция: Начните с 2 и заканчивается в 3. (Примечание: индекс начинается с 0 или 1, что может варьироваться в зависимости от текущего языка программирования)

Пример 2: Когда выражение «BCD» при сопоставлении строки «ABCDE» результат сопоставления: успешно; Соответствующий контент: «BCD»; Соответствующая позиция: начните с 1 и заканчивается в 4.

1.2 Простые экологичные персонажи

Для некоторых символов, которые неудобны для написания, используйте метод добавления «/» к фронту. Мы уже знакомы с этими персонажами.

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

Соответствующий метод этих сбежавших символов похож на «нормальные символы». Это также соответствует тому же персонажу.

Пример 1: Когда выражение «/$ d», при сопоставлении строки «ABC $ de», соответствующий результат: успех; Соответствующий контент: "$ D"; Соответствующая позиция: начните с 3 и конец в 5.

1.3 выражения, которые могут соответствовать «нескольким символам»

Некоторые методы представления в регулярных выражениях могут соответствовать любому из «нескольких символов». Например, выражение "/D" может соответствовать любому числу. Хотя он может соответствовать любому персонажу в нем, он может быть только одним, а не множественным. Это похоже на игру в покерные карты, большие и маленькие короли могут заменить любую карту, но они могут заменить только одну карту.

Пример 1: Когда выражение «/d/d» при сопоставлении «ABC123» результатом совпадения является: успех; Соответствующий контент: «12»; Соответствующая позиция: начните с 3 и конец в 5.

Пример 2: Когда выражение «A./D» при сопоставлении «AAA100» результатом совпадения является: успех; Соответствующий контент: «AA1»; Соответствующая позиция: начните с 1 и заканчивается в 4.

1.4 Настройте выражения, которые могут соответствовать «нескольким символам»

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

Пример 1: Когда выражение «[BCD] [BCD]« соответствует «ABC123», результатом совпадения является: успех; Соответствующий контент: «BC»; Соответствующая позиция: начните с 1 и заканчивается в 3.

Пример 2: Когда выражение «[^abc]» соответствует «ABC123», результатом совпадения является: успех; Соответствующий контент: «1»; Соответствующая позиция: Начните с 3 и конец в 4.

1.5 Специальные символы, которые изменяют количество совпадений

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

Метод использования: «количество модификации» размещается после «модифицированного выражения». Например: «[BCD] [BCD]» можно записать как «[BCD] {2}».

Пример 1: Когда выражение "/d+/.?/d*" соответствует "оно стоит 12,5 долларов", результат совпадения: успешно; Соответствующий контент: "12.5"; Соответствующая позиция: начните с 10 и конец в 14.

Пример 2: Когда выражение «go {2,8} gle» соответствует «рекламе Gooooogle», результат матча: успех; Соответствующий контент: «Gooooogle»; Соответствующая позиция: начните с 7 и конец в 17.

1.6 Некоторые другие специальные символы, представляющие абстрактное значение

Некоторые символы представляют особое значение абстракции в выражениях:

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

Пример 1: Когда выражение «^aaa» соответствует «xxx aaa xxx», результат сопоставления: не удастся. Потому что «^» требует сопоставления, где начинается строка, «^aaa» может соответствовать только тогда, когда «AAA» находится в начале строки, например: «AAA XXX XXX».

Пример 2: Когда выражение «AAA $» соответствует «XXX AAA XXX», результат сопоставления: не удастся. Поскольку «$» требует соответствия конец строки, «AAA $» может соответствовать только тогда, когда «AAA» находится в конце строки, например: «XXX XXX AAA».

Пример 3: Когда выражение "./b." соответствует "@@@ abc", соответствующий результат: успешно; Соответствующий контент: "@a"; Соответствующая позиция: начните с 2 и конец в 4.

Дальнейшее объяснение: «/b» аналогична «^» и «$», что не соответствует самим персонажам, но требуется, чтобы оно было на левой и правой сторонах позиции в результате сопоставления, одна сторона-диапазон «/w», а другая-это диапазон не-”/w».

Пример 4: Когда выражение "/bend/b" Matches "Weekend, Endfor, End", соответствующий результат: успешно; Соответствующий контент: «конец»; Соответствующая позиция: начните с 15 и заканчивается в 18 лет.

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

Пример 5: Когда выражение «Том | Джек» соответствует струне «Я Том, он Джек», соответствующий результат: успешно; Соответствующий контент: «Том»; Соответствующая позиция: начните с 4 и конец в 7. При сопоставлении следующего результат сопоставления: успешно; Соответствующий контент: «Джек»; При подходящей позиции: начинается с 15 и заканчивается в 19.

Пример 6: Выражение "(Go/S*)+" При сопоставлении "Let's Go Go!", Соответствующий результат: успешно; Соответствующий контент: «Иди иди иди иди»; Соответствующая позиция: начните с 6 и заканчивается в 14.

Пример 7: Когда выражение «￥ (/d+/.?/D*)» сопоставлено с «￥ 10,9, ￥ 20,5», результат совпадения: успешно; Соответствующий контент: «￥ 20,5»; Соответствующая позиция: Начните с 6 и конец в 10. Содержание, которое получает диапазон кронштейнов отдельно,: «20,5».

2. Некоторые передовые правила в регулярных выражениях

2.1 жадность и не-середины во время матча

При использовании специальных символов, которые изменяют количество совпадений, существует несколько методов представления, которые позволяют одному и тому же выражению, чтобы соответствовать различным временам, например: «{m, n}», «{m,}», "?", "?", "" ","+". Конкретное количество матчей зависит от соответствующей строки. Это выражение с неопределенным количеством повторяющихся совпадений всегда совпадает как можно много раз в процессе сопоставления. Например, для текста "dxxxdxxxd" следующее:

Видно, что когда «/w+» соответствует, он всегда соответствует как можно большему количеству персонажей, которые соответствуют его правилам. Хотя во втором примере он не соответствует последнему «D», это также должно сделать успешное соответствие все выражение. Точно так же выражения с «*» и «{m, n}» соответствуют как можно большему количеству, и выражения с "?" также «совпадают» как можно больше, когда они могут соответствовать или несоответствие. Этот принцип сопоставления называется «жадностью».

Не-зеленого режима:

Добавление "?" Знак после изменения специального символа количества совпадений может сделать выражения с различным количеством совпадений матчей как можно меньше, так что выражения, которые могут соответствовать или несоответствие, могут быть «сопоставлены» как можно больше. Этот соответствующий принцип называется «не-зеленым» шаблоном, также называемым рисунком «Барб». Если есть несколько совпадений, это приведет к выходу из строя все выражение. Подобно жадному режиму, режим нежестников будет соответствовать минимальной степени, чтобы все выражение успешно соответствовало. Например, для текста "DXXXDXXXD":

Для получения дополнительной информации, пожалуйста, обратитесь к следующему:

Пример 1: Когда выражение "<td> (.*) </Td>" соответствует строке "<Td> <p> aa </p> </td> <td> <p> bb </p> </td>", результат сопоставления: успех; Матч - «<td> <p> aa </p> </td>« вся строка, а «</td>» в выражении будет соответствовать последнему «</td>» в строке.

Пример 2: Напротив, когда выражение «<td> (.*?) Когда вы снова сопоставите следующий, вы получите второй "<Td> <p> bb </p> </td>".

2.2 Backreferences /1, /2 ...

Когда выражение соответствует, двигатель выражения записывает строку, соответствующую выражению, содержащемуся в кронштейне "()". При получении соответствующего результата строка, соответствующая выражению, содержащемуся в скобках, может быть получена отдельно. Это было продемонстрировано много раз в предыдущих примерах. В практических приложениях, когда определенная граница используется для поиска, а содержание, которое нужно получить, не содержит границ, скобки должны использоваться для указания желаемого диапазона. Например, предыдущий "<td> (.*?) </Td>".

Фактически, «строка, соответствующая выражению, содержащемуся в кронштейнах», может использоваться не только после окончания матча, но и во время процесса соответствия. Часть после выражения может относиться к предыдущей «подпочтистой строке, которая была сопоставлена» в скобках. Справочный метод состоит в том, чтобы добавить число "/". «/1» относится к строке, соответствующей первой паре кронштейнов »,/2» относится к строке, соответствующей второй паре кронштейнов ... и так далее, если одна пара кронштейнов содержит другую пару кронштейнов, внешние кронштейны сначала отсортируются. Другими словами, если у пары есть левый кронштейн »(« Раньше, то пара будет отсортирована сначала.

В качестве примера:

Пример 1: Выражение "('|") (.*?) (/1) "При сопоставлении" "Привет", "Мир" "Результат совпадения: успешно; соответствующий контент:" "Привет". При сопоставлении следующего снова вы можете соответствовать "" World "".

Пример 2: Когда выражение "(/w)/1 {4,}" соответствует "AA BBBB ABCDEFG CCCCC 111121111 999999999999", результат совпадения: успешно; Соответствующий контент - «CCCCCC». Когда вы снова сопоставите следующий, вы получите 999999999. Это выражение требует, чтобы символы в диапазоне «/w» повторялись не менее 5 раз, обращая внимание на разницу от «/w {5,}».

Пример 3: Выражение «<(/w+)/s*(/w+(= ('|»).*?/4)?/S*)*>.*? успешный.

2.3 Предварительный поиск, несоответствие; Обратный предварительный поиск, несоответствие

В предыдущей главе я говорил о нескольких специальных символах, представляющих абстрактные значения: «^», «$», «/b». Все они имеют одну общую черту: они сами не соответствуют каким -либо символам, а только прикрепляют условие к «двум концу строки» или «щели между символами». После понимания этой концепции этот раздел будет продолжать вводить еще один более гибкий метод представления, который добавляет условия к «двум концам» или «щели».

Перемесенный предварительный поиск: "(? = XXXXX)", "(?! XXXXX)"

Формат: «(? = XXXXX)», в соответствующей строке условие, прикрепленное к «щели» или «два конца», состоит в том, что правая сторона зазора должна соответствовать выражению части XXXXX. Поскольку это всего лишь дополнительное условие в этом разрыве, оно не влияет на последующее выражение, чтобы по -настоящему соответствовать персонажам после этого разрыва. Это похоже на «/b», что не соответствует самим персонажам. «/B» просто берет персонажей до и после разрыва и выносит суждение и не повлияет на выражения, стоящие за по -настоящему.

Пример 1: Когда выражение «Windows (? = NT | XP)» соответствует «Windows 98, Windows NT, Windows 2000», оно будет соответствовать «Windows» в «Windows NT», и другие слова «Windows» не будут сопоставлены.

Пример 2: выражение "(/w) ((? =/1/1/1) (/1))+" При сопоставлении строки "AAA ffffff 999999999", он сможет сопоставить первые 4 из 6 "F" и первые 7 из 9 "9". Это выражение можно прочитать и интерпретировать как: Повторение буквенно -цифрового числа более 4 раза будет соответствовать детали до последних 2 цифр. Конечно, это выражение не может быть написано таким образом, и цель здесь предназначена для демонстрационных целей.

Формат: «(?! XXXXX)», правая сторона зазора не должна соответствовать выражению xxxxx.

Пример 3: Выражение "((?!/Bstop/b).)+" При сопоставлении "fdjka ljfdl Stop fjdsla fdj", он будет сопоставлен с начала до позиции до «остановки». Если в строке нет «остановки», вся строка будет сопоставлена.

Пример 4: Выражение "Do (?!/W)" может совпадать с "Do" при сопоставлении строки "Dode, Do, Dog". В этой статье эффект использования «DO» после »(?

Обратный предварительный поиск: "(? <= Xxxxx)", "(? <! XXXXX)"

Концепции этих двух форматов похожи на предварительный поиск. Требования для обратного предварительного поиска: «левая сторона» разрыва. Два формата требуют, чтобы они могли соответствовать и не могли соответствовать указанному выражению, а не судить о правой стороне. Подобно «Первоначальному поиску»: они оба являются дополнительным условием для разрыва, в котором они расположены и не соответствуют самим персонажам.

Пример 5: Выражение "(? <=/D {4})/d+(? Поскольку jscript.regexp не поддерживает обратный предварительный поиск, эта статья не может быть продемонстрирована. Многие другие двигатели могут поддерживать обратный предварительный поиск, такие как: java.util.regex Package выше Java 1.4, System.Text.RegularexPressions пространства имен в .net, и самый простой и самый простой регулярный двигатель Deelx, рекомендованный этим сайтом.

3. Другие общие правила

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

3.1 В выражениях «/xxx» и «/uxxxx» можно использовать для представления символа («x» означает шестнадцатеричное число)

3.2. В то время как выражения «/s», «/d», «/w», «/b» представляют собой особые значения, соответствующие буквы заглавного средства представляют собой противоположные значения

3.3 В выражении существует особое значение, и необходимо добавить «/», чтобы соответствовать сводке символа самого символа.

3.4 Субэкспрессия в скобках "()". Если вы хотите, чтобы результат соответствия не был записан для будущего использования, вы можете использовать формат «(?: XXXXX)»

Пример 1: Когда выражение "(? Соответствующий результат кронштейна "(? :)" Диапазон не записан, так что "(/w)" используется для его ссылки.

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

4. Другие советы

4.1.

4.2 Если вы хотите потребовать выражения, чтобы соответствовать всей строке, вместо того, чтобы найти часть из строки, вы можете использовать «^» и «$» в начале и в конце выражения, например: «^/D+$» требует, чтобы вся строка имела только цифры.

4.3 Если контент, необходимый для сопоставления, является полным словом, а не частью слова, то используйте «/b» в начале и в конце выражения, например: используйте «/b(if|whilewaillsewoid|int..int...)/b», чтобы соответствовать ключевым словам в программе.

4.4 Выражение не соответствует пустой строке. В противном случае матч будет успешным все время, и ничего не будет сопоставлено. Например: когда вы готовитесь написать выражение, которое соответствует «123», «123.», «123,5», «.5» и т. Д., Целые числа, десятичные точки и десятичные числа могут быть опущены, но не писать выражение как: «/д*/.?/D*», потому что, если это не может быть успешно соответствовать выражению. Лучший способ написать это: "/d+/.?/d*|/./d+".

4.5 Не бесконечно разбирайтесь на подпоставлениях, которые могут соответствовать пустым струнам. Если каждая часть подэкспрессии в кронштейнах может соответствовать 0 раз, а скобки в целом могут соответствовать бесконечному времени, то ситуация может быть более серьезной, чем говорится в предыдущей статье, и процесс сопоставления может быть мертвой петлей. Хотя некоторые двигатели регулярного выражения теперь избегали мертвой петли в этой ситуации, таких как регулярные выражения .NET, мы все равно должны стараться избежать этой ситуации. Если мы сталкиваемся с мертвой петлей при написании выражений, мы также можем начать с этой точки зрения и выяснить, является ли это причиной, упомянутой в этой статье.

4.6. Разумно выберите жадный режим и не-сильный режим, см. Обсуждение темы.

4.7 или "|" С левой и правой стороны лучше всего соответствовать только одной стороне определенного персонажа, чтобы выражения с обеих сторон «|» не будет отличаться из -за обменной позиции.

Следующая статья -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1. Определите регулярные выражения

1) Существует две формы определения регулярных выражений, одна - обычный метод, а другая - метод конструктора.

2) Нормальный метод: var reg =/expression/дополнительные параметры

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

Дополнительные параметры: используется для расширения значения выражения, в настоящее время существует три основных параметра:

G: означает, что глобальное соответствие может быть выполнено.

Я: это означает нечувствительное соответствие случая.

М: означает, что можно выполнить несколько сопоставления строк.

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

пример:

var reg =/a*b/;

var reg =/abc+f/g;

3) Метод конструктора: var reg = new Regexp («Выражение», «Добавить параметры»);

Значение «выражения» и «дополнительных параметров» совпадает с методом определения выше.

пример:

var reg = new Regexp ("a*b");

var reg = new Regexp ("abc+f", "g");

4) Разница между обычными методами и методами конструктора

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

var reg = new Regexp (document.forms [0] .exprfiled.value, "g");

2. Схема экспрессии

1) Паттерн выражения относится к методу выражения и стилю выражения, то есть как описать «выражение» в var reg =/expression/дополнительные параметры?

2) С стандартизированной точки зрения паттерны экспрессии делятся на простые паттерны и составные паттерны.

3) Простой шаблон: относится к шаблону, выраженной через комбинацию обычных символов, например,

var reg =/abc0d/;

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

4) Составной шаблон: относится к шаблону, выраженному с помощью символов подстановочных знаков, например:

var reg =/a+b?/w/;

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

Давайте сосредоточимся на значении и использовании каждого подстановочного знака в композитном режиме.

5) Объяснение специальных символов в составном режиме:

1>/: используется в качестве экономного персонажа во многих языках программирования. Вообще говоря

Если / символ сопровождается обычным символом C, то / C представляет собой особое значение. Например, N первоначально представляет символ N, но /N представляет новую линию.

Если / символ сопровождается специальным символом C, то / C представляет обычный символ c. Например, / обычно используется в качестве экономного символа, но // используется для настройки обычного символа /.

Использование / в регулярном выражении JavaScript такое же, как и выше, но в разных языках программирования специальные таблицы символов могут быть разными.

2>^: Сопоставьте начало входной строки. Если это многострочное совпадение, то есть дополнительные параметры выражения содержат M, оно также будет сопоставлено после новой линии.

пример:

/^B/Сопоставьте первое B в "Bab bc"

Пример 2:

/^B/gm Сопоставление

«Бадд б

CDAF

B dsfb "

Первая строка в первой B, первая B в третьей строке

3> $: Сопоставьте конец входного создания символов. Если это многострочное совпадение, то есть дополнительные параметры выражения содержат M, оно также будет сопоставлено перед новой линией.

В отличие от использования ^.

Пример: / T $ / Matches T в «Bat», но не соответствует T в «ненависти»

Пример 2: /t $ /match

«Теги в

летучая мышь

Последний Т первой строки и Т второй строки.

4>*: Сопоставьте предыдущий символ 0 или более раз.

Пример: /ab* /matches "abbbb" в "dddabbbbc", а также совпадает "в" ddda "

5>+: Сопоставьте предыдущий символ 1 или более раз.

Пример: / ab+ / matches "abbbb" в "dddabbbbc", но не соответствует "ddda"

Аналогично использованию следующего {1,} (прототип: {n,})

6>?: Использование? это особенное. Вообще говоря, он используется, чтобы соответствовать предыдущему символу в 0 раз или 1 раз, но у него есть два других специальных применения:

Если сразу же после *, +, и {}, это означает минимальное количество совпадений исходного совпадения, например:

/ ba*/ изначально сопоставлялся «baaaa» в «bbbaaaa», но/ ba*?/ matched «b» в «bbbaaaa» (потому что*означает 0 или более совпадений, а плюс? должно означать минимальное количество совпадений, то есть 0 матчей).

Аналогично: / ba+? / Matches "ba" в "Baaaa".

В качестве символа синтаксической структуры он используется в предварительном сборе, то есть x (? = Y) и x (?! = Y), который будет упомянут позже.

7>.: "." Войдите в десятичную точку, соответствует любому отдельному символу, за исключением символа Newline.

Каковы персонажи в общей сложности? Пожалуйста, обратитесь к: набор символов

Например: / ab / matchs «acb» в «Acbaa», но не соответствует «ABB».

8> (x): означает сопоставление x (не относится к символу x или конкретно, ссылаясь на символ, x представляет строку), и совпадение запомнится. В синтаксисе этот вид () называется «захватом родителей», то есть скобки, используемые для захвата.

Матчи запоминаются, потому что в функциях, предоставленных выражением, некоторые функции возвращают массив, который содержит все соответствующие строки, такие как функция exec ().

Также обратите внимание, что предпосылка x in () запоминается, состоит в том, чтобы соответствовать x.

Пример 1:

var regx =/a (b) c/;

var rs = regx.exec ("abcddd");

Как видно из вышеперечисленного, / a (b) c / matches «abc» в «abcddd». Из -за () B также будет записывать его, поэтому содержание номера возвращается RS:

{abc, b}

Пример 2:

var regx =/a (b) c/;

var rs = regx.exec ("acbcddd");

RS возвращает NULL, потому что / a (b) C / не соответствует «acbcddd», поэтому B in () не будет записана (хотя строка содержит B)

9> (?: X): Сопоставьте X, но не помните x. () В этом формате называется «не капитальные родители», то есть в скобки для нехватки.

пример:

var regx =/a (?: b) c/;

var rs = regx.exec ("abcddd");

Как видно из вышеизложенного, / a (?: B) c / совпадение «ABC» в «Abcddd» из -за (? :), b не будет записано, поэтому содержание числа, возвращаемое RS:

{ABC}

10> X (? Если матч совпадает, только x запомнится, и Y не запомнится.

пример:

var regx =/user (? = name)/;

var rs = regx.exec («Имя пользователя - это Мэри»);

Результат: совпадение успешно, а значение RS - {пользователь}

11> x (? Если матч совпадает, только x запомнится, и Y не запомнится.

пример:

var regx =/user (?! name)/;

var rs = regx.exec («Имя пользователя - Мэри»);

Результат: совпадение успешно, а значение RS - {пользователь}

Пример 2:

var regx = // d+(?!/.)/;

var rs=regx.exec(“54.235”);

Result: The matching result, the value of rs is {5}, and the mismatch is because 54 is followed by the "." знак. Of course, 235 also matches, but due to the behavior of the exec method, 235 will not be returned.

12>x|y：匹配x或y。注意如果x和y都匹配上了，那么只记住x。

пример:

var regx=/beijing|shanghai/;

var rs=regx.exec(“I love beijing and shanghai”);

结果：匹配成功，rs的值为{beijing}，虽然shanghai也匹配，但不会被记住。

13>{n}：匹配前一个字符的n次出现。

n必须是一个非负数，当然如果是一个负数或小数也不会报语法错误。

пример:

var regx=/ab{2}c/;

var rs=regx.exec(“abbcd”);

结果：匹配成功，rs的值为：{abbc}。

14>{n,}：匹配前一个字符的至少n次出现。

пример:

var regx=/ab{2,}c/;

var rs=regx.exec(“abbcdabbbc”);

结果：匹配成功，rs的值为：{abbc}。注意为什么abbbc也符合条件为什么没有被记住，这与exec方法的行为有关，后面会统一讲解。

15>{n,m}：匹配前一个字符的至少n次最多m次的出现。

只要n与m为数字，而且m>=n就不会报语法错误。

пример:

var regx=/ab{2,5}c/;

var rs=regx.exec(“abbbcd”);

结果：匹配成功，rs的值为：{abbbc}。

Пример 2:

var regx=/ab{2,2}c/;

var rs=regx.exec(“abbcd”);

结果：匹配成功，rs的值为：{abbc}。

例子3：

var regx=/ab(2,5)/;

var rs=regx.exec(“abbbbbbbbbb”);

Result: The match is successful, and the value of rs is: {abbbbb}, which means that if the previous character appears more than m times, it will only match m times. кроме того:

var regx=/ab(2,5)c/;

var rs=regx.exec(“abbbbbbbbbbc”);

结果：匹配失败，rs的值为：null，为什么匹配失败，因为b多于5个则b(2,5)会匹配前5个b，，而表达式/ab(2,5)c/中b后面是c，但字符串中5个b之后还是b所以会报错。

16>[xyz]：xyz表示一个字符串，该模式表示匹配[]中的一个字符，形式上[xyz]等同于[xz]。

пример:

var regx=/a[bc]d/;

var rs=regx.exec(“abddgg”);

结果：匹配成功，rs的值为：{abd}

Пример 2:

var regx=/a[bc]d/;

var rs=regx.exec(“abcd”);

结果：匹配失败，rs的值为：null，之所以失败，是因为[bc]表示匹配b或c中的一个，但不会同时匹配。

17>[^xyz]：该模式表示匹配非[]中的一个字符，形式上[^xyz]等同于[^xz]。

пример:

var regx=/a[^bc]d/;

var rs=regx.exec(“afddgg”);

结果：匹配成功，rs的值为：{afd}

Пример 2:

var regx=/a[^bc]d/;

var rs=regx.exec(“abd”);

结果：匹配失败，rs的值为：。

18>[/b]：匹配退格键。

19>/b：匹配一个词的边界符，例如空格和换行符等等，当然匹配换行符时，表达式应该附加参数m。

пример:

var regx=//bc./;

var rs=regx.exec(“Beijing is a beautiful city”);

结果：匹配成功，rs的值为：{ci}，注意c前边的空格不会匹配到结果中，即{ ci}是不正确的。

20>/B：代表一个非单词边界。

пример:

var regx=//Bi./;

var rs=regx.exec(“Beijing is a beautiful city”);

结果：匹配成功，rs的值为：{ij}，即匹配了Beijing中的ij。

21>/cX，匹配一个控制字符。例如， /cM 匹配一个Control-M 或

回车符。 x 的值必须为AZ 或az 之一。否则，将c 视为一

个原义的'c' 字符。（实际的例子还需补充）

21>/d：匹配一个数字字符，等同于[0-9]。

пример:

var regx=/user/d/;

var rs=regx.exec(“user1”);

结果：匹配成功，rs的值为：{user1}

22>/D：匹配一个非数字字符，等同于[^0-9]。

пример:

var regx=/user/D/;

var rs=regx.exec(“userA”);

结果：匹配成功，rs的值为：{userA}

23>/f：匹配一个换页符。

24>/n：匹配一个换行符。因为是换行符，所以在表达式中要加入m参数。

пример:

var regx=/a/nbc/m;

var str=“a

bc”;

var rs=regx.exec(str);

结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。

25>/r：匹配一个回车符

26>/s：匹配一个空格符，等同于[ /f/n/r/t/v/u00A0/u2028/u2029].

пример:

var regx=//si/;

var rs=regx.exec(“Beijing is a city”);

结果：匹配成功，rs的值为：{ i}

27>/S：匹配一个非空格符，等同于[ ^/f/n/r/t/v/u00A0/u2028/u2029].

пример:

var regx=//Si/;

var rs=regx.exec(“Beijing is a city”);

结果：匹配成功，rs的值为：{ei}

28>/t：匹配一个tab

пример:

var regx=/a/tb/;

var rs=regx.exec(“a bc”);

结果：匹配成功，rs的值为： {a bc}

29>/v：匹配一个竖向的tab

30>/w：匹配一个数字、_或字母表字符，即[A-Za-z0-9_ ]。

пример:

var regx=//w/;

var rs=regx.exec(“$25.23”);

结果：匹配成功，rs的值为：{2}

31>/W：匹配一个非数字、_或字母表字符，即[^A-Za-z0-9_ ]。

пример:

var regx=//w/;

var rs=regx.exec(“$25.23”);

结果：匹配成功，rs的值为：{$}

32>/n：注意不是/n，这里n是一个正整数，表示匹配第n个()中的字符。

пример:

var regx=/user([,-])group/1role/;

var rs=regx.exec(“user-group-role”);

结果：匹配成功，rs的值为：{user-group-role,-}，同样对user,group,role的匹配也是成功的，但像user-group,role等就不对了。

33>/0：匹配一个NUL字符。

34>/xhh：匹配一个由两位16进制数字所表达的字符。

35>/uhhhh：匹配一个由四位16进制数字所表达的字符。

3，表达式操作

1）表达式操作，在这里是指和表达式相关的方法，我们将介绍六个方法。

2）表达式对象（RegExp）方法：

1>exec(str)，返回str中与表达式相匹配的第一个字符串，而且以数组的形式表现，当然如果表达式中含有捕捉用的小括号，则返回的数组中也可能含有()中的匹配字符串，例如：

var regx=//d+/;

var rs=regx.exec(“3432ddf53”);

返回的rs值为：{3432}

var regx2=new RegExp(“ab(/d+)c”);

var rs2=regx2.exec(“ab234c44”);

返回的rs值为：{ab234c,234}

In addition, if there are multiple suitable matches, exec is executed for the first time and exec is continued, the second and third matches are returned in turn. Например:

var regx=/user/d/g;

var rs=regx.exec(“ddduser1dsfuser2dd”);

var rs1=regx.exec(“ddduser1dsfuser2dd”);

则rs的值为{user1}，rs的值为{rs2}，当然注意regx中的g参数是必须的，否则无论exec执行多少次，都返回第一个匹配。后面还有相关内容涉及到对此想象的解释。

2>test(str), determines whether the string str matches the expression, and returns a boolean value. Например:

var regx=/user/d+/g;

var flag=regx.test(“user12dd”);

flag的值为true。

3）String对象方法

1>match(expr)，返回与expr相匹配的一个字符串数组，如果没有加参数g，则返回第一个匹配，加入参数g则返回所有的匹配

пример:

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.match(regx);

rs的值为：{user1,user3}

2>search(expr)，返回字符串中与expr相匹配的第一个匹配的index值。

пример:

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.search(regx);

rs的值为：0

3>replace(expr,str)，将字符串中匹配expr的部分替换为str。另外在replace方法中，str中可以含有一种变量符号$，格式为$n，代表匹配中被记住的第n的匹配字符串（注意小括号可以记忆匹配）。

пример:

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.replace(regx,”00”);

rs的值为：003userddd0045

Пример 2:

var regx=/u(se)r/d/g;

var str=“user13userddduser345”;

var rs=str.replace(regx,”$1”);

rs的值为：se3userdddse45

对于replace(expr,str)方法还要特别注意一点，如果expr是一个表达式对象则会进行全局替换（此时表达式必须附加参数g，否则也只是替换第一个匹配），如果expr是一个字符串对象，则只会替换第一个匹配的部分，例如：

var regx=“user”

var str=“user13userddduser345”;

var rs=str.replace(regx,”00”);

rs的值为： 0013userddduser345

4>split(expr)，将字符串以匹配expr的部分做分割，返回一个数组，而且表达式是否附加参数g都没有关系，结果是一样的。

пример:

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.split(regx);

rs的值为：{3userddd,45}

4，表达式相关属性

1）表达式相关属性，是指和表达式相关的属性，如下面的形式：

var regx=/myexpr/;

var rs=regx.exec(str);

其中，和表达式自身regx相关的属性有两个，和表达式匹配结果rs相关的属性有三个，下面将逐一介绍。

2）和表达式自身相关的两个属性：

1>lastIndex，返回开始下一个匹配的位置，注意必须是全局匹配（表达式中带有g参数）时，lastIndex才会有不断返回下一个匹配值，否则该值为总是返回第一个下一个匹配位置，例如：

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var lastIndex1=regx.lastIndex;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var lastIndex2=regx.lastIndex;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var lastIndex3=regx.lastIndex;

上面lastIndex1为9，第二个lastIndex2也为9，第三个也是9；如果regx=/user/d/g，则第一个为9，第二个为18，第三个为0。

2>source, return the expression string itself. Например:

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var source=regx.source;

source的值为user/d

3）和匹配结果相关的三个属性：

1>index, return the current matching position. Например:

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var index1=rs.index;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var index2=rs.index;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var index3=rs.index;

index1为4，index2为4，index3为4，如果表达式加入参数g，则index1为4，index2为13，index3会报错（index为空或不是对象）。

2>input, used for matching strings. Например:

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var input=rs.input;

input的值为sdsfuser1dfsfuser2。

3>[0]，返回匹配结果中的第一个匹配值，对于match而言可能返回一个多值的数字，则除了[0]外，还可以取[1]、[2]等等。例如：

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var value1=rs[0];

rs=regx.exec(“sdsfuser1dfsfuser2”);

var value2=rs[0];

value1的值为user1,value2的值为user2

5，实际应用

1）实际应用一

描述：有一表单，其中有一个“用户名”input域

要求：汉字，而且不能少于2个汉字，不能多于4个汉字。

выполнить:

 <script>function checkForm(obj){ var username=obj.username.value; var regx=/^[/u4e00-/u9fa5]{2,4}$/g if(!regx.test(username)){ alert("Invalid username!"); вернуть ложь; } return true;}</script><form name="myForm" onSubmit="return checkForm(this)"> <input type="text" name="username"/> <input type="submit" vlaue="submit"/>

2）实际应用二

描述：给定一个含有html标记的字符串，要求将其中的html标记去掉。

выполнить:

 <script>function toPlainText(htmlStr){ var regx=/<[^>]*>|<//[^>]*>/gm; var str=htmlStr.replace(regx,""); return str;}</script><form name=“myForm”> <textarea id=“htmlInput”></textarea> <input type=“button” value=“submit” onclick=“toPlainText(document.getElementById('htmlInput').value”/></form>

三，小结

1，Javascript正则表达式，我想在一般的程序员之中，使用者应该不是很多，因为我们处理的页面一般都不是很复杂，而复杂的逻辑一般我们都在后台处理完成了。但是目前趋势已经出现了扭转，富客户端已经被越来越多的人接受，而Javascript就是其中的关键技术，对于复杂的客户端逻辑而言，正则表达式的作用也是很关键的，同时它也是Javascript高手必须要掌握的重要技术之一。

2，为了能够便于大家对前面讲述的内容有一个更为综合和深刻的认识，我将前面的一些关键点和容易犯糊涂的地方再系统总结一下，这部分很关键！

总结1：附件参数g的用法

表达式加上参数g之后，表明可以进行全局匹配，注意这里“可以”的含义。我们详细叙述：

1) For the exec method of the expression object, if g is not added, it will only return the first match, no matter how many times it is executed, if g is added, the first execution will also return the first match, and then the execution will return the second match, and so on. Например

var regx=/user/d/;

var str=“user18dsdfuser2dsfsd”;

var rs=regx.exec(str);//此时rs的值为{user1}

var rs2=regx.exec(str);//此时rs的值依然为{user1}

如果regx=/user/d/g；则rs的值为{user1}，rs2的值为{user2}

通过这个例子说明：对于exec方法，表达式加入了g，并不是说执行exec方法就可以返回所有的匹配，而是说加入了g之后，我可以通过某种方式得到所有的匹配，这里的“方式”对于exec而言，就是依次执行这个方法即可。

2）对于表达式对象的test方法，加入g于不加上g没有什么区别。

3) For the match method of the String object, g is not added, and it only returns the first match. If the match method is executed all the time, it always returns the first match. If g is added, then all matches will be returned at once (note that this is different from the exec method of the expression object. For exec, even if g is added, all matches will not be returned at once). Например:

var regx=/user/d/;

var str=“user1sdfsffuser2dfsdf”;

var rs=str.match(regx);//此时rs的值为{user1}

var rs2=str.match(regx);//此时rs的值依然为{user1}

如果regx=/user/d/g，则rs的值为{user1,user2}，rs2的值也为{user1,user2}

4）对于String对象的replace方法，表达式不加入g，则只替换第一个匹配，如果加入g，则替换所有匹配。（开头的三道测试题能很好的说明这一点）

5）对于String对象的split方法，加上g与不加g是一样的，即：

var sep=/user/d/;

var array=“user1dfsfuser2dfsf”.split(sep);

则array的值为{dfsf, dfsf}

此时sep=/user/d/g，返回值是一样的。

6）对于String对象的search方法，加不加g也是一样的。

总结2：附加参数m的用法

附加参数m，表明可以进行多行匹配，但是这个只有当使用^和$模式时才会起作用，在其他的模式中，加不加入m都可以进行多行匹配（其实说多行的字符串也是一个普通字符串），我们举例说明这一点

1）使用^的例子

var regx=/^b./g;var str=“bd76 dfsdf sdfsdfs dffs b76dsf sdfsdf”;var rs=str.match(regx);

此时加入g和不加入g，都只返回第一个匹配{bd}，如果regx=/^b./gm，则返回所有的匹配{bd,b7}，注意如果regx=/^b./m，则也只返回第一个匹配。所以，加入m表明可以进行多行匹配，加入g表明可以进行全局匹配，综合到一起就是可以进行多行全局匹配

2）使用其他模式的例子，例如

var regx=/user/d/;var str=“sdfsfsdfsdf sdfsuser3 dffs b76dsf user6”;var rs=str.match(regx);

此时不加参数g，则返回{user3}，加入参数g返回{user3,user6}，加不加入m对此没有影响。

3）因此对于m我们要清楚它的使用，记住它只对^和$模式起作用，在这两种模式中，m的作用为：如果不加入m，则只能在第一行进行匹配，如果加入m则可以在所有的行进行匹配。我们再看一个^的例子

var regx=/^b./;var str=“ret76 dfsdf bjfsdfs dffs b76dsf sdfsdf”;var rs=str.match(regx);

此时rs的值为null，如果加入g，rs的值仍然为null，如果加入m，则rs的值为{bj}（也就是说，在第一行没有找到匹配，因为有参数m，所以可以继续去下面的行去找是否有匹配），如果m和g都加上，则返回{bj,b7}（只加m不加g说明，可以去多行进行匹配，但是找到一个匹配后就返回，加入g表明将多行中所有的匹配返回，当然对于match方法是如此，对于exec呢，则需要执行多次才能依次返回）

总结3：

在HTML的textarea输入域中，按一个Enter键，对应的控制字符为“/r/n”，即“回车换行”，而不是“/n/r”，即“换行回车”，我们看一个前面我们举过的例子：

 var regx=/a/r/nbc/;var str=“a bc”;var rs=regx.exec(str);

结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。

The above article briefly discusses the use of RegExp objects and brackets for JS regular expressions is all the content I share with you. Я надеюсь, что это может дать вам ссылку, и я надеюсь, что вы сможете поддержать Wulin.com больше.