Testeur Java RegEx

Testeur Java RegEx

Le Testeur Java RegEx de Qodex aide les développeurs à écrire, tester et déboguer des expressions régulières en temps réel en utilisant le package java.util.regex de Java. Il prend en charge les tests instantanés de patterns pour les e-mails, mots de passe, numéros de téléphone, dates, cartes de crédit et bien plus.

Vous pouvez visualiser les résultats des correspondances, les groupes de capture et les retours de syntaxe instantanément, facilitant ainsi le perfectionnement de votre regex avant de l'utiliser dans du code Java.

Note importante : Cet outil fonctionne dans le navigateur en utilisant le moteur regex JavaScript, qui diffère du java.util.regex de Java sur plusieurs points. Différences clés à connaître :

• Les quantificateurs possessifs (*+, ++, ?+) sont pris en charge en Java mais pas en JavaScript

• Les groupes atomiques ((?>...)) fonctionnent en Java mais pas en JavaScript

• Les classes de propriétés Unicode comme \p{IsGreek} ou \p{Sc} ont une prise en charge plus large en Java

• La syntaxe des backreferences diffère dans les chaînes de remplacement : Java utilise $1, JavaScript utilise $1 (identique), mais Java supporte aussi \1 dans le pattern

• Les flags : Java prend en charge Pattern.CANON_EQ et Pattern.UNIX_LINES qui n'ont pas d'équivalent en JavaScript

Pour du code Java en production, vérifiez toujours les patterns avec Pattern.compile() dans votre IDE ou un environnement d'exécution Java.

Comment l'utiliser :

1. Saisissez votre expression régulière.

2. Fournissez une chaîne de test.

3. Visualisez instantanément les correspondances surlignées et les groupes de capture.

Besoin de données de test ? Essayez nos outils :

• Générateur d'e-mails

• Générateur UUID

• Générateur de numéros de téléphone

• Générateur de mots de passe

Référence rapide / Aide-mémoire Java Regex

Gardez ce tableau sous la main pour des consultations rapides lors de l'écriture de patterns Java :

Syntaxe Java Regex : l'essentiel

Métacaractères

• . : Correspond à tout caractère unique sauf les sauts de ligne.

• ^ : Ancre la correspondance au début d'une ligne ou d'une chaîne. Exemple : ^abc correspond à abc uniquement au début.

• $ : Ancre la correspondance à la fin d'une ligne ou d'une chaîne. Exemple : xyz$ correspond à xyz uniquement à la fin.

• | : Opérateur logique OU. Exemple : cat|dog correspond à cat ou dog.

Classes de caractères

• [abc] : Correspond à l'un des caractères suivants : a, b ou c.

• [^abc] : Correspond à tout caractère sauf a, b ou c.

• [a-zA-Z] : Spécifie une plage, correspond à toute lettre majuscule ou minuscule.

Classes de caractères prédéfinies

• \d : Correspond à tout chiffre ; équivalent à [0-9].

• \D : Correspond à tout caractère non-chiffre ; équivalent à [^0-9].

• \s : Correspond à tout espace blanc (espace, tabulation, saut de ligne).

• \S : Correspond à tout caractère non-espace blanc.

• \w : Correspond à tout caractère de mot (lettres, chiffres ou underscore) ; équivalent à [a-zA-Z0-9_].

• \W : Correspond à tout caractère qui n'est pas un caractère de mot.

Quantificateurs

• * : Correspond à zéro occurrence ou plus. Exemple : lo*l correspond à ll, lol, lool, etc.

• + : Correspond à une occurrence ou plus. Exemple : lo+l correspond à lol, lool, mais pas ll.

• ? : Correspond à zéro ou une occurrence. Rend également les quantificateurs paresseux lorsque placé après eux.

• {n} : Correspond exactement à n occurrences. Exemple : a{3} correspond à aaa.

• {n,} : Correspond à n occurrences ou plus.

• {n,m} : Correspond entre n et m occurrences.

Groupes et capture

• (abc) : Capture et groupe la correspondance pour abc. Peut être réutilisé avec des backreferences.

• (?:abc) : Groupe abc sans le capturer. Utile pour appliquer des quantificateurs sans créer de références.

• (?i)abc : Active la correspondance insensible à la casse pour le groupe.

• \b : Limite de mot.

• \1, \2, etc. : Backreferences aux groupes capturés. Exemple : (\w+)\s\1 correspond aux mots répétés comme hello hello.

Assertions logiques (lookaheads et lookbehinds)

• (?=...) : Lookahead positif. Garantit que ce qui suit la position actuelle correspond au pattern. Exemple : \d(?=px) correspond à un chiffre uniquement s'il est suivi de px.

• (?!...) : Lookahead négatif. Garantit que les caractères suivants ne correspondent pas au pattern.

• (?<=...) : Lookbehind positif. Garantit que ce qui précède la position actuelle correspond au pattern.

• (?<!...) : Lookbehind négatif. Garantit que ce qui précède ne correspond pas.

Quantificateurs gourmands vs paresseux

• *? : Correspond au minimum possible, zéro fois ou plus.

• +? : Correspond au minimum possible, une fois ou plus.

• ?? : Correspond au minimum possible, zéro ou une fois.

• {n,m}? : Correspond entre n et m fois en choisissant la correspondance la plus petite.

Les quantificateurs paresseux sont utiles pour éviter de consommer trop de texte, notamment pour les balises imbriquées ou les délimiteurs répétés.

Support Unicode

• \p{L} : Correspond à tout type de lettre de toute langue.

• \p{N} : Correspond à tout type de caractère numérique.

• \p{IsGreek} : Correspond à tout caractère du bloc Unicode grec.

• \P{...} : L'inverse de \p{...}.

Les propriétés Unicode permettent à votre regex de fonctionner globalement, idéal pour les applications internationales.

Exemples courants de regex Java

Chaque exemple ci-dessous inclut du code Java complet et fonctionnel que vous pouvez copier dans votre IDE.

1. Validation d'e-mail

À utiliser avec le Validateur Regex Java pour e-mails

import java.util.regex.*;
public class EmailValidator {
public static void main(String[] args) {
String email = "test@example.com";
Pattern pattern = Pattern.compile("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$");
Matcher matcher = pattern.matcher(email);
System.out.println("Email valid: " + matcher.matches()); // true
}
}

2. Vérification de la solidité du mot de passe

Testez avec le Validateur Regex Java pour mots de passe

import java.util.regex.*;
public class PasswordValidator {
public static void main(String[] args) {
String password = "Str0ng@Pass!";
String regex = "(?=.[a-z])(?=.[A-Z])(?=.\d)(?=.[@$!%?&])[A-Za-z\d@$!%?&]{8,}";
boolean isStrong = password.matches(regex);
System.out.println("Password strong: " + isStrong); // true
}
}

3. Formats de numéros de téléphone

Couvre (123) 456-7890, 1234567890, 123-456-7890 :

import java.util.regex.*;
public class PhoneValidator {
public static void main(String[] args) {
String[] phones = {"(123) 456-7890", "1234567890", "123-456-7890"};
Pattern pattern = Pattern.compile(
"^(\d{10}|\(\d{3}\)[\s.-]?\d{3}[\s.-]\d{4}|\d{3}[\s.-]\d{3}[\s.-]\d{4})$"
);
for (String phone : phones) {
System.out.println(phone + " valid: " + pattern.matcher(phone).matches());
}
}
}

4. Correspondance de carte de crédit (Visa)

Utilisez le Validateur Regex Java pour cartes de crédit avec la vérification Luhn pour une validation complète.

import java.util.regex.*;
public class CreditCardValidator {
public static void main(String[] args) {
String card = "4111111111111111";
Pattern visa = Pattern.compile("^4[0-9]{12}(?:[0-9]{3})?$");
System.out.println("Visa valid: " + visa.matcher(card).matches()); // true
}
}

5. Formats de dates (ISO / US)

Le regex vérifie uniquement le format. Utilisez les bibliothèques de dates Java pour la validation du calendrier (ex. : années bissextiles).

import java.util.regex.*;
public class DateValidator {
public static void main(String[] args) {
String isoDate = "2024-12-25";
String usDate = "12/25/2024";
    Pattern isoPattern = Pattern.compile("\\d{4}-\\d{2}-\\d{2}");
    Pattern usPattern = Pattern.compile("\\d{2}/\\d{2}/\\d{4}");

    System.out.println("ISO valid: " + isoPattern.matcher(isoDate).matches()); // true
    System.out.println("US valid: " + usPattern.matcher(usDate).matches());     // true
}

}

Conseils importants

• Échappez toujours les caractères regex deux fois dans les chaînes Java (ex. : \. pour correspondre à un point littéral).

• Préférez les groupes non-capturants sauf si vous avez besoin de références.

• Évitez le regex pour analyser des formats structurés comme JSON, HTML ou XML, utilisez des parsers à la place.

• Utilisez Pattern.compile() une seule fois et réutilisez les patterns compilés pour de meilleures performances.

• Utilisez [\s\S] à la place de . pour la correspondance multiligne lorsque le mode DOTALL est nécessaire.

Testez d'autres patterns regex en Java :

• Validateur Regex Java pour e-mails

• Validateur Regex Java pour mots de passe

• Validateur Regex Java pour numéros de téléphone

• Validateur Regex Java pour cartes de crédit

• Validateur Regex Java pour UUID

• Validateur Regex Java pour dates

Vous souhaitez tester dans un autre langage ? Essayez nos :

• Testeur JavaScript RegEx

• Testeur Go RegEx

• Testeur Python RegEx