Comment faire correspondre «n'importe quel caractère» dans l'expression régulière?

Les éléments suivants doivent correspondre:

AAA123
ABCDEFGH123
XXXX123

puis-je faire ".*123":?

Oui, vous pouvez. Cela devrait fonctionner.

• . = tout caractère
• \. = le caractère de point réel
• .?= .{0,1}= correspond à n'importe quel caractère zéro ou une fois
• .*= .{0,}= correspond à tout caractère zéro ou plusieurs fois
• .+= .{1,}= correspond à tout caractère une ou plusieurs fois

Oui, cela fonctionnera, mais notez que .cela ne correspondra pas aux retours à la ligne sauf si vous passez l' indicateur DOTALL lors de la compilation de l'expression:

Pattern pattern = Pattern.compile(".*123", Pattern.DOTALL);
Matcher matcher = pattern.matcher(inputStr);
boolean matchFound = matcher.matches();

Utilisez le modèle .pour faire correspondre n'importe quel caractère une fois, .*pour faire correspondre n'importe quel caractère zéro ou plusieurs fois, .+pour faire correspondre n'importe quel caractère une ou plusieurs fois.

Il existe de nombreux outils de développement et de test regex sophistiqués, mais si vous voulez juste un simple harnais de test en Java, en voici un pour jouer avec:

    String[] tests = {
        "AAA123",
        "ABCDEFGH123",
        "XXXX123",
        "XYZ123ABC",
        "123123",
        "X123",
        "123",
    };
    for (String test : tests) {
        System.out.println(test + " " +test.matches(".+123"));
    }

Maintenant, vous pouvez facilement ajouter de nouveaux tests et essayer de nouveaux modèles. Amusez-vous à explorer l'expression régulière.

Voir également

• regular-expressions.info/Tutorial

Non, *correspondra à zéro ou plusieurs caractères. Vous devez utiliser +, qui correspond à un ou plusieurs à la place.

Cette expression pourrait mieux vous convenir: [A-Z]+123

Le moyen le plus courant que j'ai vu pour coder cela est avec une classe de caractères dont les membres forment une partition de l'ensemble de tous les caractères possibles.

Habituellement , les gens écrivent que [\s\S](espaces ou des espaces), bien que [\w\W], [\d\D]etc. seraient tous les travaux.

.*et .+sont pour tous les caractères sauf pour les nouvelles lignes.

Double évasion

Au cas où vous souhaiteriez inclure de nouvelles lignes, les expressions suivantes pourraient également fonctionner pour les langages nécessitant un double échappement, tels que Java ou C ++:

[\\s\\S]*
[\\d\\D]*
[\\w\\W]*

pour zéro ou plusieurs fois, ou

[\\s\\S]+
[\\d\\D]+
[\\w\\W]+

pour une ou plusieurs fois.

Évasion simple:

Le double échappement n'est pas requis pour certains langages tels que C #, PHP, Ruby, PERL, Python, JavaScript:

[\s\S]*
[\d\D]*
[\w\W]*
[\s\S]+
[\d\D]+
[\w\W]+

Tester

import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class RegularExpression{

    public static void main(String[] args){

        final String regex_1 = "[\\s\\S]*";
        final String regex_2 = "[\\d\\D]*";
        final String regex_3 = "[\\w\\W]*";
        final String string = "AAA123\n\t"
             + "ABCDEFGH123\n\t"
             + "XXXX123\n\t";

        final Pattern pattern_1 = Pattern.compile(regex_1);
        final Pattern pattern_2 = Pattern.compile(regex_2);
        final Pattern pattern_3 = Pattern.compile(regex_3);

        final Matcher matcher_1 = pattern_1.matcher(string);
        final Matcher matcher_2 = pattern_2.matcher(string);
        final Matcher matcher_3 = pattern_3.matcher(string);

        if (matcher_1.find()) {
            System.out.println("Full Match for Expression 1: " + matcher_1.group(0));
        }

        if (matcher_2.find()) {
            System.out.println("Full Match for Expression 2: " + matcher_2.group(0));
        }
        if (matcher_3.find()) {
            System.out.println("Full Match for Expression 3: " + matcher_3.group(0));
        }
    }
}

Production

Full Match for Expression 1: AAA123
    ABCDEFGH123
    XXXX123

Full Match for Expression 2: AAA123
    ABCDEFGH123
    XXXX123

Full Match for Expression 3: AAA123
    ABCDEFGH123
    XXXX123

Si vous souhaitez explorer l'expression, cela a été expliqué dans le panneau supérieur droit de regex101.com . Si vous le souhaitez, vous pouvez également regarder dans ce lien , comment cela pourrait correspondre à certains exemples d'entrées.

Circuit RegEx

jex.im visualise les expressions régulières:

Solution spécifique à l'exemple de problème: -

Essayez [A-Z]*123$correspondront 123, AAA123, ASDFRRF123. Dans le cas où vous avez besoin d'au moins un caractère avant 123utilisation [A-Z]+123$.

Solution générale à la question (Comment faire correspondre "n'importe quel caractère" dans l'expression régulière):

1. Si vous cherchez quelque chose, y compris des espaces, vous pouvez essayer [\w|\W]{min_char_to_match,}.
2. Si vous essayez de faire correspondre autre chose que des espaces, vous pouvez essayer [\S]{min_char_to_match,}.

[^]doit correspondre à n'importe quel caractère, y compris la nouvelle ligne. [^CHARS] correspond à tous les caractères sauf ceux de CHARS . Si CHARS est vide, il correspond à tous les caractères.

Exemple JavaScript:

/a[^]*Z/.test("abcxyz \0\r\n\t012789ABCXYZ") // Returns ‘true’.

Essayez l'expression régulière .{3,}. Cela correspondra à tous les caractères sauf une nouvelle ligne.

Je travaille ce point pas toujours signifie n'importe quel caractère. Exception en mode ligne unique. \p{all}devrait être

String value = "|°¬<>!\"#$%&/()=?'\\¡¿/*-+_@[]^^{}";
String expression = "[a-zA-Z0-9\\p{all}]{0,50}";
if(value.matches(expression)){
    System.out.println("true");
} else {
    System.out.println("false");
}