Créer, tester et relire des regex avec Claude Code

Les expressions régulières échouent souvent quand le besoin est flou. Un motif qui accepte user@example.com peut refuser user+tag@sub.example.co.jp, accepter par erreur user@.com, ou devenir illisible dès qu’un groupe de capture est ajouté.

Claude Code est utile parce qu’il transforme des exemples en boucle vérifiable: chaînes acceptées, chaînes refusées, regex, tests exécutables et liste de relecture. Une expression régulière décrit la forme d’un texte. Une capture nommée donne un nom lisible à une partie extraite, par exemple timestamp ou requestId.

Si vous débutez, commencez par le guide de démarrage Claude Code. Pour mieux formuler vos demandes, lisez aussi 5 conseils pour de meilleurs prompts. Les références officielles à garder sous la main sont Claude Code overview et MDN Regular expressions.

Flux de travail

flowchart LR
  A["Exemples acceptés"] --> C["Demander à Claude Code"]
  B["Exemples refusés"] --> C
  C --> D["Regex et helpers"]
  D --> E["Tests Node.js"]
  E --> F["Relecture des risques"]

Ne demandez pas seulement “une regex e-mail”. Précisez si l’objectif est la validation, l’extraction, le remplacement ou l’analyse de logs. Les exemples deviennent le contrat protégé par les tests.

Premier prompt

Crée un helper JavaScript de regex pour les adresses e-mail, les numéros de téléphone japonais et les logs applicatifs.

Contraintes:
- Exécutable directement avec Node.js
- Accepter user+tag@sub.example.co.jp
- Refuser user..name@example.com et user@.com
- Accepter 090-1234-5678, 03-1234-5678 et 05012345678
- Extraire timestamp, level, service, requestId et message avec des captures nommées
- Ajouter des tests avec node:test
- Expliquer les cas où une regex ne doit pas remplacer une validation métier

Le point important est le périmètre. La validation complète d’un e-mail selon toutes les règles possibles est rarement nécessaire pour un formulaire. Ici, on bloque les erreurs évidentes et on laisse la délivrabilité à l’e-mail de confirmation ou au backend.

Exemple 1: helper e-mail, téléphone et logs

Enregistrez ce fichier sous regex-helper.mjs, puis lancez node regex-helper.mjs.

import { fileURLToPath } from "node:url";

export const emailRegex =
  /^(?!.*\.\.)[A-Z0-9_%+-]+(?:\.[A-Z0-9_%+-]+)*@(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,63}$/i;

export const emailSearchRegex =
  /[A-Z0-9_%+-]+(?:\.[A-Z0-9_%+-]+)*@(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,63}/gi;

export const normalizedJapanesePhoneRegex = /^0(?:[5789]0\d{8}|[1-9]\d{8,9})$/;

export const looseJapanesePhoneSearchRegex =
  /0\d{1,4}[-\s]?\d{1,4}[-\s]?\d{3,4}/g;

export const appLogRegex =
  /^\[(?<timestamp>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z)\]\s+(?<level>INFO|WARN|ERROR)\s+(?<service>[a-z][a-z0-9-]*)\s+requestId=(?<requestId>[A-Za-z0-9_-]+)\s+message="(?<message>[^"]*)"$/;

export function isEmail(input) {
  return emailRegex.test(input.trim());
}

export function normalizePhone(input) {
  return input.replace(/[()\s-]/g, "");
}

export function isJapanesePhone(input) {
  return normalizedJapanesePhoneRegex.test(normalizePhone(input));
}

export function extractContacts(text) {
  const emails = [...text.matchAll(emailSearchRegex)]
    .map((match) => match[0])
    .filter(isEmail);

  const phones = (text.match(looseJapanesePhoneSearchRegex) ?? []).filter(
    isJapanesePhone,
  );

  return {
    emails: [...new Set(emails)],
    phones: [...new Set(phones)],
  };
}

export function parseLogLine(line) {
  const match = line.match(appLogRegex);
  if (!match?.groups) return null;

  return {
    timestamp: match.groups.timestamp,
    level: match.groups.level,
    service: match.groups.service,
    requestId: match.groups.requestId,
    message: match.groups.message,
  };
}

if (process.argv[1] === fileURLToPath(import.meta.url)) {
  const text = "Contact: user+tag@sub.example.co.jp / 090-1234-5678";
  const log =
    '[2026-06-02T10:15:30.000Z] ERROR billing-api requestId=req_123 message="payment failed"';

  console.log(extractContacts(text));
  console.log(parseLogLine(log));
}

Les numéros de téléphone sont normalisés avant la validation. Le motif reste plus court, et les différences de tirets ou d’espaces ne changent pas le résultat. Pour les logs, les captures nommées rendent la relecture plus simple: match.groups.requestId est plus clair que match[4].

Exemple 2: tests de non-régression

Enregistrez ce fichier sous regex-helper.test.mjs, puis lancez node --test regex-helper.test.mjs.

import test from "node:test";
import assert from "node:assert/strict";
import {
  extractContacts,
  isEmail,
  isJapanesePhone,
  parseLogLine,
} from "./regex-helper.mjs";

test("validates practical email addresses", () => {
  assert.equal(isEmail("user@example.com"), true);
  assert.equal(isEmail("user+tag@sub.example.co.jp"), true);
  assert.equal(isEmail("user..name@example.com"), false);
  assert.equal(isEmail("user@.com"), false);
  assert.equal(isEmail("@example.com"), false);
});

test("validates Japanese phone numbers after normalization", () => {
  assert.equal(isJapanesePhone("090-1234-5678"), true);
  assert.equal(isJapanesePhone("03-1234-5678"), true);
  assert.equal(isJapanesePhone("05012345678"), true);
  assert.equal(isJapanesePhone("123-4567-8901"), false);
  assert.equal(isJapanesePhone("090-123-456"), false);
});

test("extracts contacts from free text", () => {
  assert.deepEqual(
    extractContacts("support: user+tag@example.com, tel: 090-1234-5678"),
    {
      emails: ["user+tag@example.com"],
      phones: ["090-1234-5678"],
    },
  );
});

test("parses application logs with named captures", () => {
  const parsed = parseLogLine(
    '[2026-06-02T10:15:30.000Z] WARN auth-service requestId=req_abc message="retry required"',
  );

  assert.deepEqual(parsed, {
    timestamp: "2026-06-02T10:15:30.000Z",
    level: "WARN",
    service: "auth-service",
    requestId: "req_abc",
    message: "retry required",
  });
});

Demandez ensuite à Claude Code d’exécuter les tests.

Lance node --test regex-helper.test.mjs.
Si un test échoue, explique d'abord si le problème vient de la regex ou de la donnée de test.
Avant d'élargir le support des e-mails, ajoute un exemple accepté et un exemple refusé.

Exemple 3: extraction de logs

Les logs sont un bon cas d’usage, car leur format est contrôlé par l’application.

Lis logs/app.log, extrait uniquement les lignes ERROR, puis écris requestId et message dans un CSV.
Utilise le même appLogRegex que regex-helper.mjs.
Ne supprime pas silencieusement les lignes non parsables; affiche leur nombre à la fin.
N'écris pas d'adresses e-mail ni de numéros de téléphone dans le CSV.

En production, des formats anciens, des lignes tronquées ou des sorties de debug temporaires apparaissent toujours. Un parseur qui retourne null est plus facile à auditer qu’un script qui ignore les erreurs.

Modèle de relecture

## Regex review request

Files:
- regex-helper.mjs
- regex-helper.test.mjs

Review:
- Are allowed and rejected examples covered by tests?
- Are email, phone, and log responsibilities separated?
- Are named capture names readable?
- Is there any ambiguous repetition that could cause ReDoS?
- Could personal data leak into logs or CSV output?

Output:
- For each issue, include file, line, reason, and suggested fix
- Ask a question instead of guessing when the business rule is unclear
- Run node --test regex-helper.test.mjs after changes

ReDoS désigne une regex qui peut prendre un temps extrême sur une entrée choisie. Dès que des répétitions sont imbriquées, demandez explicitement à Claude Code de vérifier ce risque.

Pièges fréquents

Piège	Meilleure consigne
Donner seulement des exemples valides	Ajouter au moins 3 exemples refusés
Utiliser .* partout	Définir une borne concrète comme [^"]*
Réutiliser une regex avec g dans test()	Séparer regex de validation et de recherche
Dépendre des index de capture	Utiliser des captures nommées ou non capturantes
Confondre regex et validation métier	Vérifier délivrabilité et existence côté backend

La regex est adaptée pour mettre en forme une entrée ou extraire des données d’un texte contrôlé. Elle ne prouve pas qu’un e-mail est joignable ni qu’un numéro existe.

CTA

Les corrections de regex touchent souvent les formulaires de leads, les logs de paiement, le support et les téléchargements. Pour pratiquer, commencez par la fiche gratuite Claude Code. Pour des modèles réutilisables, consultez les produits. Pour un déploiement d’équipe avec validation, revue de logs et règles de relecture, utilisez la formation et consultation Claude Code.

Résumé

La bonne méthode consiste à donner à Claude Code des exemples, des contre-exemples, des tests et des critères de relecture dans la même boucle. Lors de l’essai de Masa, demander “la regex et les tests ensemble” a détecté plus tôt les cas user+tag, les téléphones avec tirets et les captures de logs nommées qu’une demande limitée à la regex.