Zusammenfassung der regulären Ausdrücke erstellen
Übereinstimmung konstruieren
Charakter
x Zeichen x
// Backslash -Zeichen
/0n Zeichen n mit Oktalwert 0 (0 <= n <= 7)
/0nn Zeichen nn mit Oktalwert 0 (0 <= n <= 7)
/0Mnn Zeichen MNN mit Oktalwert 0 (0 <= m <= 3, 0 <= n <= 7)
/xhh Charakter HH mit Hexadezimalwert 0x
/uhhhh Charakter Hhhhh mit Hexadezimalwert 0x
/t Registerkarte ('/U0009')
/n Neue Zeile (Zeilenumbruch) Zeichen ('/u000a')
/R -Wagenrückgabezeichen ('/u000d')
/f Seite Break ('/u000c')
/ein Alarm (Bell) Symbol ('/u0007')
/e Escape -Zeichen ('/u001b')
/cx entspricht x
Charakterklasse
[ABC] A, B oder C (einfache Klasse)
[^abc] Jeglicher Charakter außer A, B oder C (negativ)
[a-za-z] a bis z oder a bis z, Buchstaben an beiden Enden sind enthalten (Bereich)
[AD [MP]] A bis D oder M bis P: [A-DM-P] (Union)
[Az && [def]] D, e oder f (Kreuzung)
[Az && [^Bc]] a bis z, außer b und c: [ad-z] (minus)
[az && [^mp]] a bis z, nicht m bis p: [a-lq-z] (minus)
Vordefinierte Charakterklassen
. Jedes Zeichen (kann mit dem Zeilenende -Charakter übereinstimmen oder nicht)
/d Nummer: [0-9]
/D Nichtnummer: [^0-9]
/s Whitespace -Zeichen: [/t/n/x0b/f/r]
/S Nicht-Whitespace-Zeichen: [^/s]
/W Wort Zeichen: [a-za-z_0-9]
/W Nicht-Wort-Zeichen: [^/w]
POSIX-Charakterklasse (nur US-Ascii)
/P {Lower} Kleinbuchstaben Alphabet Zeichen: [AZ]
/p {ober} Kapitalbuchstaben Zeichen: [AZ]
/p {ascii} alle ASCII: [/x00-/x7f]
/p {alpha} alpha Zeichen: [/p {Lower}/p {ober}]
/p {digit} Dezimalzahl: [0-9]
/p {alnum} alphanumerische Zeichen: [/p {alpha}/p {digit}]
/p {punct} Interpunktion:! "#$%& '()*+,-./:; <=>?@[/]^_ {{|} ~
/p {graph} sichtbare Zeichen: [/p {alnum}/p {punct}]
/p {print} druckbare Zeichen: [/p {graph}/x20]
/p {leer} Speicherplatz oder Registerkarte Zeichen: [ /t]
/p {cntrl} Steuerzeichen: [/x00-/x1f/x7f]
/p {xdigit} Hexadezimalnummer: [0-9a-fa-f]
/P {Space} Whitespace -Zeichen: [/t/n/x0b/f/r]
java.lang.character class (einfacher java charaktertyp)
/P {JavalowerCase} entspricht Java.lang.Character.IlsowerCase ()
/p {javauppercase} entspricht java.lang.character.isuppercase ()
/p {javawhitespace} entspricht java.lang.character.iswhITespace ()
/p {javamirrored} entspricht java.lang.character.ismirrored ()
Unicode -Blöcke und Klassen
/p {ingreek} Zeichen in einem griechischen Block (einfacher Block)
/p {lu} Großbuchstaben (einfache Kategorie)
/p {sc} Währungssymbol
/P {ingreek} Alle Zeichen, außer im griechischen Block (negativ)
[/p {l} && [^/p {lu}] alle Buchstaben, außer Großbuchstaben (minus)
Grenzübereinstimmung
^ Der Beginn der Linie
Das Ende der $ line
/b Wortgrenzen
/B Nicht-Wort-Grenze
/Ein Eingangsstart
/G am Ende des vorherigen Spiels
Das Ende der /z -Eingabe, nur für das letzte Endcharakter (falls vorhanden)
Das Ende der Eingabe /z
Gieriges quantitatives Wort
X? X, einmal oder einmal, nein
X* x, null oder mehrmals
X+ x, einmal oder mehr
X {n} x, genau n -mal
X {n,} x, mindestens n -mal
X {n, m} x, mindestens n -mal, aber nicht mehr als m -mal
Widerstrebendes quantitatives Wort
X?? X, einmal oder einmal, nein
X*? X, null oder mehrmals
X+? X, einmal oder mehr
X {n}? X, genau n -mal
X {n,}? X, mindestens n -mal
X {n, m}? X, mindestens n -mal, aber nicht mehr als m -mal
Besitzergreifende quantitative Wörter
X?+ X, einmal oder einmal, nein
X*+ x, null oder mehrmals
X ++ x, einmal oder mehr
X {n}+ x, genau n -mal
X {n,}+ x, mindestens n -mal
X {n, m}+ x, mindestens n -mal, aber nicht mehr als m -mal
Logischer Operator
Xy x Ferse y
X | yx oder y
(X) x, als Erfassungsgruppe
Zurück -Zitat
/n jede passende n -te Capture -Gruppe
Zitat
/Nichts, aber zitieren Sie die folgenden Zeichen
/Q nichts, aber zitiert alle Zeichen bis /e
/E nichts, aber beendet die Referenz beginnend mit /q
Spezialkonstruktion (nicht erfasst)
(?: X) x, als Nicht-Kerngruppe
(? IDMSUX -IDMSUX) Nicht
(?
Nicht-Kauf-Gruppe (? = x) x, durch positive Aussehen von Null-Breiten
(?! X) x, durch negative Nullbreite negative Aussehen
(? <= X) x, durch ein positives Null-Breiten-Lookbehind
(? <! X) x, negativ aussehen durch Null Breite
(?> X) x, als unabhängige Nichtkapiturgruppe
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Backslashes, Flucht und Referenzen
Das Backslash-Zeichen ('/') wird verwendet, um Escape-Konstrukte wie in der obigen Tabelle definiert und auch auf andere Zeichen zu verweisen, die als nicht geschmückte Konstrukte interpretiert werden. Daher entspricht der Ausdruck // mit einem einzelnen Backslash und /{{{{{{{{{{{{{{{{{{{{{{{{{{{{ass).
Es ist falsch, Backslashes vor alphabetischen Zeichen zu verwenden, die keine Fluchtkonstrukte darstellen. Sie sind für zukünftige Erweiterungen regulärer Ausdruckssprachen reserviert. Vor einem nicht-alphabetischen Charakter kann ein Backslash verwendet werden, unabhängig davon, ob der Charakter nicht Teil des entkommenen Konstrukts ist.
Nach den Anforderungen der Java -Sprachspezifikation werden die Backslashes in Strings des Java -Quellcodes interpretiert, als Unicode entkommt oder anderer Zeichen entkommt. Daher müssen im String -Literal zwei Backslashes verwendet werden, um anzuzeigen, dass der reguläre Ausdruck vom Java -Bytecode -Compiler nicht interpretiert wird. Wenn beispielsweise die String -Literal "/B" als regulärer Ausdruck interpretiert wird, entspricht sie mit einem einzelnen Backpace -Zeichen und "// B" mit der Wortgrenze überein. Der String-Literal "/(Hallo/)" ist illegal und verursacht einen Kompilierungsfehler. Um der Zeichenfolge (Hallo) zu entsprechen, muss die String Literal "// (Hallo //)" verwendet werden.
Charakterklasse
Charakterklassen können in anderen Zeichenklassen erscheinen und Gewerkschaftsbetreiber (implizit) und Intersektionsoperatoren (&&) enthalten. Der Gewerkschaftsbetreiber repräsentiert eine Klasse, die mindestens alle Zeichen in einer seiner Operandenklassen enthält. Der Kreuzungsoperator repräsentiert eine Klasse, die alle Zeichen in seinen beiden Operandenklassen gleichzeitig enthält.
Die Priorität der Operatoren der Charakterklassen ist wie folgt, angeordnet von höchster bis niedrigster:
1 buchstäbliche Flucht/x
2 Gruppierung [...]
3 Bereich AZ
4 Union [ae] [IU]
5 Kreuzung [AZ && [aeiou]]
Beachten Sie, dass sich verschiedene Metacharacter -Sätze tatsächlich innerhalb der Zeichenklasse befinden, nicht außerhalb der Charakterklasse. Zum Beispiel reguläre Ausdrücke. Die besondere Bedeutung geht in einer Zeichenklasse verloren, und der Ausdruck wird zum Bereich, der Metacharacter bildet.
Zeilenende Charakter
Ein Zeilenende -Zeichen ist eine Sequenz von ein oder zwei Zeichen, die das Ende der Linie der Eingangszeichensequenz markiert. Der folgende Code wird als Zeilen -End -Zeichen erkannt:
Neue Linie (Zeile Newline) Zeichen ('/n'),
Der Kutschenrücklaufcharakter ("/r/n"), gefolgt vom neuen Liniencharakter,
Ein separater Wagenrückgabecharakter ('/r'),
Nächste Zeilenzeichen ('/u0085'),
Zeilenbegrenzung ('/u2028') oder
Absatzabscheider ('/U2029).
Wenn der UNIX_LINES -Modus aktiviert ist, ist das neue Zeilenzeichen das einzigartig erkannte Zeilenendzeichen.
Wenn das Dotall -Flag nicht angegeben ist, ist der reguläre Ausdruck. kann jedem Zeichen übereinstimmen (außer dem Ende der Linie).
Standardmäßig ignorieren reguläre Ausdrücke ^ und $ Zeilenende und stimmen nur mit dem Beginn und Ende der gesamten Eingangssequenz überein. Wenn der Multilinmodus aktiviert ist, tritt ein Match erst nach Beginn des Eingangs und am Ende der Linie (das Ende der Eingabe) auf. Im Multiline -Modus übereinstimmt $ nur vor dem Ende der Leitung oder am Ende der Eingangssequenz.
Gruppe und Erfassung
Erfassungsgruppen können nummeriert werden, indem ihre offenen Klammern von links nach rechts berechnet werden. Zum Beispiel gibt es im Ausdruck ((a) (b (c))) vier solcher Gruppen:
1 ((a) (b (c)))
2 /a
3 (b (c))
4 (c)
Gruppennullen repräsentieren immer den gesamten Ausdruck.
Die Erfassungsgruppen werden auf diese Weise benannt, da in der Übereinstimmung jede Unterbringung der Eingabesequenz, die diesen Gruppen entspricht, gespeichert wird. Die erfasste Subsequenz kann später im Ausdruck über Rückreferenzen verwendet werden oder nach Abschluss des Matching -Vorgangs aus dem Matcher erhalten werden.
Der mit der Gruppe verbundene Erfassungseingang ist immer die Subsequenz, die zuletzt mit der Gruppe übereinstimmt. Wenn die Gruppe aufgrund der Quantisierung erneut berechnet wird, wird ihr zuvor erfasster Wert beim zweiten Berechnungsfehler (falls vorhanden) beibehalten. Wenn Sie beispielsweise die Zeichenfolge "ABA" mit dem Ausdruck (a (b)?)+ Übereinstimmen, wird die zweite Gruppe auf "B" festgelegt. Zu Beginn jedes Spiels werden alle erfassten Eingänge verworfen.
Gruppen beginnend mit (?) Sind reine Nicht-Kauf-Gruppen, die keinen Text erfassen und nicht mit Combo-Zählungen zählen.
Das obige ist der gesamte Inhalt des regulären Ausdrucks (empfohlen vom Grammatikartikel) vom Herausgeber. Ich hoffe, jeder kann Wulin.com mehr unterstützen ~