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

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

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

• Экранирование: обратная косая черта экранирует специальные символы, включая косую черту в литералах регулярных выражений (см. Ниже) и сам обратный слэш.
  
  • Если вы указываете регулярное выражение в строке, вы должны экранировать дважды: один раз для строкового литерала, один раз для регулярного выражения. Например, чтобы просто сопоставить обратную косую черту, строковый литерал становится «\\\\».
  • Обратная косая черта также используется для некоторых специальных операторов сопоставления (см. Ниже).
• Группа без захвата: (?: 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

> 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

    > "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) { ... }

    > "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])

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