Содержание

Введение в регулярные выражения в JavaScript | by Victoria Likhanova | NOP::Nuances of Programming

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

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

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

Если с помощью JavaScript вы хотите создать регулярное выражение (описать шаблон), есть два способа это сделать.

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

Первый способ — использование конструктора. Это громкое слово на самом деле означает функцию-конструктор объекта RegExp. Конструктор принимает два параметра. Первый — шаблон, который вы хотите описать. Это обязательный параметр. В конце концов, зачем вообще создавать регулярное выражение, если нет шаблона?

Второй параметр — строка с флагами (flags). Не волнуйтесь, скоро мы с ними познакомимся. Этот параметр необязательный. Стоит запомнить одно: после создания регулярного выражения флаги уже нельзя будет добавить или убрать. Поэтому, если хотите использовать флаг, добавьте его на этапе создания выражения.

// Синтаксис конструктора регулярных выражений
new RegExp(pattern[, flags])// Создание регулярного выражения
// с помощью конструктора
// без флагов
const myPattern = new RegExp('[a-z]')// Создание регулярного выражения
// с помощью конструктора
// с одним флагом
const myPattern = new RegExp('[a-z]', 'g')

Литерал регулярных выражений

Второй способ — использование литерала. Как и конструктор, литерал регулярных выражений состоит из двух частей. Первая часть — это описываемый шаблон. Он заключается в слэши (//). После закрывающего слэша идёт вторая часть — флаги. Они необязательны.

// Синтаксис литерала регулярных выражений
/pattern/flags// Создание регулярного выражения
// с помощью литерала
// без флагов
const myPattern = /[a-z]/// Создание регулярного выражения
// с помощью литерала
// с одним флагом
const myPattern = /[a-z]/g

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

Конструктор или литерал?

Конструктор и литерал выполняют одну функцию, но есть одно важное различие. Регулярное выражение, созданное при помощи конструктора, компилируется при выполнении программы, литерал — на этапе загрузки скрипта. Это значит, что литерал нельзя изменить динамически, в то время как конструктор — можно.

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

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

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

exec()

Ещё один метод, который можно использовать — exec(). Если есть совпадение, метод exec() возвращает массив. Массив содержит в себе информацию об используемом шаблоне, позиции, на которой было найдено совпадение, проверяемом тексте и наборах. Если совпадений нет, метод exec() возвращает null.

Необходимо запомнить одну вещь: метод exec() возвращает информацию только о первом найденном в тексте совпадении. Он прекращает работу после нахождения первого совпадения. Не используйте этот метод, если хотите получить множественные совпадения.

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

const myString = 'The world of code is not full of code.'// Описание шаблона
const myPattern = /code/// Использование exec() для проверки текста,
// когда exec() находит совпадение
myPattern.exec(myString)
// [
// 'code',
// index: 13,
// input: 'The world of code is not full of code.',
// groups: undefined
// ]
// Описание другого шаблона

const myPatternTwo = /JavaScript/// Использование exec() с новым шаблоном для новой проверки текста,
// когда exec() не находит совпадений
myPatternTwo.exec(myString)
// null

test() и exec() — не единственные методы, которые можно использовать для поиска совпадений строки с шаблоном. Есть ещё search(), match() и matchAll(). Эти методы принадлежат не объекту RegExp, а строкам. Несмотря на это, они позволяют применять регулярные выражения.

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

search()

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

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

const myString = 'The world of code is not full of code.'// Описание шаблона
const myPattern = /code/// Использование search() для поиска
//совпадения строки с шаблоном,
//когда search() находит совпадение

myString. search(myPattern)
// -13
// Вызов search() прямо на строке,

// когда search() не находит совпадений
'Another day in the life.'.search(myPattern)
// -1

match()

match() — второй метод объекта String, который позволяет использовать регулярные выражения. Он работает аналогично exec(): при нахождении совпадения метод match() возвращает массив с информацией об использованном шаблоне, позиции в строке, на которой было найдено совпадение, проверяемом тексте и наборах.

Так же как и exec(), match() возвращает null при отсутствии совпадений. При использовании метода match() с флагом g для поиска всех совпадений с шаблоном возвращается массив из всех совпадений.

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

const myString = 'The world of code is not full of code. '// Описание шаблона
const myPattern = /code/// Использование match() для поиска совпадения в тексте
myString.match(myPattern)
// [
// 'code',
// index: 13,
// input: 'The world of code is not full of code.',
// groups: undefined
// ]'Another day in the life.'.match(myPattern)
// null
// Использование match() для поиска всех совпадений

// Создание текста для проверки
const myString = 'The world of code is not full of code.'// Описание шаблона
const myPattern = /code/g // добавление флага 'g'// Использование match() для поиска совпадения в тексте
myString.match(myPattern)
// [ 'code', 'code' ]

matchAll()

Подобно методу match(), matchAll() возвращает все совпадения при использовании флага g в шаблоне. Однако работает он по-другому. Метод matchAll() возвращает объект RegExp String Iterator. Есть несколько способов извлечь из него все совпадения.

Во-первых, можно пройтись по объекту циклом for…of и вернуть или записать все совпадения. Также можно использовать Array.from(), чтобы создать массив из содержимого объекта, или оператор spread, который даст точно такой же результат, как и Array.from().

// Синтаксис метода match()
// 'проверяемый текст'.match(/шаблон/)// Создание текста для проверки
const myString = 'The world of code is not full of code.'// Описание шаблона
const myPattern = /code/g
// Обратите внимание, что используется флаг 'g'// Использование matchAll() для поиска совпадений в тексте
const matches = myString.matchAll(myPattern)// Использование цикла for...of для получения всех совпадений
for (const match of matches) {
console.log(match)
}
// [
// [
// 'code',
// index: 13,
// input: 'The world of code is not full of code. ',
// groups: undefined
// ],
// [
// 'code',
// index: 33,
// input: 'The world of code is not full of code.',
// groups: undefined
// ]
// ]
// Использование Array.from() для получения всех совпадений

const matches = Array.from(myString.matchAll(myPattern))
// [
// [
// 'code',
// index: 13,
// input: 'The world of code is not full of code.',
// groups: undefined
// ],
// [
// 'code',
// index: 33,
// input: 'The world of code is not full of code.',
// groups: undefined
// ]
// ]// Использование оператора spread для получения всех совпадений
const matches = [...myString.matchAll(myPattern)]
// [
// [
// 'code',
// index: 13,
// input: 'The world of code is not full of code. ',
// groups: undefined
// ],
// [
// 'code',
// index: 33,
// input: 'The world of code is not full of code.',
// groups: undefined
// ]
// ]

Вы узнали, как создавать и использовать регулярные выражения. Теперь давайте рассмотрим процесс создания шаблонов. Простейший способ составлять регулярные выражения —применение простых шаблонов. Это значит, что необходимо создать строку с особым текстом, а затем проверить, имеет ли какая-то другая строка совпадения с этим текстом.

// Создание простого шаблона
// с использованием литерала регулярного выражения
const myPattern = /JavaScript/// Проверка строки на совпадения с шаблоном
myPattern.test('One of the most popular languages is also JavaScript.')
// true// Проверка строки на совпадения с шаблоном
myPattern.test('What happens if you combine Java with scripting?')
// false

До сих пор мы использовали регулярные выражения из простых шаблонов. \t\r\n\v\f]).

Примеры:

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

Операторы контроля

Ещё один вид специальных символов — это операторы контроля. Такие символы позволяют описывать шаблоны с границами, то есть указывать, где начинается или заканчивается слово или строка. С помощью операторов контроля также можно создавать более сложные шаблоны, такие как опережающие проверки, ретроспективные проверки и условные выражения. re/console.log(myPattern.test(‘write’))
// falseconsole.log(myPattern.test(‘read’))
// trueconsole.log(myPattern.test(‘real’))
// trueconsole.log(myPattern.test(‘free’))
// false
// $ — Конец строки

const myPattern = /ne$/console.log(myPattern.test(‘all is done’))
// trueconsole.log(myPattern.test(‘on the phone’))
// trueconsole.log(myPattern.test(‘in Rome’))
// falseconsole.log(myPattern.test(‘Buy toner’))
// false
// \b — Граница слова

const myPattern = /\bro/console.log(myPattern.test(‘road’))
// trueconsole.log(myPattern.test(‘steep’))
// falseconsole.log(myPattern.test(‘umbro’))
// false// Или
const myPattern = /\btea\b/console.log(myPattern.test(‘tea’))
// trueconsole.log(myPattern.test(‘steap’))
// falseconsole.log(myPattern.test(‘tear’))
// false
// \B — Несловообразующая граница

const myPattern = /\Btea\B/console. log(myPattern.test(‘tea’))
// falseconsole.log(myPattern.test(‘steap’))
// trueconsole.log(myPattern.test(‘tear’))
// false
// x(?=y) — Опережающая проверка

const myPattern = /doo(?=dle)/console.log(myPattern.test(‘poodle’))
// falseconsole.log(myPattern.test(‘doodle’))
// trueconsole.log(myPattern.test(‘moodle’))
// false
// x(?!y) — Негативная опережающая проверка

const myPattern = /gl(?!u)/console.log(myPattern.test(‘glue’))
// falseconsole.log(myPattern.test(‘gleam’))
// true
// (?<=y)x — Ретроспективная проверка

const myPattern = /(?<=re)a/console.log(myPattern.test(‘realm’))
// trueconsole.log(myPattern.test(‘read’))
// trueconsole.log(myPattern.test(‘rest’))
// false
// (?<!y)x — Негативная ретроспективная проверка

const myPattern = /(?<!re)a/console.log(myPattern. test(‘break’))
// falseconsole.log(myPattern.test(‘treat’))
// falseconsole.log(myPattern.test(‘take’))
// true

Квантификаторы

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

/* Квантификатор - Значение */
* - 0 или более совпадений с предшествующим выражением.
+ - 1 или более совпадений с предшествующим выражением.
? - Предшествующее выражение необязательно (то есть совпадений 0 или 1).
x{n} - "n" должно быть целым положительным числом. Количество вхождений предшествующего выражения "x" равно "n".
x{n, } - "n" должно быть целым положительным числом. Количество вхождений предшествующего выражения "x" равно, как минимум, "n".
x{n, m} - "n" может быть равно 0 или целому положительному числу. "m" - целое положительное число. Если "m" > "n", количество вхождений предшествующего выражения "x" равно минимум "n" и максимум "m".

Примеры:

// * - 0 или более совпадений с предшествующим выражением
const myPattern = /bo*k/console.log(myPattern.test('b'))
// falseconsole.log(myPattern.test('bk'))
// trueconsole.log(myPattern.test('bok'))
// true
// + - 1 или более совпадений с предшествующим выражением
const myPattern = /\d+/console.log(myPattern.test('word'))
// falseconsole.log(myPattern.test(13))
// true
// ? - Предшествующее выражение необязательно, совпадений 0 или 1

const myPattern = /foo?bar/console.log(myPattern.test('foobar'))
// trueconsole.log(myPattern.test('fooobar'))
// false
// x{n} - Количество вхождений предшествующего выражения "x" равно "n"
const myPattern = /bo{2}m/console.log(myPattern.test('bom'))
// falseconsole.log(myPattern.test('boom'))
// trueconsole.log(myPattern.test('booom'))
// false
// x{n, } - Количество вхождений предшествующего выражения "x" равно, как минимум, "n"
const myPattern = /do{2,}r/console. b-g]/console.log(myPattern.test('bcd'))
// false (нет других символов, кроме входящих в диапазон от 'b' до 'g')console.log(myPattern.test('jklm'))
// true (есть другие символы, кроме входящих в диапазон от 'b' до 'g')
// (x) - "x", значение запоминается для дальнейшего использования.
const myPattern = /(na)da\1/console.log(myPattern.test('nadana'))
// true - \1 запоминает и использует совпадение 'na' из первого выражения в скобках.console.log(myPattern.test('nada'))
// false
// (?<name>x) - Создание именованной скобочной группы, к которой можно обратиться по указанному имени.
const myPattern = /(?<foo>is)/console.log(myPattern.test('Work is created.'))
// trueconsole.log(myPattern.test('Just a text'))
// false
// (?:x) - "x", значение не запоминается.
const myPattern = /(?:war)/console.log(myPattern.test('warsawwar'))
// trueconsole. log(myPattern.test('arsaw'))
// false

Альтернация

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

/* Альтернация - Значение */
| - выражение до или после символа |, как в булевом ИЛИ (||).

Примеры:

// | - Выражение до или после символа |
const myPattern = /(black|white)swan/console.log(myPattern.test('black swan'))
// trueconsole.log(myPattern.test('white swan'))
// trueconsole.log(myPattern.test('gray swan'))
// false

Флаги

Флаги — последний тип символов, которые используются в регулярных выражениях. С помощью флагов можно легко расширить функционал шаблонов. К примеру, флаги позволяют игнорировать регистр букв, чтобы шаблон находил совпадения и в верхнем, и в нижнем регистрах, находить множественные совпадения и совпадения в многострочном тексте и т. д.

/* Флаг - Значение */
g – Глобальный поиск, не останавливается после нахождения первого совпадения. " и заканчивается "$" (начало и конец каждой строки).

Примеры:

// флаг g - Глобальный поиск
const myPattern = /xyz/gconsole.log(myPattern.test('One xyz and one more xyz'))
// true// флаг i - Игнорирование регистра
const myPattern = /xyz/iconsole.log(myPattern.test('XyZ'))
// true - регистр символов не имеет значения при нечувствительном к регистру поиске.
// флаг s - Точка (.) соответствует переводу на новую строку
const myPattern = /foo.bar/sconsole.log(myPattern.test('foo\nbar'))
// trueconsole.log(myPattern.test('foo bar'))
// trueconsole.log(myPattern.test('foobar'))
// false

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

Читайте также:

  • Чистый код JavaScript — объекты и классы
  • Хроники нового текстового редактора — от замысла до реализации
  • Двоичное дерево поиска: вставка значения с использованием JavaScript

Читайте нас в телеграмме, vk и Яндекс. _`{|}~-][email protected][a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/

Определение регулярных выражения​

Определение регулярного выражения, это создание🏗️ шаблона, на основе которого будет происходить работа со строками. В JavaScript регулярные выражения — это объект, который может быть определён двумя способами.

  • Литерал
  • Конструкция

Определение регулярных выражений с использованием литералов. Для регулярных выражений литералами выступают слеши / ... /, они играют ту же роль, что и скобки ' ... ' при создании🏗️ строк.

let regExp = /шаблон/

Если вы решили создавать🏗️ регулярные выражения при помощи литералов, то стоит учитывать, что такой метод создания🏗️ не допускает динамическое изменение задаваемых значений. Происходит это из-за того, что литералы регулярных выражения вызывают предварительную компиляцию при анализе скрипта. banana$/. Метод .test() вернёт true ✅ только в том случае, если вся строка это banana.

Флаги​

Флаги используются для расширения осуществляемого регулярными выражениями поиска.

  • g — при поиске ищет все совпадения;
  • i — поиск не зависит от регистра [Z-z];
  • m — многострочный режим;
  • s — включает режим dotall, при котором точка . может соответствовать символу перевода строки;
  • y — выполняет поиск начиная с символа, который находится на позиции свойства lastindex текущего регулярного выражения;
  • u — включает поддержку Unicode.

Использование флагов при разных способах создания🏗️ шаблона регулярного выражения

  • Литерал
  • Конструкция
let regExp = /шаблон/флаг // prettier-ignore

Обратите внимание, что флаги являются

неотъемлемой частью регулярного выражения. Флаги не могут быть добавлены или удалены позднее. Также флаги можно комбинировать.

function learnJavaScript() { let regExp = /banana/i, str = ‘faNana RanaNA BaNanA’ return regExp.test(str) ? ‘Нашёл’ : ‘Нету’ }

Loading…

Попробуйте убрать флаг i из примера.

Итого​

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

Проблемы?​

Пишите в Discord или телеграмм чат, а также подписывайтесь на наши новости

Вопросы​

Для чего нужны регулярные выражения?

  1. Cоздание шаблонов
  2. Манипуляции со строками
  3. Редактирования строк

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

  1. Слеш /
  2. Обратный слеш \
  3. Квадратные скобки []

В каком способе создания регулярного выражения не допускается дальнейшее динамическое изменение задаваемых значений?

  1. В литеральном
  2. В конструкции
  3. При любом способе динамическое изменение допустимо

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

Ссылки​

  1. Learn JavaScript
  2. MDN Web Docs
  3. JS RegExp

Contributors ✨​

Thanks goes to these wonderful people (emoji key):


IIo3iTiv
📖

Dmitriy Vasilev
💵

Resoner2005
🐛 🎨 🖋

Navernoss
🖋 🐛 🎨

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

Функция ES2018, называемая именованными группами захвата, упрощает анализ даты и делает ее более читаемой.

Типичный RegExp трудно читать

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

Например, при сопоставлении даты в формате Год-Месяц-День мы получаем три пронумерованные группы захвата: 1, 2 и 3:

Появилась новая функция, называемая именованные группы захвата, которая делает это регулярное выражение проще, чем когда-либо, с использованием таких имен, как year, month и date.

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

ECMAScript2018 (ES2018) внес изменение в регулярные выражения JavaScript с добавлением именованных групп захвата.

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

Это удобная функция, которая упрощает чтение регулярных выражений.

Пример использования замены

Именованные группы захвата также можно использовать с функцией String.prototype.replace().

Метод .replace() заменит вхождение регулярного выражения в строке, но при этом будет легко ссылаться на каждую группу:

Обратите внимание, что для меня этот код не работал в Mozilla Firefox 69.0.1, поэтому мне пришлось протестировать его с помощью Google Chrome и в этой песочнице на CodeSandbox.

Преобразовать в объект Date тоже просто

Новые именованные группы захвата означают, что создание объекта Date теперь очень четко отображается в коде JavaScript:

Единственная сложность заключается в том, что конструктор даты ожидает в качестве параметра monthIndex, а не фактический месяц. Это равно месяцу минус 1.

Для групп захвата требуется

exec()

Обратите внимание, что функция RegExp.prototype.exec () используется вместо функции String.prototype.match (). Это почему?

«Если ваше регулярное выражение является глобальным, и вы выполняете захват, вы должны использовать exec. Матч не вернет все ваши снимки. Match отлично подходит для случаев, когда просто сопоставляется (а не захватывается) ».

— Stack Overflow ответ от barlop

Поэтому просто не забудьте использовать функцию .exec() вместо функции .match() при попытке использовать нумерованные или именованные группы захвата.

дальнейшее чтение

  • Флавио Коупс подробно рассказывает об объектах Date в своем блоге:


Полное руководство по датам JavaScript
Изучаете JavaScript? Загрузите мое бесплатное руководство по JavaScript 🔥 Работа с датами может быть сложной. Независимо от… flaviocopes.com



  • В Javascript.info есть много примеров использования объектов Date:


Дата и время
Знакомимся с новым встроенным объектом: Дата. Он хранит дату, время и предоставляет методы для управления датой и временем. Для… javascript.info



  • Зелл Лью написал отличный пост, посвященный объектам Date на CSS-Tricks.com:


Все, что вам нужно знать о дате в JavaScript | CSS-уловки
Странная дата в JavaScript. Это настолько действует нам на нервы, что мы обращаемся к библиотекам (например, Date-fns и Moment)… css-tricks.com



  • Moment.js надеется заменить Date, как объясняется в блоге InventiStudio:


Почему не стоит использовать Moment.js …
или, по крайней мере, что следует помнить при его использовании. Самая популярная библиотека JS DateTime, которая дала нам все, что мы… inventi. studio



  • Бен Надел показывает, как использовать именованные группы захвата для синтаксического анализа CSV с помощью Node.js в своем блоге:


Игра с именованными группами захвата RegExp в Node 10
Бен Надел экспериментирует с именованными группами захвата RegExp, которые теперь поддерживаются в Node.js 10 (с V8 версии 6.7)… www.bennadel.com



  • Флавио Копес рассказывает о RegExp и назвал группы захвата в своем блоге:


Руководство по регулярным выражениям JavaScript
Узнайте все о регулярных выражениях JavaScript с помощью этого краткого руководства, обобщающего наиболее важные концепции… flaviocopes.com


Присоединяйтесь к моему списку рассылки, чтобы получить бесплатный доступ ко всем моим статьям на Medium.

Programming JavaScript Technology Software Engineering Data Science

schedule 12.01.2022

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

❮ Предыдущий Далее ❯

Синтаксис

/ шаблон / модификатор(ы) ;

Пример

let pattern = /w3schools/i;

Попробуйте самостоятельно »

Пример объяснено:

W3Schools Для поиска
/W3Schools / REGUPPT выражение

Учебное пособие по регулярным выражениям см. в нашем учебном пособии по регулярным выражениям JavaScript.


Поддержка браузера

/ регулярное выражение / — это функция ECMAScript1 (ES1).

ES1 (JavaScript 1997) полностью поддерживается во всех браузерах:

Хром ИЭ Край Фаерфокс Сафари Опера
Да Да Да Да Да Да

Модификаторы

Модификаторы используются для выполнения глобального поиска без учета регистра:

Модификатор Описание
г Выполнить глобальное сопоставление (найти все совпадения, а не останавливаться после первого совпадения) 90-9] Найти любой символ НЕ в скобках (любой нецифровой)
(х|у) Найти любую из указанных альтернатив


Метасимволы

Метасимволы — это символы со специальным значением:

Метасимвол
Описание
. Найти один символ, кроме новой строки или символа конца строки
Найти символ слова
\Вт Найти символ, не являющийся словом
Найти цифру
\D Найти нецифровой символ
Найти символ пробела
Найти непробельный символ
Найти совпадение в начале/конце слова, начинающегося так: \bHI, заканчиваться так: HI\b
Найти совпадение, но не в начале/конце слова
\0 Найти символ NULL
Найти новый символ строки
Найти символ перевода страницы
\r Найти символ возврата каретки
Найти символ табуляции
\v Найти символ вертикальной табуляции
\xxx Найти символ, заданный восьмеричным числом xxx
\хдд Найдите символ, заданный шестнадцатеричным числом дд
= удддд Найдите символ Unicode, заданный шестнадцатеричным числом dddd

Квантификаторы

Квантификаторы Описание
n+ Соответствует любой строке, содержащей хотя бы один n
нет* Соответствует любой строке, содержащей ноль или более вхождений n
нет? Соответствует любой строке, которая содержит ноль или одно вхождение n
п{Х} Соответствует любой строке, содержащей последовательность X n 9п Соответствует любой строке с
n
в начале
?=n Соответствует любой строке, за которой следует определенная строка n
?!n Соответствует любой строке, за которой не следует определенная строка n

Свойства объекта RegExp

Свойство Описание
конструктор Возвращает функцию, которая создала прототип объекта RegExp
глобальный Проверяет, установлен ли модификатор «g»
ignoreCase Проверяет, установлен ли модификатор «i»
последний индекс
Указывает индекс, с которого начинается следующее совпадение.
многострочный Проверяет, установлен ли модификатор «m»
источник Возвращает текст шаблона RegExp

Методы объекта RegExp

Метод Описание
компиляция() Устарело в версии 1.5. Компилирует регулярное выражение
exec() Проверяет совпадение в строке. Возвращает первое совпадение
тест()
Проверяет совпадение в строке. Возвращает истину или ложь
toString() Возвращает строковое значение регулярного выражения

❮ Предыдущий Далее ❯


НОВИНКА

Мы только что запустили
Видео W3Schools

Узнать

ВЫБОР ЦВЕТА
КОД ИГРЫ

Играть в игру




Лучшие учебники
Учебник HTML
Учебник CSS
Учебник JavaScript
Учебник How To
Учебник SQL
Учебник Python
Учебник по W3. CSS
Учебник по Bootstrap
Учебник по PHP
Учебник по Java
Учебник по C++
Учебник по jQuery

Основные ссылки
HTML Reference
CSS Reference
JavaScript Reference
SQL Reference
Python Reference
W3.CSS Reference
Bootstrap Reference
PHP Reference
HTML Colors
Java Reference
Angular Reference
jQuery Reference

Top9 Примеры Примеры HTML

Примеры CSS
Примеры JavaScript
Примеры инструкций
Примеры SQL
Примеры Python
Примеры W3.CSS
Примеры Bootstrap
Примеры PHP
Примеры Java
Примеры XML
Примеры jQuery


FORUM | О

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

Используя W3Schools, вы соглашаетесь прочитать и принять наши условия использования, куки-файлы и политика конфиденциальности.

Copyright 1999-2022 Refsnes Data. Все права защищены.
W3Schools использует W3.CSS.

Объект JavaScript RegExp — использование регулярных выражений в сценариях на стороне клиента

Вариант регулярных выражений JavaScript является частью стандарта ECMA-262 для языка. Это означает, что ваши регулярные выражения должны работать одинаково во всех реализациях JavaScript. В прошлом было много серьезных проблем, связанных с браузером. Но современные браузеры очень хорошо следуют стандарту JavaScript для регулярных выражений. Вам нужно только убедиться, что ваши веб-страницы имеют тип документа, который запрашивает браузер использовать стандартный режим, а не специальный режим.

Вариант регулярных выражений JavaScript

В исходном коде JavaScript регулярное выражение записывается в виде /pattern/modifiers, где «шаблон» — это само регулярное выражение, а «модификаторы» — это последовательность символов, обозначающая различные параметры. Часть «модификаторы» необязательна. Этот синтаксис заимствован из Perl. JavaScript поддерживает следующие модификаторы, подмножество модификаторов, поддерживаемых Perl:

  • /g включает «глобальное» сопоставление. При использовании метода replace() укажите этот модификатор, чтобы заменить все совпадения, а не только первое.
  • /i делает регулярное выражение нечувствительным к регистру.
  • /m включает «многострочный режим». В этом режиме знак вставки и доллар совпадают до и после разрыва строки в строке темы.
  • /s включает «однолинейный режим». В этом режиме точка соответствует разрыву строки. Этот модификатор является новым в ECMAScript 2018. Старые браузеры, включая Internet Explorer и оригинальный Edge, его не поддерживают.

Вы можете комбинировать несколько модификаторов, связывая их вместе, как в /regex/gim. В частности, отсутствует возможность сделать так, чтобы точки соответствовали символам разрыва строки.

Поскольку регулярное выражение ограничивается косой чертой, любые косые черты, которые появляются в регулярном выражении, должны быть экранированы. Например. регулярное выражение 1/2 записывается как /1\/2/ в JavaScript.

Чтобы найти абсолютно любой символ без /s, вы можете использовать класс символов, который содержит сокращенный класс и его отрицательную версию, например [\s\S].

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

  • Нет привязок \A или \Z, соответствующих началу или концу строки. Вместо этого используйте каретку или доллар.
  • Нет группировки атомов или притяжательных кванторов.
  • Нет поддержки Unicode, за исключением сопоставления отдельных символов с \uFFFF.
  • Нет именованных групп захвата. Вместо этого используйте пронумерованные группы захвата.
  • Нет модификаторов режима для установки параметров соответствия в регулярном выражении.
  • Без условий.
  • Нет комментариев к регулярным выражениям. Вместо этого опишите регулярное выражение с помощью // комментариев JavaScript вне строки регулярного выражения. \d+$/ соответствует только строкам, полностью состоящим из цифр.

    Чтобы выполнить поиск и замену с помощью регулярных выражений, используйте метод replace() строки: myString.replace(/replaceme/g, «replacement»). Использование модификатора /g гарантирует замену всех вхождений «replaceme». Второй параметр — обычная строка с замещающим текстом.

    Использование метода split() строки позволяет разбить строку на массив строк, используя регулярное выражение для определения позиций, в которых строка разбивается. Например. myArray = myString.split(/,/) разбивает список, разделенный запятыми, на массив. Сами запятые не включаются в результирующий массив строк.

    Как использовать объект RegExp JavaScript

    Самый простой способ создать новый объект RegExp — просто использовать специальный синтаксис регулярного выражения: myregexp = /regex/. Если у вас есть регулярное выражение в строке (например, потому что оно было введено пользователем), вы можете использовать конструктор RegExp: myregexp = new RegExp(regexstring). Модификаторы могут быть указаны в качестве второго параметра: myregexp = new RegExp(regexstring, «gim»).

    Я рекомендую вам не использовать конструктор RegExp с литеральной строкой, потому что в литеральных строках необходимо экранировать обратную косую черту. Регулярное выражение \w+ может быть создано как re = /\w+/ или как re = new RegExp(«\\w+»). Последнее определенно труднее читать. Регулярное выражение \\ соответствует одной обратной косой черте. В JavaScript это становится re = /\\/ или re = new RegExp(«\\\\»).

    Каким бы способом вы ни создавали «myregexp», вы можете передать его описанным выше методам String вместо буквального регулярного выражения: myString.replace(myregexp, «replacement»).

    Если вы хотите получить совпавшую часть строки, вызовите функцию exec() созданного вами объекта RegExp, например: mymatch = myregexp.exec(«subject»). Эта функция возвращает массив. Нулевой элемент массива будет содержать текст, совпавший с регулярным выражением. Следующие элементы содержат текст, соответствующий скобкам в регулярном выражении, если таковые имеются. mymatch.length указывает длину массива match[], которая на единицу больше, чем количество групп захвата в вашем регулярном выражении. mymatch.index указывает позицию символа в строке темы, с которой совпало регулярное выражение. mymatch.input сохраняет копию строки темы.

    Вызов функции exec() также изменяет свойство lastIndex объекта RegExp. Он сохраняет в строке темы индекс, с которого будет начинаться следующая попытка сопоставления. Вы можете изменить это значение, чтобы изменить начальную позицию следующего вызова exec().

    Функция test() объекта RegExp является ярлыком для exec() != null. Он принимает строку темы в качестве параметра и возвращает true или false в зависимости от того, соответствует ли регулярное выражение части строки или нет.

    Вы также можете вызывать эти методы для литеральных регулярных выражений. /\d/.test(subject) — это быстрый способ проверить, есть ли какие-либо цифры в строке темы.

    Синтаксис текста замены

    Функция String. replace() интерпретирует несколько заполнителей в текстовой строке замены. Если регулярное выражение содержит группы захвата, вы можете использовать обратные ссылки в тексте замены. $1 в замещающий текст вставляет текст, соответствующий первой захватываемой группе, $2 — второй и так далее до $9.9. Если в вашем регулярном выражении больше 1, но меньше 10 групп захвата, то $10 рассматривается как обратная ссылка на первую группу, за которой следует буквальный ноль. Если в вашем регулярном выражении менее 7 групп захвата, то $7 рассматривается как буквальный текст $7. $& повторно вставляет все соответствие регулярному выражению. $` (обратная галочка) вставляет текст слева от совпадения с регулярным выражением, $’ (одинарная кавычка) вставляет текст справа от совпадения с регулярным выражением. $$ вставляет один знак доллара, как и любой $, который не образует один из описанных здесь заполнителей.

    $_ и $+ не являются частью стандарта, но тем не менее поддерживаются некоторыми браузерами. В Internet Explorer $_ вставляет всю строку темы. В Internet Explorer и Firefox $+ вставляет текст, соответствующий захватываемой группе с наибольшим номером в регулярном выражении. Если группа с наибольшим номером не участвовала в матче, $+ заменяется ничем. Это не то же самое, что $+ в Perl, который вставляет текст, соответствующий группе захвата с наибольшим номером, которая фактически участвовала в сопоставлении.

    В то время как такие вещи, как $&, на самом деле являются переменными в Perl, которые работают где угодно, в JavaScript они существуют только как заполнители в строке замены, передаваемой функции replace().

    Проверка поддержки регулярных выражений JavaScript в вашем веб-браузере

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

    | Быстрый старт | Учебник | Инструменты и языки | Примеры | Ссылка | Обзоры книг |

    | грэп | PowerGREP | Регулярное выражение друг | RegexMagic |

    | EditPad Lite | EditPad Pro |

    | Повышение | Дельфы | GNU (Linux) | Отличный | Ява | JavaScript | . NET | PCRE (C/C++) | PCRE2 (C/C++) | Перл | PHP | POSIX | PowerShell | Питон | Р | Руби | std::regex | Tcl | VBScript | Visual Basic 6  | wxвиджеты | XML-схема | Ходжо | XQuery и XPath | XRegExp |

    | MySQL | Оракул | PostgreSQL |

    Регулярные выражения Javascript — поиск по шаблону

    Регулярные выражения позволяют «находить» и «находить и заменять» данные с помощью текстовых строк, задающих шаблоны поиска. Регулярные выражения (или регулярные выражения) являются гибкими, мощными и значительно облегчают написание понятных и поддерживаемых программ. В этой записи блога будут рассмотрены эти шаблоны поиска и различные способы использования регулярных выражений в Javascript. 9,!]*

    находит слова, содержащие корень «кошка» в « кошка , не собака, а игрушки кошка разбросана около — категорически а катастрофа

Регулярные выражения не являются интуитивно понятными и, по-видимому, всегда требуют некоторой настройки, поэтому необходим онлайн-тестер регулярных выражений.

Как сказал Джейми Завински на alt.religion.emacs в 1997 году:

Некоторые люди, сталкиваясь с проблемой, думают: «Я знаю, я буду использовать регулярные выражения». Теперь у них две проблемы.

Синтаксис

Регулярное выражение имеет синтаксис /pattern/modifiers . Используя строку /cat/i в качестве примера, терминология регулярных выражений:

  • /cat/i — полное регулярное выражение
  • кот это шаблон
  • i это модификатор
  • косая черта / является разделителем шаблона

Функция Javascript search() принимает регулярное выражение для поиска совпадения и возвращает позицию совпадения.

Функция Javascript replace() принимает регулярное выражение и возвращает модифицированную строку, в которой заменяется шаблон.

search()

Функция Javascript search() принимает регулярное выражение и возвращает позицию в строке, где найдено совпадение (или -1, если не найдено). Например, здесь мы ищем в строке слово «Кот» с модификатором i (при поиске игнорируем регистр).

 пусть регулярное выражение = /Cat/i ; // нечувствительный к регистру поиск по запросу "Кот"
let string = "мой кот, Кот" ; // поиск в этой строке
console.log(string.search(regex)); // --> 3
 

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

 console.log( "my cat, Cat".search(/Cat/) ) ; // --> 10
console.log("мой кот, Кот".search(/Cat/i) ); // --> 3
 

ПРИМЕЧАНИЕ. Javascript /Cat/ — это совершенно другой зверь, чем «Cat» в этом контексте: первое — регулярное выражение, второе — строка. Это частый источник ярости отладчика — думать, что вы ищете с помощью сопоставления регулярных выражений только для того, чтобы обнаружить строку в кавычках. Читайте дальше для упоминания о RegExp() , что делает этот тип опечатки менее распространенным.

replace()

Функция Javascript replace() принимает регулярное выражение и возвращает строку, возможно модифицированную шаблоном, если поиск успешен. Сравните результаты следующих трех вызовов:

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

 console.log("my cat, Cat".replace("Cat", "Dog") ) ; // --> мой кот, Собака
 

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

 console.log( "мой кот, Кот".replace(/Кот/i, "Собака") ) ; // --> моя собака, кошка
 

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

 console.log("my cat, Cat".replace(/Cat/ig, "Dog") ) ; // --> моя собака, собака
 

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

Модификаторы

Модификаторы изменяют поведение сопоставления по умолчанию (возвращают первое совпадение, используют сопоставление с учетом регистра и сопоставляют только первую строку многострочной переменной):

Модификатор Описание
г глобальное соответствие (все, а не только первое)
и соответствие без учета регистра
м многострочное сопоставление

Диапазоны

Диапазоны, разделенные квадратными скобками [] , соответствуют диапазону символов:

Выражение Описание 90-9] Найти любой символ НЕ в скобках (любой нецифровой)
`(х г)`

Метасимволы

Метасимволы соответствуют определенным типам символов:

Метасимвол Описание
. одиночный символ, кроме символа новой строки или конца строки
символ слова
\Вт символ, не являющийся словом
цифра
\D нецифровой символ
символ пробела
непробельный символ
совпадение на границе слова, в начале с \bWORD или в конце WORD\b
совпадение, но не в начале или конце слова
\0 НУЛЕВОЙ символ
\n символ новой строки
символ подачи формы
символ возврата каретки
символ табуляции
\v символ вертикальной табуляции
\xxx символ, указанный восьмеричным числом xxx
\xdd символ, заданный шестнадцатеричным числом дд
\удддд символ Unicode, указанный шестнадцатеричным числом dddd

Квантификаторы

Квантификаторы изменяют определенные последовательности соответствия чисел:

Квантификатор Описание
н+ Совпадение хотя бы с одним n
нет* Совпадение с нулем или более вхождений n
нет? Совпадение с нулем или одним вхождением 9п Совпадение с в начале
?=n Соответствует любой строке, за которой следует определенная строка n
?!n Совпадение с любой строкой, за которой не следует определенная строка n

Встроенный объект Javascript RegExp обеспечивает более гибкий механизм использования переменных для каждого из соответствующих элементов. Вы видели это в действии — косая черта автоматически создает регулярные выражения — так что следующие эквиваленты:

 let foo = new RegExp("is a") ;
пусть бар = /является/ ;
 

test() и exec()

Давайте начнем изучение объекта RegExp с запуска сопоставления буквальной строки с объектом буквальной строки:

 console.log( /Cat/ig.exec( "Мой кот, Тор, это Бомбей." )) );
 

Чтобы дать Javascript-программисту максимальную вычислительную гибкость, мы помещаем строку и шаблон в переменные, а затем используем test() и exec() Методы для возврата логического значения и массива результатов соответственно:

 let string = "Мой кот, Тор, бомбейский кот". ;
пусть шаблон = /Cat/ig ;
console.log(шаблон.тест(строка)); // --> верно
console.log(шаблон.exec(строка)); // --> ["кошка"]
 

search()

Метод Javascript search() возвращает местоположение первого совпадения:

 console. log(string.search(pattern)); // --> 3
 

split()

Javascript Метод split() обрабатывает шаблон как разделитель и возвращает массив со всей строкой, разделенной шаблоном.

 let string = "Мой кот Тор - бомбейский кот." ;
пусть шаблон = /Cat/ig ;
console.log(string.split(шаблон)); // --> ["Мой ", ", Тор, Бомбей", "."]
 

match()

Метод Javascript match() возвращает массив со всеми совпадениями строк.

 console.log(string.match(шаблон)); // --> ["кот","кот"]
 9,!]*/грамм ;
console.log(string.match(шаблон));
  // --> [ "кошачий", "кошачий", "рассеянный", "категорически", "катастрофа" ]
 

replace()

Javascript replace() method

 let string = "Кошка, а не собака, и кошачьи игрушки разбросаны — категорическая катастрофа!" ;
пусть шаблон = /Cat/ig ;
пусть замена = "Собака" ;
console.log(string.replace(шаблон, замена));
 

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

Собака, не собака, и игрушки, о которых собака sDogtered — Догегорически Dogastrophe!

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