предисловие
Регулярные выражения очень распространены в повседневной работе, но его магия может всегда существовать как магию для многих программистов. Большинство из регулярных выражений, используемых в работе, получены из онлайн-поиска, и требуется много времени, чтобы посмотреть документацию, если это больше сложный. Плуреднее положить его вместе. Вы глубоко затронуты? Однажды я увидел видео о регулярности в Интернете, что заставило меня получить много товаров. В то время я тщательно записал свои заметки и мою собственную идею и надеялся помочь большему количеству детских туфлей нуждающихся. В статье говорится о регулярности с нуля, что делает его немного долго. Вы можете собрать раздробленное время и медленно прочитать его. После того, как прочитал его, вы обязательно принесите пользу. Статья впервые опубликована вмой блог, следующий текст:
Регулярное выражение использует одну строку для описания и сопоставления серии строк, которые соответствуют правилу грамматики. Проще говоря, это сопоставление строк, удовлетворяющих условиям, по определенным правилам. Вот онлайн-инструмент для изучения регулярных выражений:regexper.com/, на сайте используются изображения и пояснения на английском языке…^\d{4}[/-]\d{2}[/-]\d{2}$Вот что показывает инструмент:
Разве это не очень интуитивно~
Объект регулярного выражения
Регулярные выражения поддерживаются в javaScript через встроенный объект RegExp.Существует два способа создания экземпляра объекта RegExp:
- буквальный
- Конструктор
1. Буквальный
Предположим, вам нужно сопоставить строчные буквы в английском предложении с прописными буквами IS, вы можете сделать это:
var reg = /\bis\b/;
var text = 'He is a boy, This is a dog. Where is she?';
var result = text.replace(reg,'IS');
console.log(result) //He IS a boy, This is a dog. Where is she?
Это заменит первое английское слово «is» на «IS». Если вы хотите заменить все слова «is» в предложении на «IS», вы должны написать:
var reg = /\bis\b/g;
var text = 'He is a boy, This is a dog. Where is she?';
var result = text.replace(reg,'IS');
console.log(result) //He IS a boy, This IS a dog. Where IS she?
Просто добавьте 'g' в конце регулярного выражения. 'g' означает глобальный, что означает глобальное соответствие. 'g' - это модификатор регулярных выражений, модификаторы:
- 'g': глобальный полнотекстовый поиск, не добавлять, искать до первой остановки
- 'i': игнорировать регистр игнорировать регистр, регистр по умолчанию чувствителен к регистру.
- 'm': множественный многострочный поиск, обнаруживает символы новой строки в строках, в основном влияет на использование идентификатора начала строки ^ и идентификатора конца $
Вы можете подумать, почему is в 'This' в предложении не соответствует успешному совпадению, это заслуга нашего '\b'.
'\b': соответствует границе слова, то есть положению между словом и пробелом. Например, «er\b» может соответствовать «er» в «never», но не «er» в «verb».
Регулярное выражение здесь имеет «\ b» до и после «is», поэтому оно может соответствовать только слову «is».
Конструктор
Если вам нужно использовать конструктор для создания экземпляра регулярного, приведенную выше литеральную форму можно изменить на это:
var reg = new RegExp('\\bis\\b','g');
var text = 'He is a boy, This is a dog. Where is she?';
var result = text.replace(reg,'IS');
console.log(result) //He IS a boy, This IS a dog. Where IS she?
Таким образом, нет необходимости начинать и заканчивать символами «/», чтобы указать регулярность. Но специальные символы, такие как '\' внутри, должны быть экранированы с помощью '\'.
'\': помечает следующий символ как специальный символ, буквенный символ, обратную ссылку или восьмеричный escape-символ. Например, «n» соответствует символу «n». "\n" соответствует новой строке. Серийный номер "\\" соответствует "\", а "\(" соответствует "(".
метасимвол
Регулярные выражения состоят из двух основных типов символов:
- Буквенные текстовые символы, т. е. символы, представляющие их исходное значение.
- Метасимволы, метасимволы — это неалфавитные символы со специальным значением в регулярных выражениях, такие как упомянутый выше '\b', что означает соответствие границам слов, а не соответствие '\b', которые в основном существуют в регулярных выражениях.
*,+,?,$,^,.,|,\,(,),{,},[,]
класс персонажа (коллекция персонажей)
Как правило, один символ в регулярном выражении соответствует одному символу в строке, например:ab\tсоответствует строке 'ab'+'tab'
Но чаще всего мы сопоставляем не символ, а строку, которая соответствует ряду характеристик. В настоящее время мы можем использовать метасимвол '[]' для построения простого класса. Так называемый класс относится к объекту, который соответствует определенным характеристикам, общей ссылке, а не конкретному символу, например: выражение '[ abc ]' группирует символы a, b или c в класс, которому может соответствовать выражение.
var reg = /[abc]/g;
var text = 'a1b2c3d4';
var result = text.replace(reg,'X');
console.log(result); //X1X2X3d4
Таким образом, мы сопоставляем не три символа, таких как abc, а любой символ в abc, который является применением метасимволов.
отрицание класса символов
Создать с помощью метамодов '^'Обратный класс / тип отрицательный.
Обратная категория означаетКонтент, не относящийся к классу, выражение '[^abc]' означаетне символы a или b или cСодержание, например:
var reg = /[^abc]/g;
var text = 'a1b2c3d4';
var result = text.replace(reg,'X');
console.log(result); //aXbXcXXX
класс диапазона
Если нам нужно сопоставить числа с классами символов, в соответствии с предыдущим методом сопоставления запись может быть проблематичной, нам нужно это: '[0123456789]', особенно для символов от a до z.
Для этого регулярное выражение дает намкласс диапазона, мы можем использовать [az] для объединения двух символов, что означаетлюбой символ от а до яЭто закрытый интервал, содержащий саму букву z.
var reg = /[a-z]/g;
var text = 'a1b2c3d4z9';
var result = text.replace(reg,'Q');
console.log(result); //Q1Q2Q3Q4Q9
Как видите, это гораздо удобнее.
Кроме того, внутри класса, состоящего из '[]', [a-zA-Z] могут быть записаны последовательно, образуя таким образом точное совпадение прописных и строчных букв:
var reg = /[a-zA-Z]/g;
var text = 'a1b2c3d4z9ASDFHDFH';
var result = text.replace(reg,'Q');
console.log(result); //Q1Q2Q3Q4Q9QQQQQQQQ
Некоторые специалисты по детской обуви могут подумать: «Я хочу сопоставить символ «-» в классе диапазона, как мы можем это сделать?»
На самом деле все очень просто, например:
var reg = /[0-9]/g; //这样是跟前面一样的结果，不行
var text = '2018-05-13';
var result = text.replace(reg,'Q');
console.log(result); //QQQQ-QQ-QQ
var reg = /[0-9-]/g; //只要在后面另外加一个‘-’符号就可以了
var text = '2018-05-13';
var result1 = text.replace(reg,'Q');
console.log(result1); //QQQQQQQQQQ
Предопределенные классы и границы
предопределенный класс
Регулярные выражения обеспечивают предварительноепредопределенный классЧтобы соответствовать общим классам символов, давайте напишем более удобно.
| персонаж | Класс эквивалентности | имея в виду |
|---|---|---|
| . | [^\r\n] | Все символы, кроме возврата каретки и перевода строки |
| \d | [0-9] | цифровые символы |
| \D | [^0-9] | нечисловые символы |
| \s | [\t\n\x0B\f\r] | пробел |
| \S | [^\t\n\x0B\f\r] | без пробелов |
| \w | [a-zA-Z_0-9] | Символы слова (буквы, цифры, символы подчеркивания) |
| \W | [^a-zA-Z_0-9] | символы, не являющиеся словами |
цифра '\d', пробел '\s', буква слова '\w', заглавные буквы наоборот, маме больше не нужно беспокоиться о том, что я неправильно запомню
Чтобы увидеть практический пример, сопоставлениеab+число+любой символНить:
var reg = /ab\d./; //之前我们可能会这样写：ab[0-9][^\r\n]
var text = 'absdlkjflab91323';
var result = text.replace(reg,'AAAA');
console.log(result); //absdlkjflAAAA323
граница
В дополнение к предопределенным классам регулярные выражения предоставляют несколько часто используемых граничных символов.
| персонаж | Класс эквивалентности |
|---|---|
| ^ | начинается с ххх |
| $ | заканчивается на ххх |
| \b | границы слов |
| \B | границы без слов |
Мы использовали границу слова '\b' в первом примере, здесь мы делаем противоположность первому примеру выше, просто заменяем 'is' в 'This' на 'IS'
var reg = /\Bis\b/g;
var text = 'He is a boy, This is a dog. Where is she?';
var result = text.replace(reg,'IS');
console.log(result) //He is a boy, ThIS is a dog. Where is she?
Тогда речь идет о '^' и '$'. В классе '[]' '^' означает отрицание, но когда его нет в классе, '^' означает начало с xxx, а '$' означает окончание с xxx Два граничных символа обычно помещаются в начале и в конце обычного.
//先看没加^或$的情况
var reg = /@./g;
var text = '@123@ab@A';
var result = text.replace(reg,'Q');
console.log(result); //Q23QbQ
//添加^的情况
var reg = /^@./g;
var text = '@123@ab@A';
var result1 = text.replace(reg,'Q');
console.log(result1); //Q23@ab@A
//添加$的情况
var reg = /@.$/g;
var text = '@123@ab@A';
var result1 = text.replace(reg,'Q');
console.log(result1); //@123@abQ
В приведенном выше примере, если добавить и '^', и '$', совпадение не будет успешным, потому что строки без символов могут быть успешно сопоставлены, и детская обувь может попробовать это на себе.
Вот еще один пример с многострочным сопоставлением:
var reg = /^@\d./g;
var text= '@123\n@456\n@789';
var result = text.replace(reg,'Q');
console.log(result);// Q3 @456 @789
Здесь вы обнаружите, что все символы, соответствующие ожиданиям, в трех строках не были успешно заменены, как мы ожидали, успешно сопоставлена и заменена только первая строка, почему это так?
Это связано с тем, что, по нашему мнению, символ новой строки пишется с новой строки, но когда программа обрабатывает строку, символ новой строки является обычным символом, а не новой строкой, по нашему мнению. Здесь в игру вступает наш модификатор 'm':
var reg = /^@\d./gm;
var text= '@123\n@456\n@789';
var result = text.replace(reg,'Q');
console.log(result);// Q3 @6 @9
квантификатор
Если бы мы хотели сопоставить строку чисел, которая появляется 20 раз подряд, с тем, что мы узнали ранее, мы могли бы написать 20 '\d' подряд. Если вы все еще можете принять 20 раз, затем 100 раз, 1000 раз или даже больше, что вы делаете?
Для решения этой проблемы вводятся регулярные выраженияквантификаторпонятие, вот некоторые квантификаторы и их значения:
| персонаж | имея в виду |
|---|---|
| ? | Встречается ноль или один раз (не более одного) |
| + | Встречается один или несколько раз (хотя бы один раз) |
| * | Встречается ноль или более раз (любое количество раз) |
| {n} | появляется n раз |
| {n,m} | Встречается от n до m раз |
| {n,} | появляется не менее n раз |
В качестве обычного примера можно взять дату начала статьи:
var reg = /\d{4}[/-]\d{2}[/-]\d{2}/g;
var text = '2018-02-23，2018/02/24，2018~02/25';
var result = text.replace(reg,'匹配正确日期格式');
console.log(result);//匹配正确日期格式，匹配正确日期格式，2018~02/25
жадный режим
Регулярное выражение по умолчанию использует жадный режим, то есть каждое совпадение соответствует как можно большему количеству символов, пока совпадение не завершится ошибкой.
Возьмите каштан:
var reg = /\d{3,6}/g;
var text = '12345678';
var result = text.replace(reg,'X');
console.log(result);//X78
Как видно из вышеизложенного, регулярное выражение соответствует '123456', а не '123', '1234', '12345', и соответствует максимальному количеству раз, то есть жадному шаблону.
Если мы хотим, чтобы он совпадал только 3 раза, то есть как можно меньше совпадений, и после успешного совпадения мы не будем продолжать попытки, то есть что должен делать нежадный режим?
Это очень просто, просто добавьте '?' после квантификатора, давайте попробуем еще раз на примере прямо сейчас:
var reg = /\d{3,6}?/g;
var text = '12345678';
var result = text.replace(reg,'X');
console.log(result);//XX78
группировка
Предположим, у нас есть сценарий, в котором совпадающая строка Byron появляется 3 раза подряд, основываясь на том, что мы узнали ранее, мы могли бы написать:Byron{3}.
Но это неправильно.Попробуйте, и вы обнаружите, что только Byronnn может успешно сопоставиться, то есть последнее n повторяется 3 раза, и не может соответствовать случаю, когда все слово повторяется 3 раза:
var reg = /Byron{3}/g;
var text = 'ByronByronByronnn';
var result = text.replace(reg,'0');
console.log(result);//ByronByron0
Итак, как нам сопоставить три последовательных вхождения Байрона?На данный момент группировка регулярных выражений '()' помогает нам решить эту проблему:
var reg = /(Byron){3}/g;
var text = 'ByronByronByronnn';
var result = text.replace(reg,'0');
console.log(result);//0nn
или
Иногда нам может понадобиться использовать отношение или при сопоставлении, используя предыдущий класс символов '[]' (набор символов) может соответствовать только отношению или одного символа, например, сопоставление a или b, вы можете написать: '[ ab]', но если вам нужно сопоставить целое слово или связь, '[]' может не сработать. В настоящее время мы можем использовать '|' для достижения эффекта ИЛИ:
//匹配单词Byron或者Casper
var reg = /Byron|Casper/g;
var text = 'ByronCasper'
var result = text.replace(reg,'X');
console.log(result);//XX
//匹配Byr+on或Ca+sper
var reg = /Byr(on|Ca)sper/g;
var text = 'ByronsperByrCasper'
var result1 = text.replace(reg,'X');
console.log(result1);//XX
обратная ссылка
Если у нас есть такое требование: заменить дату «2015-12-25» на «25.12.2015», если бы это были вы, что бы вы сейчас сделали?
Вы можете написать что-то вроде этого:
var reg = /\d{4}-\d{2}-\d{2}/g;
var text = '2015-12-25'
var result = text.replace(reg,'12/25/2015');
console.log(result);//12/25/2015
Но с указанным выше методом записи вы можете сопоставить только «2015-12-25» и больше не можете сопоставлять другие даты. «2015-12-25» изменится, поэтому оно не будет соответствовать требованиям.
В это время регулярнообратная ссылкаможет вступить в силу. Когда выражение совпадает, механизм выражений запишет (групповой захват) строку, совпадающую с выражением, заключенным в круглые скобки "()". При получении результата сопоставления строка, совпадающая с выражением, заключенным в скобки, может быть получена отдельно.
В js строка, которая успешно соответствует обычному шаблону, может использовать $1 для обозначения первого успешного совпадения, $3 для обозначения третьего успешного совпадения и так далее до $99). Таким образом, приведенный выше пример можно записать так:
var reg = /(\d{4})-(\d{2})-(\d{2})/g;
var text = '2015-12-25'
var result = text.replace(reg,'$2/$3/$1');
console.log(result);//12/25/2015
игнорировать группировку
В приведенной выше обратной ссылке мы по умолчанию записываем все захваты в соответствии с «()» как $ 1 ~ $ 99. Что, если мы хотим игнорировать захват?
Если вы не хотите захватывать некоторые группы, вам просто нужно добавить '?:' к группе.
var reg = /(?:Byron)(\d{4})-(\d{2})-(\d{2})/g;
var text = 'Byron2016-12-05'
var result = text.replace(reg,'$2/$3/$1');
console.log(result);//12/05/2016
В настоящее время 1 доллар — это не Байрон, а 2016 год.
предвидение
Регулярные выражения начинают синтаксический анализ от начала текста к хвосту, а направление хвоста текста называется «передним».предвидениеТо есть, когда регулярное выражение соответствует правилу, оно проверяет, выполняется ли утверждение, и направление просмотра назад/обратного просмотра противоположно.
Утверждения о соответствии и несоответствии называютсяположительный / положительныйматч иОтрицательный / Отрицательныйсоответствовать.
Вышеизложенное является дальновидной концепцией, после прочтения у нее немного кружится голова? У меня немного кружится голова после прочтения... Позвольте мне объяснить: если вам нужно сопоставить человека по имени «Чжан Сан», мы могли бы только что найти человека по имени «Чжан Сан» из группы людей ранее. , но дальновидный должен спросить вас, имени идентифицированного человека «Чжан Сан» недостаточно, и отца «Чжан Сан» нужно называть «Чжан Эр» или другие конкретные условия, это дальновидный , похожий, ретроспективный. Недостаточно того, что имя Чжан Сан, сына также нужно называть «Сяо Чжан» и так далее.
Вы что-то понимаете? Однако следует отметить, чтоLook-behind/look-behind не поддерживается в javascript, так что нам больше не нужно заботиться. (Правильно здесь, просмотр назад и именованная группировка уже поддерживаются в ES2018 (ES9))
Что касается утверждения о соответствии/несоответствии, то его можно интерпретировать так: например, имя соответствующего требования «Чжан Сан», а его отца зовут не «Чжан Эр», мы называем это положительным/положительным соответствием, если оно совпадений и отрицательное совпадение, если оно не совпадает.
Затем мы объясним таблицу:
| имя | Обычный | имея в виду |
|---|---|---|
| перспективный | exp(?=assert) | Мы сопоставляем выражение, которое соответствует части exp, а затем оно не завершено.Оно также должно соответствовать части утверждения (внутри '()', регулярность после '='), чтобы считаться успешным |
| негативный взгляд вперед | exp(?!assert) | Мы сопоставляем выражение, которое соответствует части exp, а затем оно не завершено, мы также должны сопоставить часть утверждения (внутри '()', обычное после '!'), чтобы быть успешным |
| оглядываясь назад | exp(?<=assert) | джаваскрипт не поддерживает |
| негативный взгляд назад | exp(?<!assert) | джаваскрипт не поддерживает |
Это теперь ясно? Если это недостаточно ясно, ничего страшного, давайте еще один каштан:
var reg = /\w(?=\d)/g;
var text = 'a2*3';
var result = text.replace(reg,'X');
console.log(result);//X2*3
Обратите внимание, что мыутверждениеСодержимое внутри является лишь одним из условий сопоставления, а также необходимым условием, но суть сопоставления соответствует только обычному шаблону перед «()», поэтому результат выше: «X2 * 3», не "Х*3". Если результат сопоставления является последним, мы можем просто следовать исходному методу записи.var reg = /\w\d/g;, не так ли?
свойства объекта
Когда мы используем методы, связанные с регулярными выражениями, мы часто используем некоторые атрибуты объекта, связанные с регулярными выражениями.Давайте суммируем атрибуты объекта, связанные с регулярными выражениями:
- global: искать ли полный текст, по умолчанию false
- игнорировать регистр: чувствителен к регистру или нет, по умолчанию false
- multiline: многострочный поиск, по умолчанию false
- lastIndex: следующая позиция последнего символа, совпадающего с текущим выражением
- источник: текстовая строка регулярного выражения
Первые три из них были упомянуты выше, для исходников давайте объединим их, чтобы увидеть код:
var reg1 = /\w/;
var reg2 = /\w/gim;
console.log(reg1.global);//false
console.log(reg1.ignoreCase);//false
console.log(reg1.multiline);//false
console.log(reg2.global);//true
console.log(reg2.ignoreCase);//true
console.log(reg2.multiline);//true
console.log(reg1.source);//\w
console.log(reg2.source);//\w
Global, ignorecase и multiline по умолчанию имеют значение false, а источником является обычный строковый текст, который вы написали.
Что касается lastIndex, давайте сначала рассмотрим пример:
var reg1 = /\w/;
var reg2 = /\w/g;
console.log(reg1.test('a'));//true
console.log(reg1.test('a'));//true
console.log(reg1.test('a'));//true
//... 不管执行多少次都是true
console.log(reg2.test('ab'));//true
console.log(reg2.test('ab'));//true
console.log(reg2.test('ab'));//false
console.log(reg2.test('ab'));//true
console.log(reg2.test('ab'));//true
console.log(reg2.test('ab'));//false
//... 循环true true false
Не странно ли вышеприведенные результаты? Это результат эффекта «lastIndex» (что касается метода тестирования, детская обувь, которая не понимает, может удвоиться). Попробуем вывести 'lastIndex':
var reg2 = /\w/g;
while(reg2.test('ab')){
console.log(reg2.lastIndex); // 1 2
}
Можно обнаружить, что 'lastIndex' постоянно меняется, то есть следующая позиция последнего символа текущего результата сопоставления, где символ 'a' сопоставляется впервые, а последний символ результата сопоставления равен также «a», «Индекс следующей позиции символа a» равен 1. Подобно второму совпадению «b», последний символ результата сопоставления также равен «b», а индекс следующей позиции символа «b» равен 2. А теперь еще раз посмотрите на концепцию, вы многое понимаете?
Поэтому каждое регулярное совпадение не начинается с самого начала, а оглядывается на последний результат, чтобы увидеть, есть ли еще, и если есть, продолжить сопоставление, конечно, это должно быть основано на глобальном сопоставлении 'g ' , иначе каждый матч начинается с нуля.
Методы самого объекта регулярного выражения RegExp
Есть три метода, которые поставляются с объектом RegExp:
- test: извлекает значение, указанное в строке. вернуть истину или ложь
- exec: извлекает значение, указанное в строке. Вернуть найденное значение и определить его местоположение
- компилировать: компилировать регулярные выражения (обычно не используется)
Метод испытания
Тестовый () Способ для строки Если совпадение существует регулярное параметр тестирования шаблона экспрессии, возвращает true, если присутствует, в противном случае возвращает false.
СинтаксисRegExpObject.test(string), возвращает значение true, если строковая строка содержит текст, соответствующий объекту RegExpObject, в противном случае — значение false.
Возьмите каштан:
var str = "good good study, day day up";
var reg = new RegExp("study");
var result = reg.test(str);
console.log(result);//true
исполняемый метод
Метод exec() используется для выполнения поиска в строке с использованием шаблона регулярного выражения и обновляет свойства глобального объекта RegExp, чтобы отразить совпадение.
СинтаксисRegExpObject.exec(string), Если строка string содержит текст, совпадающий с RegExpObject, возвращается массив, в котором хранятся совпадающие результаты. Если совпадений не найдено, возвращаемое значение равно null.
Кроме того, у массивов есть два дополнительных свойства:
- index: объявляет позицию первого символа соответствующего текста
- ввод: сохранить полученную строку String
Метод exec() более сложен, и результаты глобальных вызовов и неглобальных вызовов различаются:
неглобальный (т.е. без 'g') вызов:
- Возвращает массив при вызове exec() для неглобального объекта RegExp
- Первый элемент массива — это текст, соответствующий регулярному выражению.
- Второй элемент массива — это текст (если есть), который соответствует первому подвыражению RegExpObject.
- Третий элемент массива — это текст, соответствующий второму подвыражению объекта RegExp (если есть, и т. д.).
Это выглядит немного головокружительно? Не бойтесь, давайте рассмотрим пример:
var reg3 = /\d(\w)\d/;
var str = '1a2b3c4d5e';
var arr = reg3.exec(str);
console.log(reg3.lastIndex + '\t' + arr.index + '\t' + arr.toString());//0 0 1a2,a
То есть выходной результат: lastIndex (здесь 0, потому что lastIndex не действует при неглобальном сопоставлении), позиция первого символа совпадающего текста (дополнительный индекс атрибута, где первый символ равен «1») и массив результатов сопоставления («1a2» — это совпадающий текст, «a» — результат сопоставления подвыражения «(\w)», второго подвыражения «()» нет, поэтому нет и третьего результат сопоставления со значением массива). Это намного яснее?
глобальный вызов:
- exec() начинает извлекать строку string с символа, указанного в свойстве lastIndex объекта RegExpObject.
- Когда функция exec() находит текст, соответствующий выражению, после сопоставления она устанавливает свойство lastIndex объекта RegExpObject в положение, следующее за последним символом совпавшего текста.
- Тем не менее, вы можете перебрать весь соответствующий текст в строке, многократно вызывая метод exec().
- Когда функция exec() больше не может найти соответствующий текст, она возвращает null и сбрасывает свойство lastIndex в 0.
- Примечание. Если вы хотите начать извлечение новой строки после завершения сопоставления с образцом в строке, необходимо вручную сбросить свойство lastIndex на 0.
Возьмем также каштан:
var reg4 = /\d(\w)(\w)\d/g;
var str = '$1az2bb3cy4dd5ee';
while(arr = reg4.exec(str)){
console.log(reg4.lastIndex + '\t' + arr.index + '\t' + arr.toString());
//5 1 1az2,a,z
//11 7 3cy4,c,y
}
Я не буду объяснять здесь значение результатов, я считаю, что детская обувь может понять общую ситуацию здесь, прочитав приведенное выше неглобальное объяснение.
метод компиляции
Метод compile() используется для компиляции регулярных выражений во время выполнения скрипта, а также может использоваться для изменения и повторной компиляции регулярных выражений. Это вообще не используется в нашей обычной работе (я еще не видел...);
Его синтаксис:RegExpObject.compile(regexp,modifier), где параметр «regexp» — регулярное выражение, а параметр «modifier» — тип указанного совпадения. «g» для глобального сопоставления, «i» для сопоставления с учетом регистра и «gi» для глобального сопоставления с учетом регистра (выдержка из W3C).
Давайте посмотрим на пример:
var str = "Every man in the world! Every woman on earth!";
var reg = /man/g;
var str2 = str.replace(reg,"person");
console.log(str2)
var reg2=/(wo)?man/g;
reg.compile(reg2);
console.log(reg.source);//(wo)?man 这里可以看到reg通过compile编译为reg2一样了
var str2=str.replace(reg,"person");
console.log(str2);
Вышеприведенное означает: глобальный поиск «человека» в строке и замена на «человек». Затем с помощью метода compile() измените reg регулярного выражения на reg2 и продолжайте использовать reg регулярного выражения после регулярного изменения, заменив «мужчина» или «женщина» на «человек».
Что касается того, почему вы используете компиляцию для динамически исправления правил, в чем разница между этим и новым?
Я проверил, чтобы найти информацию, чтобы сказать: если указанное регулярное выражение необходимо использовать повторно, то компиляция регулярного выражения повысит эффективность кода, но если выполняется только один или несколько раз, то значительных результатов не будет. , скомпилируйте, улучшите адаптивность регулярных выражений!
Методы объектов String, поддерживающие регулярные выражения
Методы объектов String, которые поддерживают регулярные выражения:
- поиск: получить значения, соответствующие регулярному выражению
- match: найти совпадение для одного или нескольких регулярных выражений.
- replace: заменить подстроку, соответствующую регулярному выражению.
- split: разбить строку на массив строк.
search
Указан метод поиска подстроки () для строки символов поиска подстроки или получения соответствия регулярному выражению
СинтаксисstringObject.search(regexp), результат возвращает индекс начальной позиции первой подстроки, соответствующей регулярному выражению в stringObject, или -1, если совпадающая подстрока не найдена.
Обратите внимание, что метод search() не выполняет глобальное сопоставление, он игнорирует модификатор 'g' и всегда ищет с начала строки.
Давайте посмотрим пример:
var str = 'a1b2c3d4';
console.log(str.search('1')); //1
console.log(str.search('10')); //-1
console.log(str.search(/b2/)); //2
console.log(str.search(/\w\d/g)); //0
console.log(str.search(/\w\d/g)); //0 忽略'g',执行多次未返回不同结果
match
Метод match() извлечет строку, чтобы найти один или несколько текстов, которые соответствуют регулярному выражению, независимо от того, есть ли модификатор 'g' в регулярном выражении, имеет большое значение. Этот метод похож на indexOf() и lastIndexOf(), но возвращает указанное значение вместо позиции строки.
СинтаксисstringObject.match(searchvalue)或stringObject.match(regexp), результат возвращает массив, содержащий совпадающие результаты. Содержимое этого массива зависит от того, имеет ли регулярное выражение глобальный флаг g.
Метод match() также делится на глобальные вызовы и неглобальные вызовы:
неглобальный вызов
- Если в регулярном выражении нет флага g , метод match() может выполнить сопоставление строки только один раз.
- Возвращает ноль, если соответствующий текст не найден
- В противном случае он возвращает массив с информацией о найденном совпадающем тексте:
- 0-й элемент массива содержит соответствующий текст, а остальные элементы содержат текст, соответствующий подвыражениям регулярного выражения. (Это похоже на метод exec(), упомянутый ранее)
Далее идет массив из двух дополнительных свойств (метод exec() практически такой же):
- index: объявляет позицию первого символа соответствующего текста
- ввод: объявляет ссылку на stringObject
Вот пример:
var reg3 = /\d(\w)\d/;
var str = '1a2b3c4d5e';
var arr = str.match(reg3);
console.log(reg3.lastIndex + '\t' + arr.index + '\t' + arr.toString());//0 0 1a2,a
Вы можете видеть, что результаты такие же, как и у метода exec(), за исключением того, что позиции строк и регулярных чисел меняются местами.
глобальный вызов
Глобальный вызов отличается от exec():
- Если регулярное выражение имеет флаг g, то метод match() выполнит глобальный поиск, чтобы найти все совпадающие подстроки в строке.
- Возвращает ноль, если не найдена совпадающая подстрока
- Возвращает массив, если найдена одна или несколько совпадающих строк
- Элемент массива хранит все совпадающие строки в строке, а атрибут индекса и входной атрибут отсутствуют.
Проще говоря, он возвращает массив со всеми совпадающими результатами в массиве.
var reg4 = /\d(\w)(\w)\d/g;
var str = '$1az2bb3cy4dd5ee';
var arr = str.match(reg4)
console.log(arr); // ["1az2", "3cy4"]
console.log(reg4.lastIndex + '\t' + arr.index) //0 undefined
Видно, что функция метода match() возвращает не так много информации, как метод exec(), но если требуется только массив результатов, метод match() будет более эффективным.
split
Я не буду вдаваться в подробности о методе split(), мы часто используем его для разбиения строк на массивы.
var str = 'a,b,c,d';
var arr = str.split(',');
console.log(arr); //['a','b','c','d']
Но вы не можете знать, мы можем использовать некоторые регулярные выражения для решения сложных ситуаций
var str = 'a1b2c3d';
var arr = str.split(/\d/);
console.log(arr); //['a','b','c','d']
Выше может быть не видно, что метод Spilt() использует обычную сегментацию, но что, если сегментация немного сложнее, например:
var str = 'a1b&c|d&e';
var arr = str.split(/[\d|&]/);
console.log(arr); //['a','b','c','d','e']
Показывает ли это преимущество использования регулярности?
Немного знаний: на самом деле, когда мы используем split() для разделения символов ',', метод split() также преобразует отшельника ',' в обычный '/,/', и метод search() тот же как метод replace().
replace
Метод replace() используется для замены одних символов другими символами в строке или для замены подстроки, соответствующей регулярному выражению.
СинтаксисstringObject.replace(regexp/substr,replacement)Затем в результате возвращается новая строка, которая заменяется первой заменой регулярного выражения на совпадение или все совпадения получены.
Для метода замены () его можно использовать тремя способами:
- String.prototype.replace(str,replaceStr);
- String.prototype.replace(reg,replaceStr);
- String.prototype.replace(reg,function);
Я не буду приводить больше примеров использования 1 и 2. Я полагаю, что если вы внимательно прочитали предыдущую статью, то должны быть хорошо знакомы с первым и вторым использованием метода replace(). Вот третий способ использования.
Скажи это первымString.prototype.replace(reg,function);Значение параметров функции в функции, функция будет вызываться каждый раз при замене совпадения, параметров четыре (второй параметр не фиксирован):
- совпадающая строка
- Содержимое группировки регулярного выражения, если нет группировки, то нет и такого параметра,
- Индекс в строке в строке
- необработанная строка
Возьмем, к примеру, два каштана:
var str = 'a1b2c3d4e5';
var reg = /\d/g;
var arr = str.replace(reg,function(match, index, origin){
console.log(index);// 1 3 5 7 9
return parseInt(match) + 1;
})
console.log(arr);//a2b3c4d5e6 把每次匹配到的结果+1替换
var str = 'a1b2c3d4e5';
var reg = /(\d)(\w)(\d)/g;
var arr = str.replace(reg,function(match, group1, group2, group3, index, origin){
console.log(match);// 1b2 3d4
return group1 + group3;
})
console.log(arr);//a12c34e5 去除了每次匹配到的group2
Вся статья здесь.Каждый пример - это результат реального теста.Он давно написан.Надеюсь статья будет вам полезна,и я останусь доволен~~