Regex pour UN ou plusieurs lettres/chiffres Et de ZÉRO ou plusieurs espaces

Je veux permettre à 0 ou plusieurs espaces blancs dans mon string et d'un ou plusieurs A-Z ou A-z ou 0-9 dans ma chaîne.

Regex permettant un espace de caractères en Java

suggère [0-9A-Za-z ]+.

Je doute que, cette expression correspond à des schémas d'avoir zéro, un ou plusieurs espaces blancs.

Quoi faire pour permettre à 0 ou plus des espaces n'importe où dans la chaîne et un ou plusieurs caractères dans la chaîne.

Ce travail? ([0-9A-Za-z]+)([ ]*)

Par un hasard, connaissez-vous la première lettre n'est pas un blanc?
pourquoi avez-vous des doutes? Elle correspond à "blancs" - si vous voulez accepter tous les espaces, l'utilisation [0-9A-Za-z\s]+
([0-9A-Za-z]+)([ ])* exigera qu'il ne peut pas commencer par un espace.
Édité. Je voulais dire zéro, un ou plusieurs espaces.
^(.*\p{Blank}?\p{Alnum}+.*\p{Blank}?)$ cela va le faire.
Zéro, un ou plusieurs espaces de... eh Bien, la regex couvre TOUT, sauf le cas de zero whitespaces - pour cela, utilisez un vide-chaîne de vérifier et vous avez obtenu tout ce que vous devez.

InformationsquelleAutor vplusplus | 2014-04-15

java regex

15

Je crois que vous pouvez faire quelque chose comme ceci:
```
([ ]*+[0-9A-Za-z]++[ ]*+)+
```
C'est 0 ou plusieurs espaces, suivie par au moins 1 numérique char, suivi de 0 ou plusieurs espaces

^^ tout ça au moins une fois.

À l'aide de Pshemo l'idée de possessif des quantificateurs pour accélérer la regex.
- +1 bien que pas aussi chic que le " look-ahead options, c'est certainement plus facile à comprendre!
- Est-ce à vérifier pour les espaces entre les caractères? Par exemple:"bonjour, J"?
- absolument. Good sera compensée par la [0-9A-Za-z]+, puis depuis ça ne fonctionne pas, il va atteindre le début du groupe nouveau et correspondre à l'espace avec [ ]*, et répétez.
- Hmm, vous avez raison. Je ne sais pas beaucoup sur les regex interprètes. Pourrait potentiellement être plus lent car il doit revérifier pour les espaces après chaque char?
- Pas exactement. Que faire si les espaces seraient placés à la fin de la Chaîne?
- Puis Cruncher de la regex ne fonctionne pas. ([ ]*[0-9A-Za-z])+ est équivalent à ([ ]*[0-9A-Za-z]+)+ (c'est ce que je voulais dire dans mon commentaire)
- Ah, vous avez raison, dans ce cas, le mien ne fonctionne pas comme il est. Je dois mettre le dos d'espace à la fin
- Ou tout simplement faire ([ ]*[0-9A-Za-z]*)+ ou même ([ ]?[0-9A-Za-z]?)+
- Yep. Aussi ([foo]+)+ sent le retour en arrière catastrophique.
- correspondra à vide
- Bien, alors [0-9A-Za-z ]([ ][0-9A-Za-z]|[0-9A-Za-z]|[ ])+
- à ce ([0-9A-Za-z ]+[ ]*)+ fonctionne aussi bien. Il y a une tonne de variations de ce fait.
- Ma pensée est que le fait d'éviter imbriquée * et + pourrait accélérer la regex.
- ouais, en fait, j'aime donut est le meilleur, même si vous avez à penser à ce sujet pendant quelques secondes la première
- Si vous voulez accélérer cette expression, vous pouvez utiliser possessif quantificateurs ([ ]*+[0-9A-Za-z]++[ ]*+)+.
- Dans ce cas, le possessif quantificateurs ne devrait pas changer la langue à droite?
- Je ne suis pas sûr de ce que tu veux dire par "changer la langue", mais ils ne seront pas de changement de correspondance/a accepté de Chaînes.
- Eh bien, tout regex chaîne représente un langage formel (en particulier un régulière) qui est définie par les chaînes qui sont et ne sont pas là. Mettre plus spécifiquement, faire positif que les quantifieurs rejeter ou d'accepter n'importe quelle chaîne qu'il ne serait pas avant?
- J'ai appuyé sur la touche enter pour rapide. Voir ma mise à jour antérieure commentaire 🙂
- Quinconce: Cela fonctionne. Si j'ai une autre contrainte comme la chaîne doit avoir au moins un chiffre et au moins une alpha, j'ai essayé de faire ([ ]*+[0-9]++[A-Za-z]++[ ]*+)+. Cela ne fonctionne pas. Quel est le problème ici?
- Dans ce cas, vous devez utiliser look-ahead des mécanismes comme dans M42 réponse.
- ` ^(?=.*\\s*)(?=.*[0-9]+)(?=.*[a-zA-z]+) ([a-zA-z0-9 ]+$ ` - j'ai utilisé ce pour la contrainte ci-dessus. Merci beaucoup!
InformationsquelleAutor Cruncher
9

La plus simple de répondre à

* signifie zero or more équivalent à {0,}

+ signifie one or more équivalent à {1,}

alors regardez cette

[A-Z]+ signifie at least one Capital Letter, peut être écrite comme [A-Z]{1,}

[!@#$%&]. signifie que vous pouvez avoir ces Caractères Spéciaux zero or more times peut être écrite comme [!@#$%&]{0,}

désolé, mais

la purpose de cette answer être as Simple as possible

InformationsquelleAutor Basheer AL-MOMANI
7

Vous pouvez également essayer ceci :
```
  ^[0-9A-Za-z ]*[0-9A-Za-z]+[ ]*$
```
- Smart! J'ai sérieusement douté de cela, avant de l'essayer.
InformationsquelleAutor donut
4

Utilisation d'anticipation:
```
^(?=.*\s*)(?=.*[a-zA-Z0-9]+)[a-zA-Z0-9 ]+$
```
- Cette réponse pourrait bénéficier de quelques explications supplémentaires si vous en avez le temps.
- (?=.*\s*) semble redondant.
InformationsquelleAutor Toto

Avant de regarder les autres réponses, je suis arrivé à le faire dans les deux regexes:

boolean ok = (myString.matches("^[A-Za-z0-9 ]+$")  &&  !myString.matches("^ *$"));

Cela correspond à une ou plusieurs lettres/chiffres et zéro ou plusieurs espaces, mais pas seulement des espaces (ou rien).

Il pourrait être rendue efficace par la création préalable d'un seul comparateur d'objet pour chaque regex:

   import  java.util.regex.Matcher;
   import  java.util.regex.Pattern;
public class OnePlusLetterDigitZeroPlusSpace  {
   //"": Unused search string, to reuse the matcher object
   private static final Matcher mtchr1PlusLetterDigitSpc = Pattern.compile("^[a-zA-z0-9 ]+$").matcher("");
   private static final Matcher mtchr0PlusSpc = Pattern.compile("^ *$").matcher("");
   public static final void main(String[] ignored)  {
      test("");
      test(" ");
      test("a");
      test("hello ");
      test(" hello ");
      test("hello there");
   }
   private static final void test(String to_search)  {
      System.out.print("\"" + to_search + "\": ");
      if(mtchr1PlusLetterDigitSpc.reset(to_search).matches()  &&  !mtchr0PlusSpc.reset(to_search).matches())  {
         System.out.println("good");
      }  else  {
         System.out.println("BAD");
      }
   }
}

De sortie:

[C:\java_code\]java OnePlusLetterDigitZeroPlusSpace
"": BAD
" ": BAD
"a": good
"hello ": good
" hello ": good
"hello there": good

Intéressant regex question du jour.

InformationsquelleAutor aliteralmind

0

Vous demandez que la chaîne (s) satisfait à cette condition (remarque: laissez c∈s dire c∈{x|x is a character in s}. Aussi, [] représentent regex classes de caractères):
```
(∀c∈s (c∈[0-9A-Za-z ])) ∧ (∃c∈s ∋ c∈[0-9A-Za-z])
```
Considérer la négation:
```
¬((∀c∈s c∈[0-9A-Za-z ]) ∧ (∃c∈s ∋ c∈[0-9A-Za-z]))
⇔
(∃c∈s ∋ c∉[0-9A-Za-z ]) ∨ (∀c∈s c∉[0-9A-Za-z])
⇔
(∃c∈s ∋ c∈[^0-9A-Za-z ]) ∨ (∀c∈s c∈[^0-9A-Za-z])
```
Alors maintenant, nous voulons construire une regex qui contient soit un non-alphanumériques et de caractère non espace ou est composé uniquement de caractères non alphanumériques.

La première est simple: [^0-9A-Za-z ].

Le second lui est semblable: ^[^0-9A-Za-z]*$

Les combiner pour obtenir: [^0-9A-Za-z ]|^[^0-9A-Za-z]*$

Maintenant nous avons besoin de nier cette regex. Évidemment, nous pouvons juste faire (?![^0-9A-Za-z ]|^[^0-9A-Za-z]*$). Ou nous pourrions manuellement nier la regex:

[^0-9A-Za-z ] devient ^[0-9A-Za-z ]*$

^[^0-9A-Za-z]*$ devient [0-9A-Za-z]. (remarque: nous pourrions facilement nous sont arrivés ici depuis le début)

Mais maintenant nous avons besoin de les combiner avec des ET les, pas OU:

Depuis [0-9A-Za-z] est un sous-ensemble de [0-9A-Za-z ], nous pouvons simplement faire ceci:
```
^[0-9A-Za-z ]*[0-9A-Za-z][0-9A-Za-z ]*$
```
Noter que nous pouvons simplifier à:
```
^[0-9A-Za-z ]*[0-9A-Za-z][ ]*$
```
Cela nécessite juste que le personnage qui correspond à [0-9A-Za-z] est le dernier personnage qui pourrait le faire. Nous pourrions également faire
```
^[ ]*[0-9A-Za-z][0-9A-Za-z ]*$
```
Qui exigerait que le caractère qui correspond à [0-9A-Za-z] est le premier personnage qui pourrait le faire.

Alors maintenant, nous avons terminé. On peut soit utiliser l'un de ces ou (?![^0-9A-Za-z ]|^[^0-9A-Za-z]*$).

_{Remarque: String#match agit comme si la regex est ^ + regex + $ (où + est la concaténation). Cela peut jeter un peu de choses.}

InformationsquelleAutor Justin
0
```
try {
    if (subjectString.matches("(?i)^(?=.*\\s*)(?!.*_)(?=.*[\\w]+)[\\w ]+$")) {
        //String matched entirely
    } else {
        //Match attempt failed
    } 
} catch (PatternSyntaxException ex) {
    //Syntax error in the regular expression
}
```
Ou Tout Simplement:
```
^(.*\p{Blank}?\p{Alnum}+.*\p{Blank}?)$
```
Exemple
- Je n'ai jamais vu un try/catch pour une syntaxe d'expression régulière échec. Si nécessaire..? Le seul cas que je peux penser est une mémoire-fuite/délai causé par catastrophiques backtracing..mais je ne pense pas que ferait par le biais d'un PatternSyntaxException.
- Ne devriez-vous pas être tester le format avant de l'utiliser dans le code de production?
- J'ai l'habitude de faire, mais de cette façon je peux l'attraper plus vite si je n'ai pas.
- Juste assez, continuer sur.
InformationsquelleAutor Pedro Lobito

Vous devez vous connecter pour publier un commentaire.