Expression régulière en JavaScript

\.[{(*+?^$|

// Regex pattern describe any character.
let regex1 = /./ ;

// Regex pattern describe a dot character.
let regex2 = /\./ ;

// Create via constructor of RegExp.
var pattern = new RegExp(pattern, attributes);
 
//
var pattern = /pattern/attributes;

// Une expression régulière avec règle :
// ABC, suivi d'un caractère quelconque apparaît une ou plusieurs fois.
// Règles : ., +, +
let aRegex = /ABC.+/

let str1 = "AB DE";

// Existe-t-il une chaîne de caractères Str1 correspondant à aRegex ?
let result1 = aRegex.test(str1);

console.log(result1); // false


let str2 = "123 ABC";
// 
let result2 = aRegex.test(str2);

console.log(result2); // false

let str3 = "123 ABCdef";
// 
let result3 = aRegex.test(str3);

console.log(result3); // true

// Une expression régulière avec règle :
// ABC, suivi de x ou y ou z
// Ensuite, suivi d'un caractère quelconque apparaît une ou plusieurs fois.
// Règle : abc], . , +
// ​​​​​​​
let aRegex = /ABC[xyz].+/

let str1 = "123ABCx";
// Existe-t-il une chaîne de caractères Str1 correspondant à aRegex ?
let result1 = aRegex.test(str1);

console.log(result1); // false


let str2 = "123ABCzMNP";
//  
let result2 = aRegex.test(str2);

console.log(result2); // true

// Une expression régulière avec règle :
// ABC ou JERRY
// Ensuite, suivi d'un caractère quelconque apparaît une ou plusieurs fois.
// Suivant, suivi du CAT
// Règle : (X|Z), . , +
// ​​​​​​​
let aRegex = /(TOM|JERRY).+CAT/

let str1 = "I saw TOM, TOM caught JERRY";
// Existe-t-il une chaîne de caractères Str1 correspondant à aRegex ?
let result1 = aRegex.test(str1);

console.log(result1); // false


let str2 = "I saw TOM, TOM is a CAT";
// 
let result2 = aRegex.test(str2);

console.log(result2); // true


let str3 = "JERRY is a mouse, It is afraid of the CAT";
//  
let result3 = aRegex.test(str3);

console.log(result3); // true

// Une expression régulière avec règle :
// Commencez par TOM ou JERRY
// Ensuite, suivi d'un caractère quelconque apparaît une ou plusieurs fois.
// Suivant, suivi de CAT, et se termine.
// Règle : ^, (X|Z), . , +, $
// ​​​​​​​@@  (2)
// Existe-t-il une chaîne de caractères Str1 correspondant à aRegex ?
let aRegex = /^(TOM|JERRY).+CAT$/

let str1 = "I saw TOM, TOM caught JERRY";
// (2) 
let result1 = aRegex.test(str1);

console.log(result1); // false


let str2 = "I saw TOM, TOM is a CAT";
// 
let result2 = aRegex.test(str2);

console.log(result2); // false


let str3 = "JERRY is a mouse, It is afraid of the CAT";
// 
let result3 = aRegex.test(str3);

console.log(result3); // true

// Une expression régulière avec règle :
// Commencez par un chiffre, apparaît 5 à 7 fois et se termine.
// Règle : ^, \d, {X,Y}, $
let aRegex = /^\d{5,7}$/

let str1 = "The Result is: 12345";
// Existe-t-il une chaîne de caractères Str1 correspondant à aRegex ?
let result1 = aRegex.test(str1);

console.log(result1); // false


let str2 = "A12345";
// 
let result2 = aRegex.test(str2);

console.log(result2); // false


let str3 = "912345";
// 
let result3 = aRegex.test(str3);

console.log(result3); // true

// Une expression régulière avec règle :
// Commencez par un chiffre, apparaît 5 à 7 fois et se termine.
// Règle : ^, \d, {X,Y}, $
let aRegex = /^\d{5,7}$/m

let str1 = "The Result is: 12345";
// 
let result1 = aRegex.test(str1);

console.log(result1); // false

// Cette chaîne est divisée en deux chaînes de caractères
// Le résultat est:' &'12345'.
let str2 = "The Result is:\n12345";
// 
let result2 = aRegex.test(str2);

console.log(result2); // true

// Une expression régulière avec règle :
// ABC ou JERRY
// Ensuite, suivi d'un caractère quelconque apparaît une ou plusieurs fois.
// Suivant, suivi du CAT
// Règle : (X|Z), . , +
let aRegex = /(TOM|JERRY).+CAT/i

let str1 = "I saw TOM, TOM is a cat";
// Existe-t-il une chaîne de caractères Str1 correspondant à aRegex ?
let result1 = aRegex.test(str1);

console.log(result1); // false


let str2 = "I saw TOM, TOM is a CAT";
// 
let result2 = aRegex.test(str2);

console.log(result2); // true

// Une expression régulière avec règle :
// ABC, suivi d'un chiffre quelconque apparaît une ou plusieurs fois.
// Règles : ., \d, +
let aRegex = /ABC\d+/

let str1 = "ABC 123";

// Trouver une sous-chaîne de str1 correspondant à aRegex ?
let result1 = aRegex.exec(str1);

console.log(result1); // null

// 
let str2 = "123 ABC123 ABC45 x";
let result2 = aRegex.exec(str2);

console.log(result2); // [ 'ABC123', index: 4, input: '123 ABC123 ABC45 x' ]

console.log(result2[0]); // ABC123
console.log(result2["index"]); // 4
console.log(result2["input"]); // 123 ABC123 ABC45 x

// Une expression régulière avec règle :
// Tout chiffre apparaît une ou plusieurs fois.
// Les règles :  \d, +
let aRegex = /\d+/g

let str1 = "ABC 123 X22 345";

let array1;

do {
  array1 = aRegex.exec(str1);
  console.log(array1);
} while( array1 != null);

var substrings = str.split([separator[, limit]])

// Une expression régulière avec règle :
// Caractère espace, apparaît une ou plusieurs fois
// Les règles :  \s, +
let aRegex = /\s+/

let str1 = "Banana \t\t Apple Lemon";

let result1 = str1.split(aRegex);

console.log(result1); // [ 'Banana', 'Apple', 'Lemon' ]

var index = str.search(searchValue)

// Une expression régulière avec règle :
// TOM ou JERRY
// Règle :  (X|Z)
let aRegex = /(TOM|JERRY)/

let str = "I saw TOM, TOM caught JERRY";

let index = str.search(aRegex);

console.log(index); // 6

str.replace(regexp|substr, newSubStr|aFunction)

// Un espace apparaît une ou plusieurs fois.
// Règle : \s, +
let aRegex = /\s+/g

let str = "This \t\t is a \n\t text";

str = str.replace(aRegex, '-');

console.log(str); // This-is-a-text

// A regular expression
let regex1 = /\w+=\d+/;

// Writing as 2 groups
let regex2 = /(\w+)=(\d+)/;

// 3 groups
let regex3 = /(\w+)(=)(\d+)/;

let regex1 = /\w+=\d+/;

let regex2 = /(\w+)=(\d+)/;

let regex3 = /(\w+)(=)(\d+)/;

var STR = "abc=100";

let result1 = regex1.exec(STR);
console.log(result1);// [ 'abc=100', index: 0, input: 'abc=100' ]

let result2 = regex2.exec(STR);
console.log(result2);// [ 'abc=100', 'abc', '100', index: 0, input: 'abc=100' ]

let result3 = regex3.exec(STR);
console.log(result3);// [ 'abc=100', 'abc', '=', '100', index: 0, input: 'abc=100' ]

// Date Format: yyyy-MM-dd
let dateRegex = /([0-9]{4})-(?:[0-9]{2})-([0-9]{2})/;


var STR = "2001-11-24";

let result  = dateRegex.exec(STR);
console.log(result);// [ '2001-11-24', '2001', '24', index: 0, input: '2001-11-24' ]

console.log("Date: " + result[0]); // Date: 2001-11-24
console.log("Year: " + result[1]); // Year: 2001
console.log("Day: " + result[2]);  // Day: 24

var TEXT = " var aa = 100; let b= 130 ; const c= 110 ; ";


var regex = /\s*(var|let|const)\s+(\w+)\s*=\s*(\d+)\s*;/g;


var result;

while (result = regex.exec(TEXT) ) {

    console.log("substring: " + result[0]);
    console.log("keyword: " + result[1]);
    console.log("variable: " + result[2]);
    console.log("value: " + result[3]);
    console.log("------------------------------");
}