Como criar, testar e revisar regex com Claude Code

Expressões regulares costumam falhar quando o requisito está vago. Um padrão que aceita user@example.com pode rejeitar user+tag@sub.example.co.jp, aceitar user@.com por engano ou ficar difícil de revisar depois que outro grupo de captura é adicionado.

Claude Code ajuda porque transforma exemplos em um fluxo verificável: strings permitidas, strings rejeitadas, regex, testes executáveis e uma lista de revisão. Uma expressão regular descreve o formato de um texto. Uma captura nomeada dá um nome legível a uma parte extraída, como timestamp ou requestId.

Se você está começando, leia primeiro o guia inicial do Claude Code. Para escrever pedidos melhores, combine com 5 dicas para prompts melhores. Como referência oficial, mantenha abertos Claude Code overview e MDN Regular expressions.

Fluxo recomendado

flowchart LR
  A["Exemplos permitidos"] --> C["Pedir ao Claude Code"]
  B["Exemplos rejeitados"] --> C
  C --> D["Regex e helpers"]
  D --> E["Testes Node.js"]
  E --> F["Revisão de riscos"]

Não peça apenas “um regex de e-mail”. Diga se o uso é validação, extração, substituição ou análise de logs. Os exemplos viram o contrato que os testes protegem.

Primeiro prompt

Crie um helper JavaScript de regex para e-mails, telefones japoneses e logs de aplicação.

Requisitos:
- Deve rodar diretamente no Node.js
- Permitir user+tag@sub.example.co.jp
- Rejeitar user..name@example.com e user@.com
- Permitir 090-1234-5678, 03-1234-5678 e 05012345678
- Extrair timestamp, level, service, requestId e message dos logs com capturas nomeadas
- Adicionar testes com node:test
- Explicar onde regex não deve substituir validação de negócio

O ponto principal é o escopo. Validação completa de e-mail por RFC raramente é necessária em um formulário. Aqui usamos uma regra prática para bloquear erros óbvios e deixamos entregabilidade para e-mail de confirmação ou backend.

Exemplo 1: Helper de e-mail, telefone e logs

Salve como regex-helper.mjs e execute 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));
}

Os telefones são normalizados antes da validação. Assim a regex fica menor e hífens ou espaços não mudam o resultado. Nos logs, capturas nomeadas deixam a revisão mais clara: match.groups.requestId explica melhor que match[4].

Exemplo 2: Testes que travam o comportamento

Salve como regex-helper.test.mjs e execute 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",
  });
});

Peça ao Claude Code para executar os testes.

Execute node --test regex-helper.test.mjs.
Se algum teste falhar, explique primeiro se o erro está na regex ou nos dados de teste.
Ao ampliar o suporte de e-mail, adicione antes um exemplo permitido e um rejeitado.

Exemplo 3: Prompt para extração de logs

Logs são um bom caso para regex porque o formato é controlado pela aplicação.

Leia logs/app.log, extraia apenas linhas ERROR e grave requestId e message em CSV.
Use o mesmo appLogRegex de regex-helper.mjs.
Não descarte em silêncio linhas que não puderem ser parseadas; mostre a contagem no final.
Não escreva e-mails nem telefones no CSV.

Em produção aparecem formatos antigos, linhas truncadas e saídas temporárias de debug. Um parser que retorna null é mais fácil de revisar do que um script que ignora dados.

Template de revisão

## 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 é quando uma expressão regular pode demorar demais em uma entrada construída para isso. Se houver repetições aninhadas, peça essa revisão explicitamente ao Claude Code.

Armadilhas comuns

Armadilha	Instrução melhor
Dar só exemplos válidos	Incluir pelo menos 3 exemplos rejeitados
Usar .* para tudo	Usar limites concretos como [^"]*
Reutilizar regex com g em test()	Separar regex de validação e de busca
Depender de índices de captura	Usar capturas nomeadas ou grupos sem captura
Tratar regex como validação de negócio	Conferir entregabilidade e existência no backend

Regex é ótima para formatar entrada e extrair dados de texto controlado. Ela não prova que um e-mail recebe mensagens, nem que um telefone está ativo.

CTA

Melhorias de regex ficam perto de receita: formulários de leads, logs de pagamento, suporte e downloads. Para praticar, comece com a cola gratuita de Claude Code. Para prompts e modelos reutilizáveis, veja produtos. Para uma equipe organizar validação, revisão de logs e gates de revisão, use treinamento e consultoria Claude Code.

Resumo

A melhor forma de usar Claude Code com regex é entregar exemplos, contraexemplos, testes e critérios de revisão no mesmo ciclo. No teste de Masa, pedir “regex e testes juntos” encontrou antes os casos de user+tag, telefones com hífen e capturas nomeadas de logs do que pedir apenas uma regex.