Expressions rationnelles JavaScript et objet RegExp

Bonjour à tous, aspirants programmeurs ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde des Expressions rationnelles (RegEx) en JavaScript. Ne vous inquiétez pas si vous n'avez jamais entendu parler de RegEx auparavant - nous allons commencer par les bases et progresser pas à pas. D'ici la fin de ce tutoriel, vous serez capable de manier la puissance de RegEx comme un pro !

Qu'est-ce que les Expressions rationnelles ?

Les Expressions rationnelles, souvent abrégées en RegEx, sont des outils puissants pour le filtrage et la manipulation de chaînes de caractères. Pensez-y comme une langue spéciale pour décrire des motifs dans le texte. Elles sont comme un couteau suisse pour travailler avec des chaînes de caractères - polyvalentes et incroyablement utiles !

Commençons par un exemple simple :

let pattern = /hello/;
let text = "Hello, world!";
console.log(pattern.test(text));  // Output: false

Dans cet exemple, /hello/ est notre motif RegEx, et nous testons s'il correspond au texte "Hello, world!". Le résultat est false car RegEx est sensible à la casse par défaut.

Objet RegExp

En JavaScript, nous pouvons créer des motifs RegEx en utilisant l'objet RegExp. Voici comment faire :

let pattern1 = new RegExp("hello");
let pattern2 = /hello/;

console.log(pattern1.test("hello world"));  // Output: true
console.log(pattern2.test("hello world"));  // Output: true

Les deux méthodes de création d'un objet RegExp sont équivalentes. La notation littérale (/pattern/) est plus couramment utilisée en raison de sa simplicité.

Modificateurs

Les modificateurs nous permettent de changer comment un motif RegEx se comporte. Jetons un œil à quelques modificateurs courants :

Modificateur	Description
i	Correspondance insensible à la casse
g	Correspondance globale (trouver toutes les correspondances, pas seulement la première)
m	Correspondance multiligne

Voici un exemple utilisant le modificateur 'i' :

let pattern = /hello/i;
let text = "Hello, World!";
console.log(pattern.test(text));  // Output: true

Maintenant, notre motif correspond à "Hello" indépendamment de la casse !

Crochets

Les crochets en RegEx sont utilisés pour définir un ensemble ou une plage de caractères à correspondre :

Crochet	Description
[abc]	Correspond à n'importe quel caractère dans les crochets
[^abc]	Correspond à n'importe quel caractère en dehors des crochets
[0-9]	Correspond à n'importe quel chiffre de 0 à 9
[a-z]	Correspond à n'importe quelle lettre minuscule

Voyons un exemple :

let pattern = /[aeiou]/;
console.log(pattern.test("hello"));  // Output: true
console.log(pattern.test("why"));    // Output: false

Ce motif correspond à n'importe quel voyelle. Il trouve une correspondance dans "hello" mais pas dans "why".

Quantificateurs

Les quantificateurs spécifient combien d'instances d'un caractère, d'un groupe ou d'une classe de caractères doivent être présents pour qu'une correspondance soit trouvée.

Quantificateur	Description
*	0 ou plus d'occurrences
+	1 ou plus d'occurrences
?	0 ou 1 occurrence
{n}	Exactement n occurrences
{n,}	n ou plus d'occurrences
{n,m}	Entre n et m occurrences

Voici un exemple amusant :

let pattern = /ba+/;
console.log(pattern.test("b"));      // Output: false
console.log(pattern.test("ba"));     // Output: true
console.log(pattern.test("baaaa"));  // Output: true

Ce motif correspond à "ba" suivi de n'importe quel nombre supplémentaire de "a". C'est comme le mugissement d'une brebis : "baaaa" !

Caractères littéraux

Les caractères littéraux en RegEx sont exactement ce qu'ils sont - ils correspondent à eux-mêmes. Par exemple, /hello/ correspond à la séquence exacte de caractères "hello".

let pattern = /hello world/;
console.log(pattern.test("hello world"));  // Output: true
console.log(pattern.test("hello earth"));  // Output: false

Méta-caractères

Les méta-caractères ont des significations spéciales en RegEx :

Méta-caractère	Description
.	Correspond à n'importe quel caractère unique
\d	Correspond à n'importe quel chiffre
\D	Correspond à n'importe quel non-chiffre
\w	Correspond à n'importe quel caractère alphabétique
\W	Correspond à n'importe quel non-caractère alphabétique
\s	Correspond à n'importe quel caractère d'espacement
\S	Correspond à n'importe quel non-caractère d'espacement

Voyons quelques exemples utilisant des méta-caractères :

let pattern = /\d{3}-\d{3}-\d{4}/;
console.log(pattern.test("123-456-7890"));  // Output: true
console.log(pattern.test("abc-def-ghij"));  // Output: false

Ce motif correspond à un format typique de numéro de téléphone américain.

Propriétés de RegExp

Les objets RegExp ont plusieurs propriétés utiles :

Propriété	Description
global	Si le drapeau "g" est défini
ignoreCase	Si le drapeau "i" est défini
multiline	Si le drapeau "m" est défini
source	Le texte du motif
lastIndex	L'index à partir duquel commencer la prochaine correspondance

Voici comment utiliser ces propriétés :

let pattern = /hello/gi;
console.log(pattern.global);      // Output: true
console.log(pattern.ignoreCase);  // Output: true
console.log(pattern.source);      // Output: "hello"

Méthodes de RegExp

Enfin, regardons quelques méthodes que nous pouvons utiliser avec les objets RegExp :

Méthode	Description
exec()	Exécute une recherche pour une correspondance dans une chaîne
test()	Teste pour une correspondance dans une chaîne
toString()	Retourne une représentation en chaîne du regexp

Voici un exemple utilisant exec() :

let pattern = /\d+/g;
let text = "I have 2 apples and 3 oranges.";
let match;

while ((match = pattern.exec(text)) !== null) {
console.log(`Found ${match[0]} at index ${match.index}`);
}

// Output:
// Found 2 at index 7
// Found 3 at index 23

Ce code trouve tous les nombres dans le texte et signale leurs positions.

Et voilà ! Nous avons couvert les bases des Expressions rationnelles en JavaScript. Souvenez-vous, la pratique rend parfait. Essayez de créer vos propres motifs et de les tester. Avant de vous en rendre compte, vous utiliserez RegEx pour résoudre toutes sortes de problèmes de manipulation de chaînes de caractères avec facilité !

Bonne programmation, et puissent vos Expressions rationnelles toujours trouver leur correspondance !

Credits: Image by storyset