Aller au contenu
FrAIFlow

Solutions / Texte & Code

Pourquoi votre regex JavaScript ne réussit qu’un test sur deux

Le même champ est validé, puis rejeté sans avoir changé, avant d’être accepté à nouveau. Examinez l’expression régulière avant de mettre la saisie en cause. Une expression réutilisée avec le drapeau global g conserve un curseur nommé lastIndex. Le drapeau sticky y conserve lui aussi un état.

Même saisie, curseur qui se déplace
Illustration explicative fondée sur l’exemple conservé, et non capture d’application.

Rendez visible le curseur à l’origine de l’alternance

Cette alternance est particulièrement déroutante, car l’utilisateur n’a rien fait de mal. Un code peut être accepté au premier envoi, rejeté au deuxième, puis accepté après un nouveau clic. Avant de modifier les règles de saisie, trouvez l’endroit où l’expression est créée. Un motif conservé hors du gestionnaire d’événement est réutilisé ; le déplacer à l’intérieur peut masquer le problème d’état sans l’expliquer.

Dans une page de test locale ou un environnement JavaScript, gardez une seule expression et appelez-la plusieurs fois avec une même valeur sans données sensibles. Journalisez le curseur avant et après chaque appel :

const check = /foo/g;
for (let attempt = 1; attempt <= 3; attempt++) {
  const before = check.lastIndex;
  const matched = check.test("foo");
  console.log({ attempt, before, matched, after: check.lastIndex });
}

Vous devriez voir le curseur passer à 3 après une correspondance, puis revenir à 0 après un échec. La tentative suivante repart du début. Le caractère apparemment aléatoire du résultat devient ainsi visible. Utilisez une expression réservée au diagnostic : les appels d’observation font eux-mêmes avancer une regex à état et peuvent modifier le comportement étudié.

Un signalement public de 2013 décrivait cette alternance. Le test conservé sous Node.js v24.19.0 l’a reproduite avec une seule expression et une seule chaîne :

const pattern = /foo/g;
pattern.test("foo"); // true;  lastIndex = 3
pattern.test("foo"); // false; lastIndex = 0
pattern.test("foo"); // true;  lastIndex = 3

La première correspondance avance le curseur jusqu’à la fin. L’appel suivant démarre à cet endroit, ne trouve rien et le réinitialise. Changer la chaîne testée ne réinitialise pas automatiquement l’expression : le curseur appartient à l’objet RegExp.

Séparer la validation du parcours de recherche
Illustration explicative fondée sur l’exemple conservé, et non capture d’application.

Validez chaque saisie indépendamment, sans état résiduel

Pour un contrôle de formulaire ordinaire, corrigez le validateur une fois plutôt que d’ajouter des réinitialisations du curseur dans tous les gestionnaires de clic. Gardez les drapeaux utiles, par exemple pour ignorer la casse, mais retirez les drapeaux global ou sticky si chaque saisie doit être évaluée indépendamment. Recherchez d’abord les autres utilisations du même objet dans le projet. Un parcours qui collecte plusieurs correspondances peut réellement avoir besoin du curseur.

L’exemple ABC-1234 ci-dessous vérifie un format, pas tous les types d’identifiants possibles. Si la valeur doit tenir sur une seule ligne, refusez explicitement les sauts de ligne. L’ancre de fin de JavaScript comporte des particularités en fin de ligne, et le mode multiligne modifie encore le comportement des ancres. Décidez si les espaces autour de la valeur sont une erreur ou une normalisation acceptée, puis expliquez cette règle au lieu de changer silencieusement les données.

const code = /^[A-Z]{3}-\d{4}$/;
["ABC-1234", "ABC-1234", "ABC-1234"]
  .map(value => code.test(value));
// [true, true, true]

Gardez les parcours de recherche intentionnels à part

function independentTest(pattern, text) {
  pattern.lastIndex = 0;
  return pattern.test(text);
}

Cette fonction modifie l’expression qui lui est transmise. Ne l’insérez pas dans une boucle qui avance volontairement d’une correspondance à la suivante. Utilisez plutôt un validateur distinct lorsque recherche et validation coexistent ; les fonctions de rappel des tableaux ne réinitialisent pas le curseur pour vous.

Les tests conservés ont produit [true, false, true] avec l’expression globale, puis trois résultats true à la fois sans g et avec une réinitialisation explicite. Il s’agit d’un résultat ciblé sous Node, pas d’un audit complet de compatibilité des navigateurs. Si l’échec persiste une fois l’état éliminé, examinez le motif, les caractères invisibles et les hypothèses Unicode plutôt que d’ajouter encore des réinitialisations.

Vérifiez la correction dans le véritable formulaire

Testez plusieurs fois la même valeur valide, puis une valeur invalide, puis à nouveau la valeur valide. Essayez aussi deux valeurs valides différentes à la suite. La réponse doit dépendre de chaque valeur, pas de l’ordre des envois. Répétez cette courte séquence dans le formulaire réel pour vérifier que les contrôles à la perte de focus, pendant la saisie et à l’envoi appliquent tous la règle prévue.

Si une erreur apparaît encore, examinez les caractères exacts et les drapeaux restants. Ajouter une réinitialisation après chaque appel n’est pas une solution universelle : cela peut casser ailleurs une boucle de recherche intentionnelle. Séparer le validateur du parcours de recherche est plus clair et plus facile à maintenir que de faire remplir les deux rôles au même objet à état.

Séquence mesurée : true avec le curseur à 3, false avec le curseur à 0, puis true avec le curseur à 3.
Explication d’origine conservée.
Résultat enregistré d’un test synthétique expliquant pourquoi une regex JavaScript ne réussit qu’un test sur deux
Résultats RegExp.test enregistrés sous Node.js v24.19.0 avec des saisies identiques répétées. Cette image présente les résultats du test enregistré, pas l’application de l’auteur du signalement. Ouvrir l’image de preuve en grand.

Sources et lectures complémentaires