Englisch Русский Deutsch Български Français Spanisch

TRegExpr

Implementiert reguläre Ausdrücke in reinem Pascal, kompatibel zu Free Pascal, Delphi 2 bis 7 und Borland C++ Builder 3 bis 6.

Um es zu nutzen, kopiere einfach den Quellcode der unit RegExpr in Dein Projekt.

In der IDE Lazarus (Free Pascal) ist diese Bibliothek bereits enthalten . Falls Sie also Lazarus verwenden, müssen Sie gar nichts kopieren.

Klasse TRegExpr

Haupt- und Nebenversion

Gibt die Haupt- und Nebenversionsnummer zurück, zum Beispiel für Version 0.944

Hauptversion = 0
Nebenversion = 944

Ausdruck

Ein regulärer Ausdruck.

Aus Optimierungsgründen wird der reguläre Ausdruck automatisch in P-Code kompiliert. Eine menschenlesbare Form des P-Codes wird gibt die Methode Dump aus.

Bei einem Kompilierfehler wird die Error-Methode aufgerufen (standardmäßig löst Error die Ausnahme ERegExpr aus)

ModifierStr

Werte für reguläre Ausdrücke setzen oder auslesen.

Die Syntax ist ähnlich wie in (?ismx-ismx). Zum Beispiel schaltet ``ModifierStr := ‘i-x’` den Modifikator / i ein, `/x <regular_expressions.html#x> `__ aus und lässt die übrigen (nicht aufgeführten) unverändert.

Wenn Sie versuchen, einen nicht unterstützten Modifikator einzustellen, wird Error aufgerufen.

ModifierI

Modifier /i, „Groß- und Kleinschreibung wird nicht berücksichtigt“ <regular_expressions.html#i>, Initialwert ist RegExprModifierI value.

ModifierR

Modifier /r, “ russische Zeichenbereiche“, initialisiert mit dem Wert von RegExprModifierR.

ModifierS

Modifier /s, „einzeilige Zeichenketten „, initialisiert mit dem Wert von RegExprModifierS .

ModifierG

Modifier /g, „Gier (greediness)“, initialisiert mit dem Wert von RegExprModifierG .

ModifierM

Modifier /m, „mehrzeilige Zeichenkette“, initialisiert mit dem Wert von RegExprModifierM .

ModifierX

Modifier /x, „erweiterte Syntax“, initialisiert mit dem Wert von RegExprModifierX .

Exec

Wendet den regulären Ausdruck auf die Eingabezeichenfolge AInputString an.

Eine überladene Exec-Version ohne AInputString ist ebenfalls vorhanden, diese verwendet implizit den zuletzt benutzten AInputString.

Siehe auch die globale Funktion ExecRegExpr, die sich ohne explizite Erstellung eines TRegExpr-Objekts nutzen lässt.

ExecNext

Die nächste Übereinstimmung suchen.

Benötigt keinen Parameter, und funktioniert in der Art von

if MatchLen [0] = 0
  then ExecPos (MatchPos [0] + 1)
  else ExecPos (MatchPos [0] + MatchLen [0]);

Löst eine Ausnahme aus, falls sie ohne vorherigen erfolgreichen Aufruf von Exec, ExecPos oder ExecNext verwendet wird.

Man muss also stets nach folgendem Schema vorgehen:

if Exec (InputString)
  then
    repeat
      { proceed results}
    until not ExecNext;

ExecPos

Durchsucht InputString ab der Position AOffset

AOffset = 1 // erstes Zeichen von InputString

InputString

Gibt die aktuelle Eingabezeichenfolge zurück (aus dem letzten Exec-Aufruf oder der letzten Zuweisung an diese Eigenschaft stammend).

Jede Zuweisung zu dieser Eigenschaft setzt Match, MatchPos und MatchLen zurück.

Substitute

function Substitute (const ATemplate: RegExprString): RegExprString;

Returns ATemplate with $& or $0 replaced by whole regular expression and $n replaced by occurence of subexpression number n.

Um ein Dollarzeichen $ oder einen Rückwärtsschrägstrich \ in ATemplate einzufügen, sind sie mit \``zu maskieren (also ``\\ oder \$).

Symbol Beschreibung
$& ganze Übereinstimmung des regulären Ausdrucks
$0 ganze Übereinstimmung des regulären Ausdrucks
$n regulärer Unterausdruck n
\n in Windows durch \r\n ersetzt
\l Kleinbuchstabe ein nächstes Zeichen
\L Kleinbuchstaben alle Zeichen danach
\u ein weiteres Zeichen
\U Großbuchstaben alle Zeichen danach
'1\$ is $2\\rub\\' -> '1$ is <Match[2]>\rub\'
'\U$1\\r' wird zu '<Match[1] in uppercase>\r'

Wenn Sie eine Ziffer unmittelbar hinter $n schreiben möchten, müssen Sie n mit geschweiften Klammern {} abgrenzen.

'a$12bc' -> 'a<Match[12]>bc'
'a${1}2bc' -> 'a<Match[1]>2bc'.

Split

Splittet den Eingabestring AInputStr an den Regex-Fundstellen in die Stringliste APieces

Ruft intern Exec / ExecNext auf

Siehe alternativ die globale Funktion SplitRegExpr, die sich verwenden läßt, ohne explizit ein``TRegExpr``-Objekt zu erstellen.

Replace, ReplaceEx

function Replace (Const AInputStr : RegExprString;
  const AReplaceStr : RegExprString;
  AUseSubstitution : boolean= False)
 : RegExprString; overload;

function Replace (Const AInputStr : RegExprString;
  AReplaceFunc : TRegExprReplaceFunction)
 : RegExprString; overload;

function ReplaceEx (Const AInputStr : RegExprString;
  AReplaceFunc : TRegExprReplaceFunction):
  RegExprString;

Gibt die Zeichenfolge mit erneuten Vorkommen durch die Ersetzungszeichenfolge zurück.

Wenn das letzte Argument (&quot;AUseSubstitution&quot;) wahr ist, wird &quot;AReplaceStr&quot; als Vorlage für Substitutionsmethoden verwendet.

Ausdruck: = &#39;((? I) block | var) \ s * (\ s * \ ([^] * \) \ s *) \ s *&#39;; Ersetzen Sie (&#39;BLOCK (test1)&#39;, &#39;def &quot;$ 1&quot; -Wert &quot;$ 2&quot;&#39;, True);

Liefert ``def „BLOCK“ Wert &quot;test1&quot; ``

Ersetzen (&#39;BLOCK (test1)&#39;, &#39;def &quot;$ 1&quot; Wert &quot;$ 2&quot;&#39;, False)

Liefert `` def &quot;$ 1&quot; Wert &quot;$ 2&quot; ``

Ruft intern Exec / ExecNext auf

Die überladene Version und ReplaceEx arbeiten mit der Rückruffunktion, sodass Sie sehr komplexe Funktionen implementieren können.

Siehe auch die globale Funktion ReplaceRegExpr, die Sie ohne explizite TRegExpr-Objekterstellung verwenden können.

SubExprMatchCount

Die Anzahl der Unterausdrücke wurde im letzten Exec / ExecNext-Aufruf gefunden.

Wenn es keine Subexpressions gibt, jedoch ein vollständiger Ausdruck gefunden wurde (Exec * hat True zurückgegeben), dann SubExprMatchCount = 0, falls weder Unterausdrücke noch vollständige gefunden wurden (Exec / ExecNext lieferte False), dann SubExprMatchCount = -1.

Beachten Sie, dass einige Unterausdrücke. kann nicht gefunden werden und für einen solchen Unterausdruck. `` MathPos = MatchLen = -1`` und `` Match = '' ``.

Ausdruck: = &#39;(1) 2 (3)&#39; &#39;; Exec (&#39;123&#39;): SubExprMatchCount = 2, Match [0] = &#39;123&#39;, [1] = &#39;1&#39;, [2] = &#39;3&#39; Exec (&#39;12&#39;): SubExprMatchCount = 1, Match [0] = &#39;12 &#39;, [1] =&#39; 1 &#39;Exec (&#39; 23 &#39;): SubExprMatchCount = 2, Match [0] =&#39; 23 &#39;, [1] =&#39; &#39;, [2] =&#39; 3 &#39;Exec (&#39; 2 &#39;): SubExprMatchCount = 0, Match [0] =&#39; 2 &#39;Exec (&#39; 7 &#39;) - Rückgabe False: SubExprMatchCount = -1

MatchPos

pos von Eingang subexpr. #Idx wurde in der letzten `` Exec * `` Zeichenfolge getestet. Erster Unterausdruck habe Idx=1, zuletzt - `` MatchCount``, ganze hat Idx=0.

Gibt -1 zurück, wenn kein solcher Subexpr vorliegt. oder dieser subexpr. nicht in Eingabezeichenfolge gefunden.

MatchLen

len von entry subexpr. #Idx wird in der letzten `` Exec * `` Zeichenfolge getestet. Erster Unterausdruck habe Idx=1, letzte - MatchCount, ganze hat Idx=0.

Gibt -1 zurück, wenn kein solcher Unterausdruck vorhanden ist. oder dieser subexpr. nicht in Eingabezeichenfolge gefunden.

Spiel

Gibt `` '' `` zurück, wenn in der Eingabezeichenfolge kein solcher Unterausdruck oder dieser Unterausdruck gefunden wurde.

LastError

Gibt ID des letzten Fehlers zurück, 0, wenn keine Fehler vorliegen (unbrauchbar, wenn die 'Fehler'-Methode eine Ausnahmebedingung auslöst) und den internen Status in 0 löschen (keine Fehler).

ErrorMsg

Gibt die Error-Nachricht für einen Fehler mit `` ID = AErrorID`` zurück.

CompilerErrorPos

Gibt pos in re zurück, wo der Compiler gestoppt wurde.

Nützlich für die Fehlerdiagnose

SpaceChars

Enthält Zeichen, die als \s behandelt werden (anfänglich mit der globalen Konstante RegExprSpaceChars gefüllt)

WordChars

Enthält Zeichen, die als \w behandelt werden (anfänglich mit der globalen Konstante RegExprWordChars gefüllt)

LineSeparators

Zeilentrennzeichen (wie \n in Unix), anfänglich gefüllt mit RegExprLineSeparators (globale Konstante)

Siehe auch `Zeilengrenzen <regular_expressions.html#lineseparators> __

LinePairedSeparator

gepaartes Trennzeichen (wie \r\n in DOS und Windows).

muss genau zwei oder gar keine Zeichen enthalten und ist anfangs mit dem Inhalt der globalen Konstante RegExprLinePairedSeparator vorbefüllt

Siehe auch `Zeilengrenzen <regular_expressions.html#lineseparators> __

Wenn Sie beispielsweise ein Verhalten im Unix-Stil benötigen, weisen Sie `` LineSeparators: = # $ a`` und `` LinePairedSeparator: = '' `` (leere Zeichenfolge) zu.

Wenn Sie als Linientrennzeichen nur x0D x0A` aber nicht` x0D` oder` x0A` allein akzeptieren möchten, weisen Sie` LineSeparators: = '' (leere Zeichenfolge) und ` LinePairedSeparator: = # $ d # $ a``.

Standardmäßig wird der gemischte Modus verwendet (definiert in RegExprLine [Paired] Separator [s] globale Konstanten):

LineSeparators: = # $ d # $ a; LinePairedSeparator: = # $ d # $ a

Das Verhalten dieses Modus wird ausführlich in den Zeilengrenzen beschrieben <regular_expressions.html#lineseparators> __.

InvertCase

Invertierung des Zeichenkastens. Definieren Sie es neu, wenn Sie ein anderes Verhalten wünschen.

Kompilieren

Kompiliert regulären Ausdruck.

Nützlich zum Beispiel für GUI-Editoren für reguläre Ausdrücke, um reguläre Ausdrücke zu überprüfen, ohne ihn zu verwenden.

Dump

Zeigen Sie P-Code (kompilierter regulärer Ausdruck) als vom Menschen lesbare Zeichenfolge.

Globale Konstanten

EscChar

Escape-char, standardmäßig \.

RegExprModifierI

Modifier i <regular_expressions.html#i> _ Standardwert

RegExprModifierR

Modifier r <regular_expressions.html#r> _ Standardwert

RegExprModifierS

`Modifier s <regular_expressions.html#s> _ Standardwert

RegExprModifierG

`Modifikator g <regular_expressions.html#g> _ Standardwert

RegExprModifierM

Modifier m <regular_expressions.html#m> _ Standardwert

RegExprModifierX

`Modifikator x <regular_expressions.html#x> _ Standardwert

RegExprSpaceChars

Standardwert für die SpaceChars-Eigenschaft

RegExprWordChars

Standardwert für die Eigenschaft WordChars

RegExprLineSeparators

Standardwert für die LineSeparators-Eigenschaft

RegExprLinePairedSeparator

Standardwert für die LinePairedSeparator-Eigenschaft

RegExprInvertCaseFunction

Standard für die Eigenschaft InvertCase

Globale Funktionen

Alle diese Funktionen stehen als Methoden von TRegExpr zur Verfügung, aber mit globalen Funktionen müssen Sie keine TReExpr-Instanz erstellen, sodass Ihr Code einfacher wäre, wenn Sie nur eine Funktion benötigen.

ExecRegExpr

true, wenn die Zeichenfolge mit dem regulären Ausdruck übereinstimmt. So wie Exec in TRegExpr.

SplitRegExpr

Teilt den String mit regulären Ausdrücken. Siehe auch Split, wenn Sie die TRegExpr-Instanz explizit erstellen möchten.

ReplaceRegExpr

Funktion ReplaceRegExpr (const ARegExpr, AInputStr, AReplaceStr: RegExprString; AUseSubstitution: boolean = False): RegExprString; Überlast; Typ TRegexReplaceOption = (rroModifierI, rroModifierR, rroModifierS, rroModifierG, rroModifierM, rroModifierX, rroUseSubstitution, rroUseOsLineEnd); TRegexReplaceOptions = Set von TRegexReplaceOption; Funktion ReplaceRegExpr (const ARegExpr, AInputStr, AReplaceStr: RegExprString; Optionen: TRegexReplaceOptions): RegExprString; Überlast;

Gibt den String mit regulären Ausdrücken zurück, die durch AReplaceStr ersetzt werden. Siehe auch Replace, wenn Sie es vorziehen, die TRegExpr-Instanz explizit zu erstellen.

Wenn das letzte Argument (AUseSubstitution) wahr ist, wird `` AReplaceStr`` als Vorlage für `` Substitutionsmethoden`` verwendet:

ReplaceRegExpr (&#39;((?)) Block | var) \ s * (\ s * \ ([^] * \) \ s *) \ s *&#39;, &#39;BLOCK (test1)&#39;, &#39;def &quot;$ 1&quot; value &quot; $ 2 &quot;, wahr)

Gibt den `` def 'BLOCK'-Wert' test1 '`zurück

Aber dieses hier (Anmerkung: Es gibt kein letztes Argument):

ReplaceRegExpr (&#39;((?)) Block | var) \ s * (\ s * \ ([^] * \) \ s *) \ s *&#39;, &#39;BLOCK (test1)&#39;, &#39;def &quot;$ 1&quot; value &quot; $ 2 &quot;&#39;)

Liefert `` def &quot;$ 1&quot; Wert &quot;$ 2&quot; ``

Version mit Optionen

Mit Options steuert man das Verhalten von \n (mit der Option rroUseOsLineEnd wird jedes \n unter Windows durch \n\r ersetzt, unter Linux bleibt es ein \n). Und so weiter.

Typ TRegexReplaceOption = (rroModifierI, rroModifierR, rroModifierS, rroModifierG, rroModifierM, rroModifierX, rroUseSubstitution, rroUseOsLineEnd);

QuoteRegExprMetaChars

Ersetzen Sie alle Metachars durch ihre sichere Darstellung, zum Beispiel `` abc'cd. (`` Konvertiert in abc\'cd\.\(.)

Diese Funktion ist nützlich für die erneute Generierung von Benutzereingaben

RegExprSubExpressions

Erstellt eine Liste der Unterausdrücke, die in ARegExpr gefunden werden

In ASubExps repräsentiert jedes Element einen ersten Ausdruck vom ersten bis zum letzten Format im Format:

String - Unterausdruck (ohne '()')

Low word of Object - Startposition in ARegExpr, einschließlich '(' falls vorhanden! (erste Position ist 1)

hohes Wort der Objektlänge, einschließlich &quot;(&quot; und &quot;Endung&quot;) &quot;falls vorhanden!

AExtendedSyntax - muss True sein, wenn der Schalter /x mit dem regulären Ausdruck verwendet werden soll.

Nützlich für GUI-Editoren von re etc (ein Beispiel für die Verwendung finden Sie in `REStudioMain.pas) <https://github.com/andgineer/TRegExpr/blob/74ab342b639fc51941a4eea9c7aa53dcdf783592/restudio/REStudioMain.pas#L474> _)

Ergebniscode Bedeutung
0 Erfolg. Es wurden keine unausgeglichenen Klammern gefunden
-1 Es gibt nicht genug schließende Klammern )
-(n+1) An Position n wurde das Öffnen von [ ohne entsprechende Schließung ``] `` gefunden
n In Position n wurde das Schließen der Klammer ) ohne entsprechende Öffnung () gefunden

Wenn Result <> 0 `ASubExprs kann leere oder illegale Elemente enthalten

ERegExpr

ERegExpr = Klasse (Ausnahme) public ErrorCode: integer; // Fehlercode. Kompilierungsfehlercodes liegen vor 1000 CompilerErrorPos: integer; // Position in re, an der der Kompilierungsfehler aufgetreten ist end;

Unicode

UniCode verlangsamt die Leistung. Verwenden Sie ihn daher nur, wenn Sie wirklich Unicode-Unterstützung benötigen.

Um Unicode zu verwenden, kommentieren Sie {$DEFINE UniCode} in regexpr.pas <https://github.com/andgineer/TRegExpr/blob/29ec3367f8309ba2ecde7d68d5f14a514de94511/src/RegExpr.pas#L86>`__ (entferne off).

Danach werden alle Zeichenfolgen als WideString behandelt.