Памятка по регулярным выражениям JavaScript с примером

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

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

тестовый матч

проверить регулярное выражение

  • Используйте метод .test()
let testString = "My test string";
let testRegex = /string/;
testRegex.test(testString);

Тест на несколько совпадений

  • Используйте оператор ИЛИ (|)

const regex = /yes|no|maybe/;

игнорировать регистр

  • Используйте флаг i, чтобы не учитывать регистр
const caseInsensitiveRegex = /ignore case/i;
const testString = 'We use the i flag to iGnOrE CasE';
caseInsensitiveRegex.test(testString); // true

Извлечь первое совпадение с переменной

  • Используйте функцию .match()

const match = "Hello World!".match(/hello/i); // "Hello"

Извлечь все совпадения в массиве

  • использовать флаг g
const testString = "Repeat repeat rePeAT";
const regexWithAllMatches = /Repeat/gi;
testString.match(regexWithAllMatches); // ["Repeat", "repeat", "rePeAT"]

соответствовать

любой персонаж

  • Используйте подстановочные знаки. В качестве заполнителя для любого символа
// To match "cat", "BAT", "fAT", "mat"
const regexWithWildcard = /.at/gi;
const testString = "cat BAT cupcake fAT mat dog";
const allMatchingWords = testString.match(regexWithWildcard); // ["cat", "BAT", "fAT", "mat"]

Сопоставьте один символ с несколькими возможностями

  • С помощью класса символов вы можете использовать его для определения набора символов, который будет соответствовать
  • вы заключаете их в квадратные скобки []
// Match "cat" "fat" and "mat" but not "bat"
const regexWithCharClass = /[cfm]at/g;
const testString = "cat fat bat mat";
const allMatchingWords = testString.match(regexWithCharClass); // ["cat", "fat", "mat"]

совпадающие буквы алфавита

  • Используйте диапазон [a-z] в наборе символов
const regexWithCharRange = /[a-e]at/;
const catString = "cat";
const batString = "bat";
const fatString = "fat";

regexWithCharRange.test(catString); // true
regexWithCharRange.test(batString); // true
regexWithCharRange.test(fatString); // false

сопоставьте определенные цифры и буквы

  • Вы также можете использовать дефисы для сопоставления чисел
const regexWithLetterAndNumberRange = /[a-z0-9]/ig;
const testString = "Emma19382";
testString.match(regexWithLetterAndNumberRange) // true

соответствует одному неизвестному символу

  • Чтобы сопоставить наборы символов, которые вам не нужны, используйте отрицательные наборы символов.
  • Чтобы исключить наборы символов, используйте знак вставки ^
const allCharsNotVowels = /[^aeiou]/gi;
const allCharsNotVowelsOrNumbers = /[^aeiou0-9]/gi;

Соответствие символам, которые появляются один или несколько раз подряд

  • Используйте знак +
const oneOrMoreAsRegex = /a+/gi;
const oneOrMoreSsRegex = /s+/gi;
const cityInFlorida = "Tallahassee";

cityInFlorida.match(oneOrMoreAsRegex); // ['a', 'a', 'a'];
cityInFlorida.match(oneOrMoreSsRegex); // ['ss'];

Соответствует нулю или более последовательным вхождениям символа

  • Используйте звездочку *
const zeroOrMoreOsRegex = /hi*/gi;
const normalHi = "hi";
const happyHi = "hiiiiii";
const twoHis = "hiihii";
const bye = "bye";

normalHi.match(zeroOrMoreOsRegex); // ["hi"]
happyHi.match(zeroOrMoreOsRegex); // ["hiiiiii"]
twoHis.match(zeroOrMoreOsRegex); // ["hii", "hii"]
bye.match(zeroOrMoreOsRegex); // null

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

  • наименьшая часть строки, удовлетворяющая заданным требованиям
  • По умолчанию регулярное выражение является жадным (соответствует самой длинной части строки, удовлетворяющей заданному требованию).
  • Ленивое сопоставление с ролями ?
const testString = "catastrophe";
const greedyRexex = /c[a-z]*t/gi;
const lazyRegex = /c[a-z]*?t/gi;

testString.match(greedyRexex); // ["catast"]
testString.match(lazyRegex); // ["cat"]

совпадать с шаблоном начальной строки

  • Чтобы проверить совпадение символов в начале строки, используйте знак вставки ^, но не используйте набор символов
const emmaAtFrontOfString = "Emma likes cats a lot.";
const emmaNotAtFrontOfString = "The cats Emma likes are fluffy.";
const startingStringRegex = /^Emma/;

startingStringRegex.test(emmaAtFrontOfString); // true
startingStringRegex.test(emmaNotAtFrontOfString); // false

сопоставить шаблон конца строки

  • Используйте знак доллара в конце регулярного выражения $, чтобы проверить наличие в конце строки.
const emmaAtBackOfString = "The cats do not like Emma";
const emmaNotAtBackOfString = "Emma loves the cats";
const startingStringRegex = /Emma$/;

startingStringRegex.test(emmaAtBackOfString); // true
startingStringRegex.test(emmaNotAtBackOfString); // false

сопоставить все буквы и цифры

  • Используйте сокращение \слово
const longHand = /[A-Za-z0-9_]+/;
const shortHand = /\w+/;
const numbers = "42";
const myFavoriteColor = "magenta";

longHand.test(numbers); // true
shortHand.test(numbers); // true
longHand.test(myFavoriteColor); // true
shortHand.test(myFavoriteColor); // true

Все кроме букв и цифр

  • Вы можете использовать противоположное \w с \W
const noAlphaNumericCharRegex = /\W/gi;
const weirdCharacters = "!_$!!";
const alphaNumericCharacters = "ab283AD";

noAlphaNumericCharRegex.test(weirdCharacters); // true
noAlphaNumericCharRegex.test(alphaNumericCharacters); // false

совпадают все числа

  • Вы можете использовать набор символов [0-9] или сокращение \d
const digitsRegex = /\d/g;
const stringWithDigits = "My cat eats $20.00 worth of food a week.";

stringWithDigits.match(digitsRegex); // ["2", "0", "0", "0"]

соответствует всем нецифрам

  • Вы можете использовать противоположное \d с \D
const nonDigitsRegex = /\D/g;
const stringWithLetters = "101 degrees";

stringWithLetters.match(nonDigitsRegex); // [" ", "d", "e", "g", "r", "e", "e", "s"]

совпадать с пробелами

  • Используйте \s для сопоставления пробелов и возврата каретки
const sentenceWithWhitespace = "I like cats!"
var spaceRegex = /\s/g;
whiteSpace.match(sentenceWithWhitespace); // [" ", " "]

совпадать без пробелов

  • Вы можете использовать противоположное \s с \S
const sentenceWithWhitespace = "C a t"
const nonWhiteSpaceRegex = /\S/g;
sentenceWithWhitespace.match(nonWhiteSpaceRegex); // ["C", "a", "t"]

количество символов для соответствия

  • Вы можете указать определенное количество символов в строке, используя {lowerBound, upperBound}
const regularHi = "hi";
const mediocreHi = "hiii";
const superExcitedHey = "heeeeyyyyy!!!";
const excitedRegex = /hi{1,4}/;

excitedRegex.test(regularHi); // true
excitedRegex.test(mediocreHi); // true
excitedRegex.test(superExcitedHey); //false

Сопоставьте минимальное количество символов

  • Вы можете определить только минимальное количество символов, требующих {lowerBound,}
  • Это называется спецификатором количества
const regularHi = "hi";
const mediocreHi = "hiii";
const superExcitedHey = "heeeeyyyyy!!!";
const excitedRegex = /hi{2,}/;

excitedRegex.test(regularHi); // false
excitedRegex.test(mediocreHi); // true
excitedRegex.test(superExcitedHey); //false

соответствовать точному количеству символов

  • Вы можете указать точное необходимое количество символов, использующих {quitcountcount}
const regularHi = "hi";
const bestHi = "hii";
const mediocreHi = "hiii";
const excitedRegex = /hi{2}/;

excitedRegex.test(regularHi); // false
excitedRegex.test(bestHi); // true
excitedRegex.test(mediocreHi); //false

соответствовать всем или ни одному из персонажей

  • Чтобы проверить, существует ли символ, используйте ?
const britishSpelling = "colour";
const americanSpelling = "Color";
const languageRegex = /colou?r/i;

languageRegex.test(britishSpelling); // true
languageRegex.test(americanSpelling); // true

Премиум-контент

Граничное совпадение \b \B

\babc\bвыполнить сопоставление границ слов(^\w|\w$|\W\w|\w\W).

\b представляет позицию совпадения, такую ​​как знак вставки (это похоже на $ и ^), где одна сторона является символом слова (например, \w), а другая - нет (например, это может быть начало строки или символ пробела). ).

Вместо этого \В. Он соответствует всем местам, где \b не совпадает, если мы хотим найти шаблоны поиска, полностью окруженные символами слова.

\Babc\BСоответствует, только если шаблон полностью окружен словесными символами.

Обратная ссылка \1

([abc])\1Используйте \1, чтобы сопоставить тот же текст, который соответствует первой группе захвата

([abc])([de])\2\1Мы можем использовать \2 (\3, \4 и т. д.), чтобы идентифицировать тот же текст, который соответствует второй (третьей, четвертой и т. д.) группе захвата.

(?<foo>[abc])\k<foo>Мы помещаем имя foo в группу и ссылаемся на нее позже (\k). Результат такой же, как первое регулярное выражение выше.

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

d(?=r)соответствует только d, если за ним следует r, но r не будет частью общего совпадения регулярного выражения

(?<=r)dсоответствует только d, если ему предшествует r, но r не будет частью общего совпадения регулярного выражения

Точно так же оператор отрицания:

d(?!r)соответствует только d, если за ним не следует r, но r не будет частью общего совпадения регулярного выражения

(?<!r)dсоответствует только d, если нет предшествующего r, но r не будет частью общего совпадения регулярного выражения

Общие примеры

пространство

^[\s]*(.*?)[\s]*$

HTML-теги

соответствует любому допустимому тегу HTML и соответствующему закрывающему тегу

<([a-z]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)

шестнадцатеричное значение

соответствует любому допустимому шестнадцатеричному значению цвета

\B#(?:[a-fA-F0–9]{6}|[a-fA-F0–9]{3})\b

Email (RFC5322)

соответствует любому действительному адресу электронной почты

\b[\w.!#$%&’*+\/=?^`{|}~-]+@[\w-]+(?:\.[\w-]+)*\b

имя пользователя

Он должен содержать не менее 3 и не более 16 цифр, состоящих из букв, цифр или дефисов.

/^[a-z0-9_-]{3, 16}$/

Надежный пароль

Не менее 6 символов в длину, не менее одной прописной буквы, не менее одной строчной буквы, не менее одной цифры и не менее одного специального символа.

(?=^.{6,}$)((?=.*\w)(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[|!"$%&\/\(\)\?\^\'\\\+\-\*]))^.*

URL (http, https or ftp)

^(((https?|ftp):\/\/)?([\w\-\.])+(\.)([\w]){2,4}([\w\/+=%&_\.~?\-]*))*$

IPv4-адрес

соответствует любому допустимому IP-адресу

\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b
Категории