Testez une regex sur des exemples et vérifiez les captures
Appliquez une expression régulière à une liste d'exemples et voyez lesquels correspondent et ce que chaque groupe a capturé : sur trois exemples, deux correspondent, et Gadget: 7 donne Gadget et 7. Chaque ligne est testée séparément, un résultat ne fausse donc jamais le suivant. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Motif
- ^(?<name>[A-Za-z]+):\s*(\d+)$
- Indicateurs
- i
- Échantillons
- Widget: 42, not a record, Gadget: 7
- Nombre d'échantillons
- 3
- Correspondances
- 2
Tester une expression régulière sur une seule chaîne soigneusement choisie révèle rarement tous ses défauts. Les données réelles comprennent des enregistrements valides, des cas proches à refuser, des différences de casse, des champs facultatifs et des valeurs répétées. Cet outil applique indépendamment un motif regex ECMAScript et ses indicateurs à une liste de chaînes d’exemple. Il indique les échantillons correspondants, toutes les occurrences lorsque la recherche globale est activée, ainsi que les groupes numérotés et nommés qui ont participé. Un motif invalide ou un indicateur non pris en charge produit une erreur claire avant tout résultat.
Constituez un jeu d’exemples qui éprouve le motif
Saisissez le corps de l’expression régulière exactement comme JavaScript doit le recevoir, sans barres obliques de délimitation. Ajoutez les indicateurs séparément afin de ne pas confondre une barre littérale avec un délimiteur. Fournissez ensuite des exemples représentant des correspondances attendues et des échecs volontaires.
Un jeu utile comporte une valeur valide ordinaire, un cas limite, des variantes de casse lorsque l’indicateur d’insensibilité est pertinent, une valeur vide ou incomplète et une chaîne contenant un texte proche qui ne doit pas convenir. Les ancres de début et de fin sont particulièrement importantes si vous souhaitez valider l’intégralité de l’échantillon plutôt que rechercher une sous-chaîne. Chaque échantillon est évalué indépendamment avec une nouvelle expression régulière : l’état d’une recherche globale ou adhésive ne passe donc jamais à la chaîne suivante.
Le résultat conserve l’échantillon d’origine et fournit un booléen de correspondance, pratique pour une lecture manuelle comme pour des assertions automatisées. Cette structure transforme une confiance approximative en exemples reproductibles qui documentent les limites prévues du motif.
Interprétez précisément les correspondances et captures
Pour chaque échantillon positif, le tableau des correspondances contient le texte exact trouvé et son index UTF-16 commençant à zéro, conformément à l’indexation des chaînes JavaScript. Les groupes numérotés apparaissent dans l’ordre d’ouverture des parenthèses sous forme d’objets associant numéro et valeur. Les groupes facultatifs absents sont omis, ce qui évite des champs nuls ambigus tout en conservant le numéro d’origine de chaque groupe présent.
Sans indicateur global, ECMAScript renvoie la première occurrence d’un échantillon. Avec cet indicateur, l’outil poursuit parmi les occurrences qui ne se chevauchent pas. Les correspondances de longueur nulle avancent sans risque pour empêcher toute boucle infinie.
La recherche adhésive conserve le comportement JavaScript natif : elle doit réussir exactement à la position courante. Examinez le texte trouvé et les captures, car un résultat positif peut encore masquer une limite de capture trop large, trop étroite ou rattachée à la mauvaise alternative.
Exploitez les erreurs et limites dans vos contrôles
Le motif et les indicateurs sont compilés avant l’évaluation des échantillons. Les indicateurs doivent appartenir au jeu ECMAScript pris en charge et ne peuvent pas être répétés. Ce contrat d’échec immédiat empêche une expression mal formée de produire une liste trompeuse de non-correspondances.
La capacité est déterministe et n’utilise ni réseau, ni inférence de modèle, ni choix aléatoire, ni horloge : des entrées identiques produisent donc des sorties structurées identiques. Des limites pratiques encadrent la longueur du motif, le nombre d’échantillons, leur taille et les occurrences par échantillon. Après une modification, vous constaterez immédiatement si les cas acceptés et refusés gardent le comportement voulu.
Cas d’usage
Validez des motifs d’extraction
Contrôlez des motifs de journaux, fichiers ou identifiants sur des exemples réalistes et examinez chaque champ extrait.
Déboguez les groupes de capture
Comparez les captures numérotées et nommées sur plusieurs formes d’entrée avant l’intégration applicative.
Questions fréquentes
Le motif doit-il inclure des barres de délimitation ?
Non. Envoyez seulement le corps de l’expression et placez les indicateurs comme g, i ou m dans le champ prévu.
Pourquoi un échantillon ne contient-il qu’une occurrence ?
Sans indicateur global, ECMAScript renvoie uniquement la première. Ajoutez g pour obtenir toutes les occurrences sans chevauchement.
Quel est le tarif ?
L’exécuteur intégré à cette page est gratuit dans le navigateur.
Quels exemples faut-il inclure dans un test ?
Prévoyez une valeur valide ordinaire, un cas limite, une autre casse si elle compte, une valeur vide ou incomplète et un texte proche qui ne doit pas correspondre. Vous verrez ainsi ce que l'expression accepte et ce qu'elle refuse.
Que se passe-t-il si mon expression régulière contient une erreur ?
L'expression et ses options sont vérifiées avant le moindre test, et l'erreur est signalée clairement. Vous n'obtenez jamais une liste trompeuse d'exemples sans correspondance due à une expression cassée.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/web/regex-test \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"pattern":"^(?<name>[A-Za-z]+):\\s*(\\d+)$","samples":["Widget: 42","not a record","Gadget: 7"]}'const res = await fetch("https://api.kit.forhosting.com/web/regex-test", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"pattern": "^(?<name>[A-Za-z]+):\\s*(\\d+)$",
"samples": [
"Widget: 42",
"not a record",
"Gadget: 7"
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/web/regex-test",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"pattern": "^(?<name>[A-Za-z]+):\\s*(\\d+)$",
"samples": [
"Widget: 42",
"not a record",
"Gadget: 7"
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/regex-test", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"pattern":"^(?<name>[A-Za-z]+):\\\\s*(\\\\d+)$","samples":["Widget: 42","not a record","Gadget: 7"]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"pattern":"^(?<name>[A-Za-z]+):\\s*(\\d+)$","samples":["Widget: 42","not a record","Gadget: 7"]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/regex-test", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"pattern": "^(?<name>[A-Za-z]+):\\s*(\\d+)$",
"samples": [
"Widget: 42",
"not a record",
"Gadget: 7"
]
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "web.regex_test",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Limites
max_pattern_chars | 2000 |
max_samples | 500 |
max_sample_chars | 100000 |
max_matches_per_sample | 10000 |
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Interprétez précisément les correspondances et captures
Les captures nommées figurent aussi dans named_groups lorsqu’elles participent.
Exploitez les erreurs et limites dans vos contrôles
Si ECMAScript refuse le motif, la requête échoue avec une erreur invalid_input dont le message signale une expression régulière invalide et reprend le détail utile du moteur. Dans une intégration continue, conservez des exemples représentatifs près du code consommateur, appelez cette capacité, puis vérifiez matched_count et les captures importantes. L’exécuteur du navigateur facilite la conception, tandis que l’API coûte $0.002 par requête pour automatiser le même test.
Cas d'intégration
Sécurisez une refonte de regex
Conservez des échantillons positifs et négatifs dans un test de régression pour repérer tout changement silencieux.
Questions techniques
Que se passe-t-il si le motif regex est invalide ?
La requête échoue avec une erreur invalid_input avant l’évaluation du moindre échantillon.
Les groupes de capture nommés sont-ils inclus ?
Oui. Les captures nommées présentes figurent dans named_groups et les captures numérotées conservent leur numéro.