Lorsque vous utilisez une chaîne de caractères, vous pouvez lui appliquer la fonction match(), de la manière suivante :

var message = 'Bonjour les gens !';
 var regex = /les/;
 if(message.match(regex))
    alert('Tiens, il y a plusieurs personnes ?');
 else
    alert('Tout seul...');

Si vous exécutez ce code, vous obtiendrez une alerte "Tiens, il y a plusieurs personnes ?". En effet, la regex /les/ vérifie que "les" est présent au moins une fois dans la chaîne de caractère message (qu'on peut appeler sujet de l'expression régulière).

Notez que j'aurais très bien pu écrire le code de cette manière :

var message = 'Bonjour les gens !';
  if(message.match(/les/))
     alert('Tiens, il y a plusieurs personnes ?');
  else
     alert('Tout seul...');

C'est vraiment similaire aux chaînes de caractères.

Vous pouvez aussi utiliser l'objet RegExp pour créer des expressions régulières. Dans ce cas, la fonction match() fonctionnera très bien aussi.

var message = 'Bonjour les gens !';
   var regex = new RegExp('les');
   if(message.match(regex))
      alert('Tiens, il y a plusieurs personnes ?');
   else
      alert('Tout seul...');

Vous voyez que j'ai juste créé un objet RegExp. Notez qu'il n'y a pas besoin d'écrire les / lorsque l'on utilise l'objet RegExp. Cela permet (notamment) de créer une regex à partir d'une chaîne de caractères.

Par exemple, le code suivant ne peut fonctionner qu'à partir d'une RegExp :

var prompt_regex = prompt('Votre regex ?', '');
   var prompt_message = prompt('Votre message ?', '');

   var regex = new RegExp(prompt_regex);

   if(prompt_message.mach(prompt_message))
        alert('La regex a trouvé quelque chose !');
   else
        alert('La regex n'a rien trouvé ;-(');

Car en effet, vous ne pouvez pas écrire :

var regex = // + prompt_regex;

Cela génèrera une erreur.

Les regex utilisent des caractères spéciaux pour pouvoir chercher plus facilement une information dans une chaîne de caractères. Et leur but est de vous faire gagner du temps et du code.

La preuve, si vous voulez que l'utilisateur saisisse un code, et que vous voulez que celui-ci soit bien constitué uniquement de 4 chiffres, vous devrez effectuer le code suivant sans regex :

var code = prompt('Le code svp ?', '');
   var error = false;

   for(var i = 0; i < 4; i++)
        if(!code[i] == '0' || !code[i] == '1' || !code[i] == '2' || !code[i] == '3' || !code[i] == '4' || !code[i] == '5' || !code[i] == '6' || !code[i] == '7' || !code[i] == '8' || !code[i] == '9') {
            error = true;
            break;
        }

  if(!error)
        alert('Le code semble correct...');
  else
        alert('Mauvais format de code ! (4 chiffres)');

Et voici ce que ça donne avec une regex :

var code = prompt('Le code svp ?', '');
    var error = false;

    if(!code.match(/^([0-9]){4}$/))
          alert('Le code semble correct...');
    else
          alert('Mauvais format de code ! (4 chiffres)');

Avouez qu'on gagne quand même à utiliser des regex, hein ? :-) Et c'est encore pire pour vérifier une adresse e-mail, par exemple !

Analysons ensemble cette regex.

• Le ^ indique que la chaîne de caractères doit commencer par ce qui est marqué après.
• Le $ indique que la chaîne de caractères doit se terminer par ce qui est marqué avant.

Vous l'aurez compris, une regex entourée d'un ^ et d'un $ signifie que toute la chaîne de caractères doit correspondre. Par exemple, "les gens" fonctionne avec /les/, avec /^les/, mais pas avec /^les$/ ou même /les$/.

• Les caractères situés entre les deux crochets [ et ] permettent de dire "n'importe quoi mais qui est marqué entre ces crochets". Par exemple, [0-9] veut dire "n'importe quel chiffre", [abc] veut dire "la lettre a, la lettre b ou la lettre c". On peut utiliser dans une regex : 0-9 : un chiffre ;a-z : une lettre minuscule ;A-Z : une lettre majuscule ;ou des caractères indépendants, comme [abc].
• Les parenthèses permettent de spécifier son contenu comme une donnée de la regex. On verra ça plus tard, ne vous inquiétez pas.
• Un chiffre entre crochets permet de dire "ce qu'il y a avant, répété x fois". Par exemple, ([0-9]){4} signifie "un chiffre, répété 4 fois", soit 1456, 1795, 7513, etc. On peut également dire "au moins 4 fois" si le code fait minimum 4 chiffres, en écrivant ([0-9]){4,}. Ou encore "2 à 4 fois" avec ([0-9]){2,4}.

Vous voyez, les expressions régulières sont vraiment très utiles lorsqu'il s'agit de vérifier le contenu d'une chaîne de caractères !

Comprendre les regex n'est pas chose facile, si vous n'avez pas tout compris, n'hésitez pas à relire cette partie du cours !

Les répétitions

Si vous voulez que la chaîne de caractères donnée contienne "il y a x personnes" (il y a 8 personnes, il y a 45 personnes, etc.), vous ne pouvez pas seulement utiliser un ([0-9]). Vous devez vérifier qu'il y a au moins un chiffre, sinon plusieurs. La solution que nous avons vue est de faire :

/^il y a ([0-9]){1,} personnes$/

Mais on peut le faire encore plus facilement en utilisant un opérateur avant la parenthèse fermante :

/^il y a ([0-9]+) personnes$/

Le + permet de dire "au moins une fois", il "remplace" le {1,} (en fait c'est plus complexe que ça, mais nous le verrons plus tard). Si j'avais mis un ?, ça aurait voulu dire "optionnel", c'est-à-dire soit 0 fois, soit 1, soit 2, etc. Il "remplace" le {0,}

1) Sujet

Voyons voir si vous avez bien tout compris ! Vous allez devoir créer une regex qui permet de vérifier que le pseudo saisit par l'utilisateur contient bien des chiffres, des lettres ou des tirets bas, et fait de 6 à 20 caractères de long. A vos marques, prêts, codez !

Ne lisez pas la suite du cours à moins de ne pas du tout réussir à créer cette regex !

2) Correction

Tout d'abord, nous devons vérifier que le pseudo contient des lettres, des chiffres ou des tirets bas (_). On fait donc :

([0-9a-zA-Z_])

Maintenant, il faut qu'il mesure entre 6 et 20 caractères, donc :

(([0-9a-zA-Z_]){6,20}

Enfin, il doit être UNIQUEMENT composé de cela, donc commencer et termine par notre regex :

^([0-9a-zA-Z_]){6,20}$

Et le code final :

var pseudo = prompt('Votre pseudo ?', '');

  if(pseudo.match(/^([0-9a-zA-Z_]){6,20}$/))
        alert('Pseudo correct !');
  else
        alert('Pseudo incorrect ;-(');