JavaScript Регулярные выражения. Уроки для начинающих. W3Schools на русском

Краткое руководство по регулярным выражениям в JavaScript, в котором изложены и показаны на примерах наиболее важные концепции регулярных выражений в JS.

str.match(regexp)

Метод str.match(regexp) ищет совпадения с regexp в строке str.

У него есть три режима работы:

  1. Если у регулярного выражения нет флага g, то он возвращает первое совпадение в виде массива со скобочными группами и свойствами index (позиция совпадения), input (строка поиска, равна str):

    let str = “I love JavaScript”;let result = str.match(/Java(Script)/);alert( result[0] ); // JavaScript (всё совпадение)alert( result[1] ); // Script (первые скобки)alert( result.length ); // 2// Дополнительная информация:alert( result.index ); // 7 (позиция совпадения)alert( result.input ); // I love JavaScript (исходная строка)
  2. Если у регулярного выражения есть флаг g, то он возвращает массив всех совпадений, без скобочных групп и других деталей.

    let str = “I love JavaScript”;let result = str.match(/Java(Script)/g);alert( result[0] ); // JavaScriptalert( result.length ); // 1
  3. Если совпадений нет, то, вне зависимости от наличия флага g, возвращается null.

    Это очень важный нюанс. При отсутствии совпадений возвращается не пустой массив, а именно null. Если об этом забыть, можно легко допустить ошибку, например:

    let str = “I love JavaScript”;let result = str.match(/HTML/);alert(result); // nullalert(result.length); // Ошибка: у null нет свойства length

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

    let result = str.match(regexp) || [];

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

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

  • Используя литерал регулярного выражения, например:

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

  • Вызывая функцию конструктор объекта RegExp, например:
    var re = new RegExp(“ab+c”);

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

Введение в регулярные выражения

Регулярные выражения (RegExp) – это очень эффективный способ работы со строками.

Составив регулярное выражение с помощью специального синтаксиса вы можете:

  • искать текст в строке
  • заменять подстроки в строке
  • извлекать информацию из строки

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

Регулярные выражения относятся к 1950-м годам, когда они были формализованы как концептуальный шаблон поиска для алгоритмов обработки строк.

Регулярные выражения реализованные в  UNIX, таких как grep, sed и популярных текстовых редакторах, начали набирать популярность и были добавлены в язык программирования Perl, а позже и в множество других языков.

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

Написание шаблона регулярного выражения

Шаблон регулярного выражения состоит из обычных символов, например /abc/, или комбинаций обычных и специальных символов, например /ab*c/ или /Chapter (d+).d*/. Последний пример включает в себя скобки, которые используются как “запоминающий механизм”. Соответствие этой части шаблона запоминается для дальнейшего использования, как описано в Использование совпадений подстрок заключённых в скобки.

Использование простых шаблонов

Простые шаблоны используются для нахождения прямого соответствия в тексте. Например, шаблон /abc/ соответствует комбинации символов в строке  только когда символы ‘abc’ встречаются вместе и в том же порядке. Такое сопоставление произойдёт в строке “Hi, do you know your abc’s?” и “The latest airplane designs evolved from slabcraft.” В обоих случаях сопоставление произойдёт с подстрокой ‘abc’. Сопоставление не произойдёт в строке “Grab crab”, потому что она не содержит подстроку ‘abc’.

Использование специальных символов

В случае когда поиск соответствия требует чего-то большего, чем прямое сопоставление, например нахождение последовательности символов ‘b’ или нахождение пробела, шаблон включает в себя специальные символы. Например, шаблон /ab*c/ соответствует любой комбинации символов, в которой за ‘a’ следует ноль или более символов ‘b’ (* означает ноль или более вхождений предыдущего символа), за которыми сразу же следует символ ‘c’. В строке “cbbabbbbcdebc,” этому шаблону сопоставляется подстрока ‘abbbbc’.

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

Таблица 4.1 Специальные символы в регулярных выражения.
Символ Значение
Одно из следующего:
  • Для символов обычно обрабатываемых буквально, означает что следующий символ является специальным и не должен интерпретироваться буквально.
  • Например, /b/ сопоставляется символу ‘b’. Добавляя слеш перед b, т.е используя /b/, символ становится специальным символом, означающим границу слова.
  • Для символов обычно обрабатываемых особым образом означает, что следующий символ не является специальным и должен интерпретироваться буквально.
  • Например, * является специальным символом, сопоставляемым 0 или более повторений предыдущего символа; например, /a*/ означает соответствие 0 или более символов а. Для буквальной интерпретации *, поставьте перед ней обратный слеш; например, /a*/ соответствует ‘a*’.
  • Также не забудьте заэкранировать сам при его использовании в записи new RegExp(“pattern”) поскольку также является экранирующим символом в обычных строках.
^

Соответствует началу ввода. Если установлен флаг многострочности, также производит сопоставление непосредственно после переноса строки.

Например, /^A/ не соответствует ‘A’ в “an A”, но соответствует ‘A’ в “An E”.

Этот символ имеет другое значение при появлении в начале шаблона набора символов.

Например, /[^a-zs]/ соответствует ‘I’ в “I have 3 sisters”.

$

Соответствует концу ввода. Если установлен битовый флаг многострочности, также сопоставляется содержимому до переноса строки.

Например, /t$/ не соответствует ‘t’ в строке “eater”, но соответствует строке “eat”.

*

Соответствует предыдущему символу повторенному 0 или более раз. Эквивалентно {0,}.

Например, /bo*/ соответствует ‘boooo’ в “A ghost booooed” и ‘b’ в “A bird warbled”, но не в “A goat grunted”.

+

Соответствует предыдущему символу повторенному 1 или более раз. Эквивалентно {1,}.

Например, /a+/ соответствует ‘a’ в “candy” и всем символам ‘a’ в “caaaaaaandy”.

? Соответствует предыдущему символу повторенному

 0 или 1 раз. Эквивалентно {0,1}.

Например, /e?le?/ соответствует ‘el’ в “angel” и ‘le’ в “angle” а также ‘l’ в “oslo”.

Если использован сразу после квалификаторов *, +, ?, или {}, делает квалификатор “нежадным” (соответствующим минимальному количеству символов), в отличие от режима по умолчанию, являющимся “жадным” (соответствующим максимальному числу символов). Например, используя /d+/ не глобальное сопоставление “123abc” возвращает “123”, если использовать /d+?/, только “1” будет возвращена.

Также используется в упреждающих утверждениях (assertions), описанных в строках x(?=y) и x(?!y) данной таблицы.

.

(десятичная точка) соответствует любому символу кроме переноса строки.

Например, /.n/ соответствует ‘an’ и ‘on’ в “nay, an apple is on the tree”, но не ‘nay’.

(x)

Соответствует ‘x’ и запоминает это соответствие. Это называется захватывающие скобки.

Например, /(foo)/ соответствует ‘foo’ в “foo bar.” Сопоставленная строка может быть получена из элементов результирующего массива [1], …, [n].

(?:x) Соответствует ‘x’ но не запоминает соответствие. Это называется не-захватывающие скобки. Сопоставленная строка не может быть получена из элементов результирующего массива [1], …, [n].
x(?=y)

Соответствует ‘x’ только если за ‘x’ следует ‘y’. Это называется упреждение.

Например, /Jack(?=Sprat)/ соответствует ‘Jack’ только если за ним следует ‘Sprat’. /Jack(?=Sprat|Frost)/ соответствует ‘Jack’ только если за ним следует ‘Sprat’ или ‘Frost’. Тем не менее, ни ‘Sprat’ ни ‘Frost’ не являются частью сопоставленного результата.

x(?!y)

Соответствует ‘x’ только если за ‘x’ не следует ‘y’. Это называется отрицательное упреждение.

Например, /d+(?!.)/ соответствует числу только если за ним не следует десятичная точка. Регулярное выражение /d+(?!.)/.exec(“3.141”) сопоставит ‘141’ но не ‘3.141’.

x|y

Соответствует либо ‘x’ либо ‘y’.

Например, /green|red/ соответствует ‘green’ в “green apple” и ‘red’ в “red apple.”

{n}

n – положительное целое. Соответствует ровно n вхождениям предыдущего символа.

Например, /a{2}/ не соответствует ‘a’ в “candy,” но соответствует всем а в “caandy,” первым двум а в “caaandy.”

{n,m}

m и n – положительные целые. Соответствует как минимум n и максимум m вхождениям предыдущего символа. При m=n=1 пропускается.

Например, /a{1,3}/ ничему не соответствует в строке “cndy”, символу ‘a’ в “candy,” двум а в “caandy,” и трём первым а в “caaaaaaandy”. Отметим, что при сопоставлении “caaaaaaandy”, совпадает “aaa”, хотя изначальная строка содержит больше а.

[xyz]

Набор символов. Соответствует любому символу из перечисленных. Можно указать диапазон символов, используя тире. Специальные символы (как точка (.) и звёздочка (*)) не имеют специального значения внутри такого набора. Их не надо экранировать. Экранирование работает также.

Например, [abcd] эквивалентна [a-d]. Они соответствуют ‘b’ в “brisket” и ‘c’ в “city”. /[a-z.]+/ и /[w.]+/ обе соответствуют всему в “test.i.ng”.

[^xyz]

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

Например, [^abc] эквивалентно [^a-c]. Они соответствуют изначально ‘r’ в “brisket” и ‘h’ в “chop.”

[b] Соответствует бэкспейсу (U+0008). (Не путать с b.)
b

Соответствует границе слова. Граница слова соответствует позиции, где за символом слова не следует другой символ слова или предшествует ему. Отметим, что граница слова не включается в соответствие. Другими словами, длина сопоставленной границы слова равна нулю. (Не путать с [b].)

Примеры:
/bmoo/ соответствует ‘moo’ в слове “moon” ;
/oob/ не соответствует ‘oo’ в слове “moon”, поскольку за ‘oo’ следует символ ‘n’ , являющимся символом слова;
/oonb/ соответствует ‘oon’ в слове “moon”, поскольку ‘oon’ является окончанием строки, и таким образом, за этими символами не следует другой символ слова;
/wbw/ никогда не будет ничему соответствовать, поскольку за символом слова никогда не может следовать и граница слова, и символ слова.

Note: JavaScript’s regular expression engine defines a specific set of charactersto be “word” characters. Any character not in that set is considered a word break. This set of characters is fairly limited: it consists solely of the Roman alphabet in both upper- and lower-case, decimal digits, and the underscore character. Accented characters, such as “é” or “ü” are, unfortunately, treated as word breaks.

B

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

Например, /B../ соответствует ‘oo’ в слове “noonday” (, а /yB./ соответствует ‘ye’ в “possibly yesterday.”

cX

Где X является символом случайного выбора из последовательности от А до Я. Соответствует управляющему символу в строке.

Например, /cM/ соответствует control-M (U+000D) в строке.

d

Соответствует цифровому символу. Эквивалентно выражению [0-9].

Например, /d/ or /[0-9]/ соответствует  ‘2’ в “B2 is the suite number.”

D

Соответствует любому нецифровому символу. Эквивалентно выражению [^0-9].

Например, /D/ or /[^0-9]/ соответствует ‘B’ в предложении “B2 is the suite number.”

f

Соответствует символу прогона страницы (U+000C). Особый символ управления печатью.

n Соответствует символу перевода строки (U+000A).
r Соответствует символу возврата каретки (U+000D).
s

Соответствует одиночному символу пустого пространства, включая пробел, табуляция, прогон страницы, перевод строки. Эквивалентен [ fnrtv​u00A0u1680​u180eu2000​u2001u2002​u2003u2004​u2005u2006​u2007u2008​u2009u200a​u2028u2029​u2028u2029​u202fu205f​u3000].

Например, /sw*/ совпадает с ‘ bar’ в “foo bar.”

S

Соответствует одиночному символу непустого пространства. Эквивалентен [^ fnrtv​u00A0u1680​u180eu2000-u200a​​u2028u2029​u202fu205f​u3000].

Например, /Sw*/ совпадает с ‘foo’ в “foo bar.”

t Соответствует символу горизонтальной табуляции (U+0009).
v Соответствует символу вертикальной табуляции (U+000B).
w

Соответствует любому цифробуквенному символу включая нижнее подчёркивание. Эквивалентен [A-Za-z0-9_].

Например, /w/ совпадает с ‘a’ в “apple,” ‘5’ в “$5.28,” и ‘3’ в “3D.”

W

Соответствует любому не цифробуквенному символу. Равносилен [^A-Za-z0-9_].

Например, /W/ or /[^A-Za-z0-9_]/ совпадает с ‘%’ в “50%.”

n

Где n это положительное целое, обратная ссылка на последнюю найденную подстроку, соответствующую n , заключённую в круглые скобки в регулярном выражении (считая левые скобки).

Например, /apple(,)sorange1/ соответствует ‘apple, orange,’ в “apple, orange, cherry, peach.”

Соответствует символу NULL (U+0000). Не следует ставить за ним другой цифровой символ, поскольку <digits> является восьмеричной экранирующей последовательностью.
xhh Соответствует символам кода hh (две шестнадцатеричные цифры)
uhhhh Соответствует символам кода hhhh (четыре шестнадцатеричные цифры).

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

function escapeRegExp(string){ return string.replace(/[.*+?^${}()|[]\]/g, ‘\$&’); }

Использование скобок

Скобки вокруг любой части регулярного выражения означают что эта часть совпадаемой подстроки будет запомнена. Раз запомнена, подстрока может выбрана для использования как это описано в Using Parenthesized Substring Matches.

Например, паттерн /Chapter (d+).d*/ включает в себя дополнительные экранирующие и специальные символы и указывает на то, что часть шаблона должна быть запомнена. Он точно соответствует символам слова ‘Chapter ‘, за которыми следует один или более цифровых символов (d означает любой цифровой символ, а ‘+’ означает 1 или более раз), за которым следует десятичная точка (сама по себе являющаяся специальным символом; предшествующий десятичной точке слеш ‘ ‘ означает, что паттерн должен искать литеральный символ ‘.’), после которой следует любой цифровой символ 0 или более раз (‘d’ обозначает цифровой символ, ‘*’ обозначает 0 или более раз). Кроме того, круглые скобки используются для запоминания первых же совпавших цифровых символов. 

Этот шаблон будет найден во фразе “Open Chapter 4.3, paragraph 6” и цифра ‘4’ будет запомнена. Но он не будет найден во фразе “Chapter 3 and 4”, поскольку эта строка не имеет точки после цифры ‘3’.

Для того, чтобы сопоставить подстроку без вызова совпавшей части для запоминания, внутри круглых скобок необходимо предварить паттерн сочетанием символов ‘ ?:’. Например, шаблон (?:d+) будет соответствовать одному или более цифровому символу, но не запомнит совпавших символов. 

Закрепление

/hey/

сработает независимо от того где находится hey внутри строки.

Если вы хотите найти строки, которые начинаются с hey, то используйте оператор ^:

/^hey/.test(‘hey’) // ✅/^hey/.test(‘bla hey’) // ❌

Если вы хотите найти строки, которые заканчиваются на hey, то используйте оператор $:

/hey$/.test(‘hey’) // ✅/hey$/.test(‘bla hey’) // ✅/hey$/.test(‘hey you’) // ❌

Объединяя два предыдущих оператора вы можете найти строку, которая полностью совпадает с hey:

/^hey$/.test(‘hey’) // ✅

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

/^hey.*joe$/.test(‘hey joe’) // ✅/^hey.*joe$/.test(‘heyjoe’) // ✅/^hey.*joe$/.test(‘hey how are you joe’) // ✅/^hey.*joe$/.test(‘hey joe!’) // ❌

test()

Для работы с регулярными выражениями есть несколько методов. Простейший из них — test(). При использовании этого метода необходимо передать функции проверяемую строку в качестве аргумента. В результате метод возвращает булево значение: true — если в строке есть совпадения с шаблоном, false — если совпадений нет.

// Синтаксис метода test()
// /шаблон/.test(‘проверяемый текст’)

// Проверка строки,

// когда test() не находит совпаденийmyPattern.test(‘There was a cat and dog in the house.’)

// false
// Создание переменной,

// которой присваивается текст для проверкиconst myString = ‘The world of code.’

// Создание шаблона
const myPattern = /code/

// Проверка текста с помощью шаблона,

// когда test() находит совпадениеmyPattern.test(myString)

// true

Группирующие скобки

В предыдущих примерах операторы повторения действовали только на один символ, который стоял перед ними. Что делать, если мы хотим подействовать им на несколько символов?

Для этого существуют группирующие скобки ‘(‘ и ‘)’:

‘xabx xababx xaabbx’.replace(/x(ab)+x/g, ‘!’); //вернет ‘! ! xaabbx’

То есть: если что-то стоит в группирующих скобках и сразу после ‘)’ стоит оператор повторения – он подействует на все, что стоит внутри скобок.

Примеры

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

Изменение порядка в Исходной Строке

След. пример иллюстрирует формирование регулярного выражения и использование string.split() и string.replace(). Он очищает неправильно сформатированную исходную строку, которая содержит имена в неправильном порядке (имя идёт первым) разделённые пробелами, табуляцией и одной точкой с запятой. В конце, изменяется порядок следования имён (фамилия станет первой) и сортируется список.

var names = “Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand “;var output = [“———- Original Stringn”, names + “n”];var pattern = /s*;s*/;var nameList = names.split(pattern);pattern = /(w+)s+(w+)/;var bySurnameList = [];output.push(“———- After Split by Regular Expression”);var i, len;for (i = 0, len = nameList.length; i < len; i++){ output.push(nameList[i]); bySurnameList[i] = nameList[i].replace(pattern, “$2, $1”);}output.push(“———- Names Reversed”);for (i = 0, len = bySurnameList.length; i < len; i++){ output.push(bySurnameList[i]);}bySurnameList.sort();output.push(“———- Sorted”);for (i = 0, len = bySurnameList.length; i < len; i++){ output.push(bySurnameList[i]);}output.push(“———- End”);console.log(output.join(“n”));

Использование спецсимволов для проверки входных данных

В след. примере, ожидается что пользователь введёт телефонный номер и требуется проверить правильность символов набранных пользователем. Когда пользователь нажмёт кнопку “Check”, скрипт проверит правильность введённого номера. Если номер правильный (совпадает с символами определёнными в регулярном выражении), то скрипт покажет сообщение благодарности для пользователя и подтвердит номер. Если нет, то скрипт проинформирует пользователя, что телефонный номер неправильный.

Внутри незахватывающих скобок (?:, регуляное выражение ищет три цифры d{3} ИЛИ |  открывающую скобку (, затем три цифры d{3}, затем закрывающую скобку ), (закрывающая незахватывающая скобка )), затем тире, слеш, или десятичная точка, и когда это выражение найдено, запоминает символ ([-/.]),  следующие за ним и запомненные три цифры d{3}, следующее соответствие тире, слеша или десятичной точки 1, и следующие четыре цифры d{4}.

Регулярное выражение ищет сначала 0 или одну открывающую скобку (?, затем три цифры d{3}, затем 0 или одну закрывающую скобку )?, потом одно тире, слеш или точка и когда найдёт это, запомнит символ([-/.]), след. три цифры d{3}, followed by the remembered match of a dash, forward slash, or decimal point 1, followed by four digits d{4}.

Событие “Изменить” активируется, когда пользователь подтвердит ввод значения регулярного выражения, нажав клавишу “Enter”. 

<!DOCTYPE html><html> <head> <meta http-equiv=Content-Type content=text/html; charset=ISO-8859-1> <meta http-equiv=Content-Script-Type content=text/javascript> <script type=text/javascript> var re = /(?d{3})?([-/.])d{3}1d{4}/; function testInfo(phoneInput){ var OK = re.exec(phoneInput.value); if (!OK) window.alert(RegExp.input + ” isn’t a phone number with area code!”); else window.alert(“Thanks, your phone number is “ + OK[0]); } </script> </head> <body> <p>Enter your phone number (with area code) and then click “Check”. <br>The expected format is like ###-###-####.</p> <form action=#> <input id=phone><button onclick=testInfo(document.getElementById(‘phone’));>Check</button> </form> </body></html>

autoPreviousNext(“JSGChapters”);

Символьные классы

Символьные классы — это своеобразные сокращения для разных типов символов. К примеру, есть свои классы для букв, цифр, пробелов и т. д.

/* Символьный класс – Значение */
. – любой символ, кроме первой строки
d – одноразрядное число (то же, что и [0-9])
w – отдельный буквенно-числовой словообразующий символ из латинского алфавита, включая подчёркивание (то же, что и [A-Za-z0-9_)
s – отдельный символ разделителя (пробел, табуляция и т. п.) (то же, что и [trnvf])
D – отдельный нечисловой символ (то же, что и[^0-9])
W – отдельный несловообразующий символ из латинского алфавита (то же, что и [^A-Za-z0-9_])
S – отдельный символ, который не является разделителем (то же, что и [^trnvf]).

Примеры:

// . – любой символ, кроме первой строки
const myPattern = /./
console.log(myPattern.test(”))
// false
console.log(myPattern.test(‘word’))
// true
console.log(myPattern.test(‘9’))
// true
// d – одноразрядное число
const myPattern = /d/
console.log(myPattern.test(‘3’))
// true
console.log(myPattern.test(‘word’))
// false
// w – отдельный буквенно-числовой словообразующий символ
const myPattern = /w/
console.log(myPattern.test(”))
// false
console.log(myPattern.test(‘word’))
// true
console.log(myPattern.test(‘9’))
// true
// s – отдельный символ разделителя
const myPattern = /s/
console.log(myPattern.test(”))
// false
console.log(myPattern.test(‘ ‘))
// true
console.log(myPattern.test(‘foo’))
// false
// D – отдельный нечисловой символ
const myPattern = /D/
console.log(myPattern.test(‘Worm’))
// true
console.log(myPattern.test(‘1’))
// false
// W – отдельный несловообразующий символ
const myPattern = /W/
console.log(myPattern.test(‘Worm’))
// false
console.log(myPattern.test(‘1’))
// false
console.log(myPattern.test(‘*’))
// true
console.log(myPattern.test(‘ ‘))
// true
// S – отдельный символ, который не является разделителем
const myPattern = /S/
console.log(myPattern.test(‘clap’))
// true
console.log(myPattern.test(”))
// false
console.log(myPattern.test(‘-‘))
// true

Альтернатива

Чередование позволяет указать альтернативную версию шаблона. Чередование в регулярном выражении работает так же, как оператор OR в условном выражении if-else.

Вы можете указать чередование, используя вертикальную черту (|). Например, регулярное выражение /fox|dog|cat/ соответствует строке «fox», или строке «dog», или строке «cat». Вот пример:

var regex = /fox|dog|cat/;var str = “The quick brown fox jumps over the lazy dog.”;var matches = str.match(regex);console.log(matches);// expected output: [“fox”, index: 16, …]

Альтернативы оцениваются слева направо, пока не будет найдено совпадение. Если левая альтернатива совпадает, правая альтернатива полностью игнорируется, даже если у нее есть совпадение.

Использование match и exec без групп

Существует разница при использовании match и exec без групп: в первом элементе массива будет находится не полностью найденная строка, а прямое совпадение:

/hey|ho/.exec(‘hey’) // [ “hey” ]/(hey).(ho)/.exec(‘hey ho’) // [ “hey ho”, “hey”, “ho” ]

Что вам делать дальше:

Приступайте к решению задач по следующей ссылке: задачи к уроку.

Когда все решите – переходите к изучению новой темы.

Флаги

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

  • g: ищет совпадения глобально
  • i: делает регулярное выражение не чувствительным к регистру
  • m: включает многострочный режим. В этом режиме ^ и $ совпадают с началом и концом всей строки. Без этого флага, с многострочными строками они совпадают с началом и концом каждой строки.
  • u: включает поддержку Unicode (добавлено в ES6/ES2015)
  • s: (новое в ES2018) сокращение от “single line”, он позволяет . совпадать с символами новой строки

Флаги можно комбинировать, а также они добавляются в конец строки литерала:

/hey/ig.test(‘HEy’) // ✅

или передаются вторым параметром в конструктор объекта RegExp:

new RegExp(‘hey’, ‘ig’).test(‘HEy’) // ✅

Границы строк

b и B позволяют определить находится ли строка в начале или конце слова:

  • b совпадает если набор символов находится в начале или конце слова
  • B совпадает если набор символов не находится в начале или конце слова

Пример:

‘I saw a bear’.match(/bbear/) //Array [“bear”]’I saw a beard’.match(/bbear/) //Array [“bear”]’I saw a beard’.match(/bbearb/) //null’cool_bear’.match(/bbearb/) //null

Замена с помощью регулярных выражений

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

Также мы видели как можно извлекать часть строк соотвествующие шаблону в массив.

Теперь давайте рассмотрим как заменять части строки на основе шаблона.

У объекта String в JavaScript есть метод replace(), который можно использовать без регулярных выражений для одной замены в строке:

“Hello world!”.replace(‘world’, ‘dog’) //Hello dog!”My dog is a good dog!”.replace(‘dog’, ‘cat’) //My cat is a good dog!

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

“Hello world!”.replace(/world/, ‘dog’) //Hello dog!

Использование флага g – это единственный способ заменить несколько вхождений в строке на ванильном JavaScript:

“My dog is a good dog!”.replace(/dog/g, ‘cat’) //My cat is a good cat!

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

“Hello, world!”.replace(/(w+), (w+)!/, ‘$2: $1!!!’)// “world: Hello!!!”

Вместо строки можно использовать функцию, чтобы делать ещё более интересные вещи. В неё будет передан ряд аргументов, таких как возвращают методы String.match(RegExp) или RegExp.exec(String), где количество аргументов зависит от количества групп:

“Hello, world!”.replace(/(w+), (w+)!/, (matchedString, first, second) => { console.log(first); console.log(second); return `${second.toUpperCase()}: ${first}!!!`})//”WORLD: Hello!!!”

Рейтинг
( 1 оценка, среднее 5 из 5 )
Загрузка ...