regExp

regExp.js

const re1 = new RegExp('hey'); // объекта RegExp
const re2 = /hey/; //литерал регулярных выражений


/*RegExp.test(String) -> boolean*/

/^hey/.test('hey');  // ^ - найти строки которые начинаются с hey
/hey$/.test('hey');  // $ - найти строки которые заканчиваются с hey
/^hey$/.test('hey'); // ^ что то тут $ - строка которая полностью совпадает

/^hey.*joe$/.test('hey joe'); // чтобы найти строку начинающуюся с одной подстроки и заканчивающуюся другой использовать .*
/^hey.*joe$/.test('hey joe!'); // ❌ будет ошибка

/*

Поиск элементов по диапазону

/[a-z]/  a, b, c, ... , x, y, z
/[A-Z]/  A, B, C, ... , X, Y, Z
/[a-c]/  a, b, c
/[0-9]/  0, 1, 2, 3, ... , 8, 9

диапозоны можно объединять

/[A-Za-z0-9]/

*/

/[A-Za-z0-9]/.test('a'); // ✅
/[A-Za-z0-9]/.test('1'); // ✅
/[A-Za-z0-9]/.test('A'); // ✅

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

/[^A-Za-z0-9]/.test('A'); // ❌
/[^A-Za-z0-9]/.test('@'); // ✅


/*
Метасимволы
\d совпадает с любым числом, эквивалентно [0-9]
\D совпадает с любым символом, который не является числом, эквивалентно [^0-9]
\w совпадает с любым буквенно-числовым символом, эквивалентно [A-Za-z0-9]
\W совпадает с любым символом, который не является буквенно-числовым значением, эквивалентно [^A-Za-z0-9]
\s совпадает с любым пробельным символом: пробел, табуляция, символ новой строки и пробелы Unicode
\S совпадает с любым символом, который не является пробелом
\0 совпадает с null
\n совпадает с символом новой строки
\t совпадает с символом табуляции
\uXXXX совпадает с символом Unicode с кодом XXXX (требуется флаг u)
. совпадает с любым символовом, кроме символа новой строки (таким как \n) (если вы не используете флаг s, объясним позже)
[^] совпадает с любым символом, включая символ новой строки. Полезно при работе с многострочными строками
*/

/*
Если вы хотите выбрать одну или другую строку, используйте оператор |.
*/

/hey|ho/.test('hey'); // ✅
/hey|ho/.test('ho');  // ✅


/*
Вы можете использовать квантификатор ?, который сделает этот символ необязательным. В нашем случае цифра должна встречаться 0 или 1 раз:
*/

/^\d?$/.test('1'); // ✅
/^\d?$/.test('');  // ✅


/*
но что если мы хотим чтобы регулярное выражение срабатывало на несколько цифр?
Вы можете сделать это 4 способами, используя +, *, {n} и {n,m}.
*/

//+ Совпадает с одним или более (>=1) элементами:
/^\d+$/.test('12');    // ✅
/^\d+$/.test('14');    // ✅
/^\d+$/.test('144343'); // ✅
/^\d+$/.test('');       // ❌
/^\d+$/.test('1a');     // ❌

//* Совпадает с 0 или более (>=0) элементами:
/^\d+$/.test('12');    // ✅
/^\d+$/.test('14');    // ✅
/^\d+$/.test('144343'); // ✅
/^\d+$/.test('');       // ✅
/^\d+$/.test('1a');     // ❌

//{n} Совпадает точно с n количеством элементов:

/^\d{3}$/.test('123');  // ✅
/^\d{3}$/.test('12');   // ❌
/^\d{3}$/.test('1234'); // ❌
/^[A-Za-z0-9]{3}$/.test('Abc'); // ✅

//{n,m} Совпадает с диапазоном от n до m элементов
/^\d{3,5}$/.test('123');    // ✅
/^\d{3,5}$/.test('1234');   // ✅
/^\d{3,5}$/.test('12345');  // ✅
/^\d{3,5}$/.test('123456'); // ❌
// m можно опустить и оставить второй предел без ограничений, чтобы было минимум n элементов:

//Следующий за элементом знак ?, сделает его необязательным:

/^\d{3}\w?$/.test('123'); // ✅
/^\d{3}\w?$/.test('123a'); // ✅
/^\d{3}\w?$/.test('123ab'); // ❌

// Используя круглые скобки, вы можете создавать группы символов (...).

//Пример ниже ищет точное совпадение из 3 цифр за которым следует один или более буквенно-числовые символов:

/^(\d{3})(\w+)$/.test('123'); // ❌
/^(\d{3})(\w+)$/.test('123sdsa'); // ✅

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

/*????????*/
/^(\d{2})+$/.test('12');
/^(\d{2})+$/.test('123');
/^(\d{2})+$/.test('12344');
/*????????*/


'123s'.match(/^(\d{3})(\w+)$/);
/^(\d{3})(\w+)$/.exec('123 s')
'123456789'.match(/(\d)+/);
/^(\d{3})(\s)?(\w+)$/.exec('123 s');
/^(\d{3})(\s)?(\w+)$/.exec('123s');


const re = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
const result = re.exec('2015-01-02')


/*
Так как по умолчанию группы являются захватываемыми, нам нужен способ игнорировать некоторые группы в возвращаемом массиве. Это возможно с помощью незахватываемых групп, которые начинаются с (?:...).
*/

console.log('123s'.match(/^(\d{3})(?:\s)(\w+)$/));
console.log('123 s'.match(/^(\d{3})(?:\s)(\w+)$/));

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

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