Статьи

JavaScript: обзор API регулярных выражений


Этот пост дает обзор API JavaScript для регулярных выражений.
Однако в нем нет подробностей о синтаксисе регулярных выражений, поэтому вы должны быть уже знакомы с ним.

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

Ниже перечислены конструкции, которые трудно запомнить (не указаны такие вещи, как * для повторения, захвата групп и т. Д.).

  • Экранирование: обратная косая черта экранирует специальные символы, включая косую черту в литералах регулярных выражений (см. Ниже) и сам обратный слэш.

    • Если вы указываете регулярное выражение в строке, вы должны экранировать дважды: один раз для строкового литерала, один раз для регулярного выражения. Например, чтобы просто сопоставить обратную косую черту, строковый литерал становится «\\\\».
    • Обратная косая черта также используется для некоторых специальных операторов сопоставления (см. Ниже).
  • Группа без захвата: (?: X) работает как группа захвата для определения подвыражения x, но не возвращает совпадений и, следовательно, не имеет номера группы.
  • Положительный прогноз: x (? = Y) означает, что x соответствует, только если за ним следует y. сам по себе y не считается частью регулярного выражения.
  • Отрицательный прогноз: x (?! Y) отрицательная версия предыдущей конструкции: x не должно сопровождаться y.
  • Повторения: {n} соответствует ровно n раз, {n,} соответствует по крайней мере n раз, {n, m} соответствует по крайней мере n, максимум m раз.
  • Управляющие символы: \ cX соответствует Ctrl-X (для любого управляющего символа X), \ n соответствует переводу строки, \ r соответствует возврату каретки.
  • Обратная ссылка: \ n ссылается на группу n и снова сопоставляет ее содержимое.

Примеры:

 > /(a+)b\1/.test("aaba")
true
> /^(a+)b\1/.test("aaba")
false
> var tagName = /<([^>]+)>[^<]*<\/\1>/;
> tagName.exec("<b>bold</b>")[1]
'b'
> tagName.exec("<strong>text</strong>")[1]
'strong'
> tagName.exec("<strong>text</stron>")
null

Создать регулярное выражение

Примеры:

    > /abc/.test("ABC")
false
> /abc/i.test("ABC")
true

Простое сопоставление

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

  • regex.test ([str]) : возвращает логическое значение, указывающее, успешно ли найдено совпадение. Если аргумент опущен, последняя входная строка используется снова.
  • str.search (regex) : возвращает индекс, в котором найдено совпадение, -1 в противном случае.

Примеры:

> var regex = /^(a+)b\1$/;
> regex.test("aabaa")
true
> regex.test("aaba")
false

Захват групп, опционально многократно

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

  • var matchData = regex.exec ([str])
    Отсутствующий параметр означает: повторно использовать аргумент из последнего вызова
  • var matchData = str.match (regex)

регулярное выражение: имеет следующие свойства.

  • Флаги: логические значения, указывающие, какие флаги установлены.

    • global : установлен флаг g ?
    • IgnoreCase : это флаг я набор?
    • многострочный : установлен флаг m ?
  • Данные о последнем матче:

    • источник : полная входная строка.
    • lastIndex : индекс, где продолжить поиск в следующий раз.

matchData:
нуль , если бы не был матч. В противном случае массив и два дополнительных свойства.

  • Свойства:

    • input : полная строка ввода.
    • index : индекс, где совпадение было найдено.
  • Массив: длина которого равна числу групп захвата плюс одна.

    • 0: совпадение для полного регулярного выражения (группа 0, если хотите).
    • n ≥ 1: захват группы n.


Вызвать один раз:
глобальный флаг
не установлен.

> var regex = /a(b+)a/;
> regex.exec("_abbba_aba_")
[ 'abbba'
, 'bbb'
, index: 1
, input: '_abbba_aba_'
]
> regex.lastIndex
0

Вызывать повторно: флаг
global установлен.

> var regex = /a(b+)a/g;
> regex.exec("_abbba_aba_")
[ 'abbba'
, 'bbb'
, index: 1
, input: '_abbba_aba_'
]
> regex.lastIndex
6
> regex.exec()
[ 'aba'
, 'b'
, index: 7
, input: '_abbba_aba_'
]
> regex.exec()
null

Зациклить спички.

 var regex = /a(b+)a/g;
var str = "_abbba_aba_";
while(true) {
var match = regex.exec(str);
if (!match) break;
console.log(match[1]);
}

Выход:

bbb
b

Поиск и замена

Вызов:
str.replace (поиск, замена) .

  • поиск :

    • либо строка (встречается буквально, не имеет групп)
    • или регулярное выражение.
  • замена :

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

Замена это строка. Знак доллара $ используется для обозначения специальных директив замены:

  • $$ вставляет знак доллара $.
  • $ & вставляет полное совпадение.
  • $ ` вставляет текст перед совпадением.
  • $ вставляет текст после совпадения.
  • $ n вставляет группу n из совпадения. n должно быть не меньше 1, $ 0 не имеет особого значения.

Примеры:

    > "a1b_c1d".replace("1", "[$`-$&-$']")
'a[a-1-b_c1d]b_c1d'
> "a1b_c1d".replace(/1/, "[$`-$&-$']")
'a[a-1-b_c1d]b_c1d'
> "a1b_c1d".replace(/1/g, "[$`-$&-$']")
'a[a-1-b_c1d]b_c[a1b_c-1-d]d'

Замена это функция. Функция замены имеет следующую подпись.

function(completeMatch, group_1, ..., group_n, offset, inputStr) { ... }

completeMatch — это то же самое, что и
$ &, выше,
offset указывает, где найдено совпадение, а
inputStr — то, с чем сопоставляется. Таким образом, аргументы специальной переменной
внутри функции начинаются с тех же данных, что и результат метода
exec () .

Пример:

    > "I bought 3 apples and 5 oranges".replace(
/[0-9]+/g,
function(match) { return 2 * match; })
'I bought 6 apples and 10 oranges'

Расщепление строк

Подпись:

str.split(separator, [limit])

В строке найдите подстроки между разделителями и верните их в массив.

  • разделитель может быть

    • строка: разделители совпадают дословно
    • регулярное выражение: для более гибкого соответствия разделителя. Многие реализации JavaScript включают первую группу захвата в массив результатов, если она есть.
  • limit необязательно указывает максимальную длину возвращаемого массива. Значение меньше 0 допускает произвольную длину.

Примеры:

> "aaa*a*".split("a*")
[ 'aa', '', '' ]
> "aaa*a*".split(/a*/)
[ '', '*', '*' ]
> "aaa*a*".split(/(a*)/)
[ '', 'aaa', '*', 'a', '*' ]

Источники: