Construire un résumé des expressions régulières
Construire la correspondance
personnage
x caractères x
// Caractères de barreaux arrière
/ 0n caractère n avec valeur octale 0 (0 <= n <= 7)
/ 0nn caractères nn avec valeur octale 0 (0 <= n <= 7)
/ 0mnn Caractère Mnn avec valeur octale 0 (0 <= m <= 3, 0 <= n <= 7)
/ personnage xhh hh avec valeur hexadécimale 0x
/ personnage uhhhh hhhhh avec valeur hexadécimale 0x
/ T Tab ('/ U0009')
/ n Nouvelle ligne (Break) Caractère ('/ u000a')
/ r Carriage Return Caractor ('/ u000d')
/ F Page Break ('/ U000C')
/ un symbole d'alarme (cloche) ('/ u0007')
/ e Escape Character ('/ u001b')
/ cx correspondant à x
Classe de personnage
[ABC] A, B ou C (classe simple)
[^ ABC] Tout caractère sauf a, b ou c (négatif)
[a-za-z] a à z ou a à z, les lettres aux deux extrémités sont incluses (plage)
[AD [MP]] A à D ou M à P: [A-DM-P] (Union)
[az && [def]] d, e ou f (intersection)
[az && [^ bc]] a à z, sauf b et c: [ad-z] (moins)
[az && [^ mp]] a à z, pas m à p: [a-lq-z] (moins)
Classes de caractères prédéfinis
. Tout personnage (peut ou non correspondre au personnage de fin de ligne)
/ d Numéro: [0-9]
/ D non-nombre: [^ 0-9]
/ s Whitespace Caractère: [/ t / n / x0b / f / r]
/ S Caractères non espaces: [^ / s]
/ w Word Caractères: [a-za-z_0-9]
/ W Caractères sans mot: [^ / w]
Classe de personnages POSIX (US-ACCII uniquement)
/ p {inférieur} Caractères de l'alphabet minuscules: [az]
/ P {Upper} Capital Letter Caractères: [az]
/ p {ascii} Tous ascii: [/ x00- / x7f]
/ p {alpha} caractères alpha: [/ p {inférieur} / p {supérieur}]
/ p {numérique} Numéro décimal: [0-9]
/ p {alnum} caractères alphanumériques: [/ p {alpha} / p {digit}]
/ p {punct} ponctuation :! "# $% & '() * +, -. /:; <=>? @ [/] ^ _` {|} ~
/ p {graphique} Caractères visibles: [/ p {alnum} / p {punct}]
/ p {print} caractères imprimables: [/ p {graphique} / x20]
/ P {blanc} Space ou Tab Caractor: [/ t]
/ p {Cntrl} Caractères de contrôle: [/ x00- / x1f / x7f]
/ p {xdigit} numéro hexadécimal: [0-9a-fa-f]
/ p {espace} Caractère de l'espace Whitespace: [/ t / n / x0b / f / r]
Java.lang.Character Classe (type de caractère Java simple)
/ P {JavalowerCase} est équivalent à java.lang.character.islowercase ()
/ p {javauppercase} équivaut à java.lang.character.isuppercase ()
/ p {javawhitespace} équivaut à java.lang.character.iswhitespace ()
/ p {javamirrored} équivaut à java.lang.character.ismirrored ()
Blocs et classes Unicode
/ p {ingreek} caractères dans un bloc grec (bloc simple)
/ p {lu} majuscules (catégorie simple)
/ P {SC} Symbole de devise
/ P {ingreek} Tous les caractères, sauf dans le bloc grec (négatif)
[/ p {l} && [^ / p {lu}]] Toutes les lettres, sauf des lettres majuscules (moins)
Correspondant aux limites
^ Le début de la ligne
La fin de la ligne $
/ b Bouilles de mot
/ B frontière non mot
/ Un début d'entrée
/ G la fin du match précédent
La fin de l'entrée / z, uniquement pour le dernier caractère final (le cas échéant)
La fin de l'entrée / z
Mot quantitatif gourmand
X? X, une fois ou une fois, non
X * x, zéro ou plusieurs fois
X + x, une fois ou plus
X {n} x, exactement n fois
X {n,} x, au moins n fois
X {n, m} x, au moins n fois, mais pas plus que m fois
Mot quantitatif réticent
X ?? X, une fois ou une fois, non
X *? X, zéro ou plusieurs fois
X +? X, une fois ou plus
X {n}? X, exactement n fois
X {n,}? X, au moins n fois
X {n, m}? X, au moins n fois, mais pas plus m fois
Mots quantitatifs possessifs
X? + X, une fois ou une fois, non
X * + x, zéro ou plusieurs fois
X ++ x, une fois ou plus
X {n} + x, exactement n fois
X {n,} + x, au moins n fois
X {n, m} + x, au moins n fois, mais pas plus que m fois
Opérateur logique
Xy x talon y
X | yx ou y
(X) x, comme groupe de capture
Citation arrière
/ n tout groupe de capture nième correspondant
Citation
/ Rien, mais citez les caractères suivants
/ Q rien, mais cite tous les caractères jusqu'à / e
/ E rien, mais met fin à la référence en commençant par / q
Construction spéciale (non capturée)
(?: x) x, en tant que groupe non captureux
(? idmsux-idmsux) Rien, mais correspondra à l'indicateur idmsux sur - off
(? idmsux-idmsux: x) x, comme idmsux sur - off avec l'indicateur donné
Groupe non capturant (? = x) x, à travers un look positif à largeur zéro
(?! X) x, à travers la largeur zéro lookahead négatif
(? <= X) x, à travers un look positif à largeur zéro
(? <! X) x, look négatif à travers la largeur zéro
(?> X) x, en tant que groupe indépendant sans capture
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Barreaux de barreaux, évasions et références
Le caractère de barre arrière ('/') est utilisé pour référencer les constructions d'échappement, telles que définies dans le tableau ci-dessus, ainsi que pour référencer d'autres caractères qui seront interprétés comme des constructions non escapées. Par conséquent, l'expression // correspond à une seule barre arrière, et / {correspond au support gauche.
Il est faux d'utiliser des barres à barres avant les caractères alphabétiques qui ne représentent pas les constructions d'échappement; Ils sont réservés à de futures extensions de langues d'expression régulières. Une barre oblique inverse peut être utilisée avant un caractère non alphabétique, que le caractère ne fasse pas partie de la construction échappée.
Selon les exigences de la spécification du langage Java, les barreaux de barreaux dans les chaînes du code source Java sont interprétées comme des évasions Unicode ou d'autres évasions de caractère. Par conséquent, deux bombardements doivent être utilisés dans la chaîne littérale pour indiquer que l'expression régulière est protégée et non interprétée par le compilateur Java Bytecode. Par exemple, lorsqu'il est interprété comme une expression régulière, la chaîne "/ b" correspond à un seul caractère arrière, et "// b" correspond à la limite du mot. La chaîne littérale "/ (Hello /)" est illégale et provoquera une erreur de temps de compilation; Pour correspondre à la chaîne (bonjour), la chaîne littérale "// (bonjour //)" doit être utilisée.
Classe de personnage
Les classes de caractères peuvent apparaître dans d'autres classes de caractères et peuvent contenir des opérateurs syndicaux (implicitement) et des opérateurs d'intersection (&&). L'opérateur syndical représente une classe qui contient au moins tous les personnages de l'une de ses classes d'opérande. L'opérateur d'intersection représente une classe qui contient tous les caractères de ses deux classes d'opérande en même temps.
La priorité des opérateurs de classe de personnage est la suivante, organisée dans l'ordre du plus haut au plus bas:
1 évasion littérale / x
2 groupement [...]
3 gamme AZ
4 Union [ae] [iu]
5 intersection [az && [aeiou]]
Notez que différents ensembles de métacharacteurs sont en fait situés à l'intérieur de la classe de caractères, et non en dehors de la classe de caractères. Par exemple, des expressions régulières. La signification particulière est perdue à l'intérieur d'une classe de caractères, et l'expression - devient la plage qui forme des métacharacteurs.
Personnage de fin de ligne
Un caractère de fin de ligne est une séquence d'un ou deux caractères qui marque la fin de la ligne de la séquence de caractères d'entrée. Le code suivant est reconnu comme un caractère de fin de ligne:
Caractère de la nouvelle ligne (ligne newline) ('/ n'),
Le caractère de retour du chariot ("/ r / n") suivi du nouveau caractère de ligne,
Un caractère de retour de chariot séparé ('/ r'),
Caractère de ligne suivante ('/ u0085'),
Line délimiter ('/ u2028') ou
Séparateur de paragraphe ('/ u2029).
Si le mode Unix_lines est activé, le nouveau caractère de ligne est le caractère d'extrémité de ligne uniquement reconnu.
Si l'indicateur Dotall n'est pas spécifié, l'expression régulière. peut correspondre à n'importe quel caractère (sauf la fin de la ligne).
Par défaut, les expressions régulières ^ et $ ignorent les terminaisons de ligne et ne correspondent qu'au début et à la fin de toute la séquence d'entrée, respectivement. Si le mode multiligne est activé, une correspondance ne se produit qu'après le début de l'entrée et la fin de la ligne (la fin de l'entrée). En mode multiligne, $ ne correspond qu'avant la fin de la ligne ou à la fin de la séquence d'entrée.
Groupe et capture
Les groupes de capture peuvent être numérotés en calculant leurs supports ouverts de gauche à droite. Par exemple, dans l'expression ((a) (b (c)))), il y a quatre de ces groupes:
1 ((a) (b (c)))
2 / A
3 (b (c))
4 (c)
Le groupe Zeros représente toujours toute l'expression.
Les groupes de capture sont nommés de cette manière car dans le match, chaque sous-séquence de la séquence d'entrée correspondant à ces groupes est enregistrée. La sous-séquence capturée peut plus tard être utilisée dans l'expression via des références arrière ou peut être obtenue à partir du correspondant une fois l'opération de correspondance terminée.
L'entrée de capture associée au groupe est toujours la sous-séquence qui correspond le plus récemment au groupe. Si le groupe est à nouveau calculé en raison de la quantification, sa valeur précédemment capturée sera conservée lors de la deuxième panne de calcul (le cas échéant). Par exemple, la correspondance de la chaîne "ABA" à l'expression (a (b)?) + Va définir le deuxième groupe sur "b". Au début de chaque match, toutes les entrées capturées sont jetées.
Les groupes commençant par (?) Sont des groupes purs non-capture qui ne capturent pas le texte et ne comptent pas contre les comptages combinés.
Ce qui précède est tout le contenu de l'expression régulière (recommandée par l'article de grammaire) que vous avez apporté par l'éditeur. J'espère que tout le monde pourra soutenir Wulin.com plus ~