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

Синтаксис

• let regex = / pattern / [ flags ]
• let regex = new RegExp (' pattern ', [ flags ])
• let ismatch = regex.test (' текст ')
• let results = regex.exec (' text ')

параметры

замечания

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

Стандартное создание

Рекомендуется использовать эту форму только при создании регулярного выражения из динамических переменных.

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

var re = new RegExp(".*");

С флагами:

var re = new RegExp(".*", "gmi");

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

var re = new RegExp("\\w*");

Статическая инициализация

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

var re = /.*/;

С флагами:

var re = /.*/gmi;

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

var re = /\w*/;

Флаги RegExp

Есть несколько флагов, которые вы можете указать для изменения поведения RegEx. Флаги могут быть добавлены к концу литерала регулярного выражения, например, указать gi in /test/gi или они могут быть указаны как второй аргумент для конструктора RegExp , как в new RegExp('test', 'gi') .

g - Глобальный. Находит все совпадения вместо остановки после первого.

i - Игнорировать дело. /[az]/i эквивалентно /[a-zA-Z]/ .

m - многострочный. ^ и $ соответствуют началу и концу каждой строки, соответственно обрабатывая \n и \r как разделители вместо простого начала и конца всей строки.

Соответствие с .exec ()

Совпадение с использованием .exec()

RegExp.prototype.exec(string) возвращает массив захватов или null если совпадение не было.

var re = /([0-9]+)[a-z]+/;
var match = re.exec("foo123bar");

match.index - это 3, (нулевое) местоположение совпадения.

match[0] - полная строка соответствия.

match[1] - текст, соответствующий первой захваченной группе. match[n] будет значением n- й захваченной группы.

Loop Through Matches Использование .exec()

var re = /a/g;
var result;
while ((result = re.exec('barbatbaz')) !== null) {
    console.log("found '" + result[0] + "', next exec starts at index '" + re.lastIndex + "'");
}

Ожидаемый результат

найденный 'a', следующий exec начинается с индекса '2'
найденный 'a', следующий exec начинается с индекса '5'
найденный 'a', следующий exec начинается с индекса '8'

Проверьте, содержит ли строка шаблон с использованием .test ()

var re = /[a-z]+/;
if (re.test("foo")) {
    console.log("Match exists.");
}

Метод test выполняет поиск, чтобы увидеть, соответствует ли регулярное выражение строке. Регулярное выражение [az]+ будет искать одну или несколько строчных букв. Поскольку шаблон соответствует строке, на консоли будет регистрироваться «соответствие существует».

Использование RegExp со строками

Объект String имеет следующие методы, которые принимают регулярные выражения в качестве аргументов.

• "string".match(...
• "string".replace(...
• "string".split(...
• "string".search(...

Совпадение с RegExp

console.log("string".match(/[i-n]+/));
console.log("string".match(/(r)[i-n]+/));

Ожидаемый результат

Массив ["in"]
Массив ["rin", "r"]

Заменить с помощью RegExp

console.log("string".replace(/[i-n]+/, "foo"));

Ожидаемый результат

strfoog

Сплит с RegExp

console.log("stringstring".split(/[i-n]+/));

Ожидаемый результат

Массив ["str", "gstr", "g"]

Поиск с помощью RegExp

.search() возвращает индекс, в котором найдено совпадение, или -1.

console.log("string".search(/[i-n]+/));
console.log("string".search(/[o-q]+/));

Ожидаемый результат

3
-1

Замена соответствия строки с помощью функции обратного вызова

String#replace может иметь функцию в качестве второго аргумента, поэтому вы можете предоставить замену на основе некоторой логики.

"Some string Some".replace(/Some/g, (match, startIndex, wholeString) => {
  if(startIndex == 0){
    return 'Start';
  } else {
    return 'End';
  }
});
// will return Start string End

Библиотека шаблонов одной строки

let data = {name: 'John', surname: 'Doe'}
"My name is {surname}, {name} {surname}".replace(/(?:{(.+?)})/g, x => data[x.slice(1,-1)]);

// "My name is Doe, John Doe"

Группы RegExp

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

Захватить

Иногда желаемый матч зависит от контекста. Это означает, что простой RegExp переберет часть интересующей строки , поэтому решение состоит в том, чтобы написать группу захвата (pattern) . Затем на захваченные данные можно ссылаться как ...

• Замена строк "$n" где n - n-я группа захвата (начиная с 1 )
• N-й аргумент в функции обратного вызова
• Если RegExp не помечен g , n + 1-й элемент в возвращаемом массиве str.match
• Если RegExp отмечен g , str.match отбрасывает захваты, вместо этого используйте re.exec

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

let str = "aa+b+cc+1+2",
    re = /([a-z])\+/g;

// String replacement
str.replace(re, '$1 '); // "aa b cc 1+2"
// Function replacement
str.replace(re, (m, $1) => $1 + ' '); // "aa b cc 1+2"

Non-Capture

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

Они могут быть особенно полезны, если захватываются другие данные, которые вы не хотите переместить индексы, но вам нужно выполнить некоторые расширенные сопоставления шаблонов, такие как OR

let str = "aa+b+cc+1+2",
    re = /(?:\b|c)([a-z])\+/g;

str.replace(re, '$1 '); // "aa+b c 1+2"

Смотреть вперед

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

let str = "aa+b+cc+1+2",
    re = /\+(?=[a-z])/g;

str.replace(re, ' '); // "aa b cc+1+2"

Использование Regex.exec () с регулярным выражением в круглых скобках для извлечения совпадений строки

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

Что такое матч? Когда найденная совместимая подстрока для всего регулярного выражения в строке, команда exec создает совпадение. Сопоставление - это массив, составленный, во-первых, всей подстрокой, которая сопоставлена, и все скобки в матче.

Представьте себе строку html:

<html>
<head></head>
<body>
  <h1>Example</h1>
  <p>Look a this great link : <a href="https://stackoverflow.com">Stackoverflow</a> http://anotherlinkoutsideatag</p>
  Copyright <a href="https://stackoverflow.com">Stackoverflow</a>
</body>

Вы хотите , чтобы извлечь и получить все ссылки внутри a теге. Во-первых, вот регулярное выражение, которое вы пишете:

var re = /<a[^>]*href="https?:\/\/.*"[^>]*>[^<]*<\/a>/g;

Но теперь представьте, что вы хотите href и anchor каждой ссылки. И вы хотите это вместе. Вы можете просто добавить новое регулярное выражение для каждого совпадения ИЛИ вы можете использовать круглые скобки:

var re = /<a[^>]*href="(https?:\/\/.*)"[^>]*>([^<]*)<\/a>/g; 
var str = '<html>\n    <head></head>\n    <body>\n        <h1>Example</h1>\n        <p>Look a this great link : <a href="https://stackoverflow.com">Stackoverflow</a> http://anotherlinkoutsideatag</p>\n\n        Copyright <a href="https://stackoverflow.com">Stackoverflow</a>\n    </body>\';\n';
var m;
var links = [];

while ((m = re.exec(str)) !== null) {
    if (m.index === re.lastIndex) {
        re.lastIndex++;
    }
    console.log(m[0]); // The all substring
    console.log(m[1]); // The href subpart
    console.log(m[2]); // The anchor subpart

    links.push({
      match : m[0],   // the entire match
      href : m[1],    // the first parenthesis => (https?:\/\/.*)
      anchor : m[2],  // the second one => ([^<]*)
    });
}

В конце цикла у вас есть массив ссылок с anchor и href и вы можете использовать его для записи уценки, например:

links.forEach(function(link) {
  console.log('[%s](%s)', link.anchor, link.href);
});

Чтобы идти дальше:

• Вложенные круглые скобки