Funktionreferenz


StringRegExp



Beschreibung anzeigen in

Prüft, ob ein String dem Suchmuster eines regulären Ausdrucks entspricht.

StringRegExp ( "test", "pattern" [, flag = 0 [, offset = 1]] )

Parameter

test Die zu prüfende Eingabe
pattern Das Suchmuster des regulären Ausdrucks.
flag [optional] Eine Zahl, die die Verhaltensweise der Funktion bestimmt. Siehe weiter unten für Details. Der Standard ist 0.
offset [optional] Die Position des Strings, wo die Funktion beginnen soll (startet bei 1). Der Standard ist 1.


Flag Werte
$STR_REGEXPMATCH (0) Ein Pattern führt zu einem Match oder nicht. (1 oder 0) (Standard).
$STR_REGEXPARRAYMATCH (1) Es wird nur der erste SubMatch zu jedem Match ausgegeben (Array).
$STR_REGEXPARRAYFULLMATCH (2) Im Ergebnisarray wird an [0] der gesamte erste Match ausgegeben, an [1..n] folgen die SubMatches des ersten Matches.
$STR_REGEXPARRAYGLOBALMATCH (3) Im Ergebnisarray werden von allen Matches alle Submatches ausgegeben.
$STR_REGEXPARRAYGLOBALFULLMATCH (4) Im Ergebnisarray wird für jeden Match ein Array gespeichert. Diese Arrays enthalten: an [0] den gesamten Match, an [1..n] folgen die SubMatches dieses Matches.
Die Konstanten sind in StringConstants.au3 definiert.

Rückgabewert

Flag = $STR_REGEXPMATCH (0) :

@error: Bedeutung
2 : Falsches Muster. @Extended = Offset des Fehlers im Muster.



Flag = $STR_REGEXPARRAYMATCH (1) oder $STR_REGEXPARRAYFULLMATCH (2) :

@error: Bedeutung
0: Array ist gültig. Siehe @extended für die weiteren Offsets überprüfen.
1: Array ist ungültig. Keine Übereinstimmungen.
2: Falsches Suchmuster, Array ist ungültig. @Extended = Offset des Fehlers im Muster.



Flag = $STR_REGEXPARRAYGLOBALMATCH (3) oder $STR_REGEXPARRAYGLOBALFULLMATCH (4) :

@error: Bedeutung
0: Array ist gültig.
1: Array ist ungültig. Keine Übereinstimmungen.
2: Falsches Suchmuster, Array ist ungültig. @Extended = Offset des Fehlers im Muster.

Bemerkungen

Reguläre Ausdrücke sind Strings, in denen einfache Textzeichen angeben, welcher Text in dem Zielstring existieren muss.
Einige Zeichen haben eine besondere Bedeutung, um anzugeben, welche Variabilität in dem Zielstring erlaubt ist. Für reguläre Ausdrücke in AutoIt ist normalerweise die Groß-/Kleinschreibung relevant.
Dabei kann man die gefundenen Strings entweder mit StringRegExp() extrahieren oder mit StringRegExpReplace() ersetzen.

Dabei sucht die Engine des Parses für die regulären Ausdrücke nach dem programmartigen Suchmuster und geht zur letzten erfolgreichen Suchstelle zurück, wenn ein Fund nicht mehr dem Format entspricht.
So geht es den gesamten Eingabestring durch und returnt je nach Flag die entsprechenden Ergebnisse.

Das sogenannte Backtracking ist eines der fundamentalsten Features eines Parsers für reguläre Ausdrücke und bereits jeder Programmierneuling sollte es bereits verstehen und täglich anwenden.
Es hinterlässt eine spezielle Haltemarke an jeder Weggabelung des Codes und man geht zu jener Haltemarke zurück wenn der aktuelle Codepfad sich als Sackgasse herausstellt.
Man backtrackt so weit zurück bis man entweder den richtigen Punkt findet (hier wäre es eine Übereinstimmung) oder bis man jeden Pfad erkundet hat ohne sein Ziel zu erreichen (keine Übereinstimmung gefunden).
Das suchen eines Dateinamens mit optionalen Wildcards (*) innerhalb einer Ordnerstruktur ist genau dasselbe.

AutoIt benutzt die PCRE Engine. PCRE bedeutet "Perl-Compatible Regular Expressions" und ist die umfassenste open-source Engine die verfügbar ist.
Diese Implementation bringt die sogenannte Unicode Category Properties (UCP) Unterstützung mit sich, welche es erlaubt die meisten von menschenhand entwickelten Sprachen sehr säuberlich zu parsen.
Um jedoch Vorgängerkompabilität zu alten AutoIt-Versionen zu wahren und die Geschwindigkeit der Übereinstimmungssuche so hoch wie möglich zu halten, ist der UCP Support standardmäßig nicht aktiviert.

Diese Seite ist nur eine Zusammenfassung der gängigsten Suchmuster. Für einen kompletten Einblick der PCRE-Suchmuster, welche in AutoIt implementiert sind, sollte man einen Blick auf diese Seite werfen.
Sollte man nicht bereits wissen wie reguläre Ausdrücke funktionieren, so sollte man sich vorher die verlinkte Dokumentation gründlich durchlesen um überhaupt im Ansatz zu wissen wie man an reguläre Ausdrücke angeht.

Reguläre Ausdrücke werden aus einem oder mehreren der folgenden einfachen Sonderzeichen gebildet. Ist ein Zeichen nicht in der folgenden Tabelle enthalten, dann steht es nur für sich selbst.

Wiederholungszeichen oder auch Quantifizierer genannt (*, +, ?, {...} ) versuchen die größtmögliche Entsprechung zu finden, außer wenn ihnen direkt ein Fragezeichen folgt; dann wird die kleinstmögliche Entsprechung der nachfolgenden Zeichen genommen.

Verschachtelte Gruppen sind erlaubt, aber es ist zu beachten, dass alle Gruppen dem zurückgegebenen Array zugewiesen werden, wobei die äußeren nach den inneren Gruppen berücksichtigt werden. Verwendet man statt der normalen Gruppierung () eine nicht-fangende Gruppierung (?: ... ) oder (?> ... ) wird die Gruppe dem zurückgegebenen Array nicht hinzugefügt.

Alles was in einer runden Klammer "()" steht wird als Gruppe bzw. Subpattern bezeichnet. Der Inhalt muß komplett in dem zu prüfenden Ausdruck enthalten sein. Alles was eingeklammert wird, wird in SubPatterns geschrieben. Diese können dann mit \1,\2...,\n abgerufen werden.
Alles was in einer eckigen Klammer "[]" steht wird als Set bezeichnet. Dort muß lediglich ein Zeichen in dem zu prüfenden Ausdruck enthalten sein.

Achtung: schlechte reguläre Ausdrücke können zu einer dauerhaft hohen CPU-Auslastung führen und diese eventuell beschädigen.

Glossar

Pattern Eine Regel mit der eine Zeichenfolge erkannt wird..
SubPattern Ein Pattern kann Suchfolgen enthalten, die separat in einer Gruppe aufgefangen werden..
Match Wird mit einem Pattern eine gültige Zeichenfolge erkannt, ist diese der Match.
Je nach Art des Patterns und Inhalt des Teststrings sind mehrere Matches möglich.
SubMatch Die mittels eines SubPatterns gefundene Zeichenfolge.

Globale Einstellungen


Diese Einstellungen werden nur am Anfang des Suchmusters wahrgenommen und wirken sich global aus.

Zeilenumbruch Konventionen
Zeilenumbruchzeichenfolgen werden wahrgenommen wo die ^ und $ Anker gefunden werden aber nicht die \N und . Anker.
Standardmäßig ist die Zeichenfolge für einen Zeilenumbruch das Makro @CRLF nicht umbrechbar. Ebenso wenig @CR und @LF alleine.
Diese Einstellung kann verändert werden indem man einer der folgenden Zeichenfolgen an den Anfang des Suchmusters stellt.
(*CR) Wagenrücklauf (@CR).
(*LF) Zeilenvorschub (@LF).
(*CRLF) Wagenrücklauf gefolgt von einem Zeilenvorschub (@CRLF).
(*ANYCRLF) Irgendeins der @CRLF, @CR oder @LF Makros. Das ist die standardmäßige Zeilenumbruchkonvention.
(*ANY) Jegliche Unicode-Zeilenumbruchsfolge: @CRLF, @LF, VT, FF, @CR oder \x85.

Was \R findet
(*BSR_ANYCRLF) Standardmäßig findet \R ein @CRLF, @CR oder @LF einzeln.
(*BSR_UNICODE) Bewirkt, dass \R eins der Unicode-Zeilenumbruchsfolgen findet: @CRLF; @LF, VT, FF, @CR oder \x85.

Optionen


PCRE-Suchmuster können Optionen enthalten welche sich in (? ) Gruppen befinden. Optionen können gruppiert werden, bspw. "(?imx)". Optionen welche einem Bindestrich folgen sind negiert: "(?im-sx)".
Optionen außerhalb einer Gruppe wirken sich auf den Rest des Patterns aus der danach noch folgt. Optionen innerhalb einer Gruppe wirken sich nur auf die Gruppe aus.
Des Weiteren verlieren Optionen ihr besondere Bedeutung innerhalb einer Zeichenklasse, in welcher sie als zu suchendes Zeichen behandelt werden.
(?i) Ohne Groß-/Kleinschreibung: Bei der Auswertung des regulären Ausdrucks wird nach dem Flag nicht zwischen Groß-/Kleinschreibung unterschieden. Dies wird nicht als Gruppe behandelt.
    Wenn UCP aktiviert ist, so wirkt sich die Groß-/Kleinschreibung auf die gesamte Unicode Gruppe 0 aus. Standardmäßig nur auf die ASCII Zeichen A-Z und a-z.
(?m) Multiline: ^ und $ finden Zeilenschaltungen innerhalb der Datenmenge. Standardmäßig ist diese Option deaktiviert.
(?s) Singleline oder DotAll: . findet alle Zeichen, auch Zeilenumbrüche. Standardmäßig findet "." keine Zeilenumbrüche.
(?U) Nicht-Gierig: Kehrt die Standardeinstellung für Gierigkeit der Quantifzierer um und setzt sie auf faul (nicht gierig).
    Standardmäßig ist die Suche gierig, siehe unten für weitere Erläuterung.
(?x) Extended: Ignoriert Whitespace-Zeichen außerhalb von Charakterklassen und # beginnt ein Kommentar bis zur nächsten soliden Zeilenumbruch.
    Nichts sagend verbessern die Whitespaces zwischen den Komponenten die Leserlichkeit.
    Standardmäßig matchen Whitespaces sich selbst und # ist ein Zeichen.

Zeichen, Metazeichen und Escaping (oder Zitierung)


Zeichen

Reguläre Ausdrücke bestehen aus Unicodetextzeichen welche sich selbst matchen und zudem aus Zeichenklassen die bestimmte Folgen angeben sowie Optionen.
Bestimmte Folgen und Optionen nutzen einige sogenannte Metazeichen welche eine besondere Bedeutung an sich haben oder spezielle Elemente in einem Muster angeben (siehe dafür die folgende Tabelle).
In Zeichenfolgen, welche nur den Text finden und keine besonderen Muster, stehen alphanumerische Zeichen immer für sich selbst.
Das bedeutet, dass das Suchmuster: "Standardzeichenfolge mit 中国文字" findet exakt den String "Standardzeichenfolge mit 中国文字". ("中国文字" bedeutet "chinesischer Text".)
Dieses Standardverhalten von Strings oder wie sie als Text und nicht als Muster wahrgenommen werden sollen nennt man auch ein Literal.

Repräsentation einiger Zeichen als Literal
Diese nachfolgenden Sequenzen werden verwendet um einige Zeichen als Literal zu interpretieren.
\a Alarmzeichen, gleich dem Kontrollzeichen BEL (Chr(7)).
\cX Findet ein Kontrollzeichen, basierend auf dem nächsten Zeichen. Zum Beispiel, \cM entspricht Strg-M.
Genau wie \x0D oder \r (Chr(13)).
\e Findet ein Escape-Zeichen (chr(27)). Nicht mit dem Escapen eines Zeichens verwechseln!
\n Findet einen Zeilenvorschub(@LF, chr(10)).
\r Findet ein Wagenrücklaufzeichen (@CR, chr(13)).
\t Findet einen Tabulator (chr(9)).
\ddd Findet Zeichen mit dem Oktalcode ddd, oder einer Rückreferenz sofern gefunden.
Findet die vorgegangene Gruppennummer exakt. Beispielsweise ([:alpha:])\1 würde ein Doppelzeichen finden.
\xhh Findet ein Unicode-Zeichen mit dem Hexwert hh: Beispielsweise ist"\x7E" eine Tilde, "~".
\x{hhhh} Findet ein Unicode-Zeichen mit dem Hexwert hhhh: Beispielsweise ist "\x{20AC}" das Eurozeichen, "€" (ChrW(0x20AC)).
\x wobei x nicht alphanumerisch ist und somit das Literal "x" ist.
Wird verwendet um Metazeichen als Literal zu interpretieren: "\.\[" wird als Punkt gefolgt von einer eckigen Klammer interpretiert also ".[".
\Q ... \E Wörtliche Sequence (Verbatim): Metazeichen verlieren ihre spezielle Bedeutung zwischen \Q und \E.
"\Q(.)\E" findet "(.)". Es ist äquivalent zum Escapen des Charakters (vorhin erwähnt) und ist einfacher zu lesen als "\(\.\)".

PCRE kennt folgende Metazeichen \ . ^ $ | [ ( { * + ? # und jedes einzelne davon kann eine oder mehrere Bedeutungen haben welche vom aktuellen Kontext abhängt.
Um ein Metazeichen als Literal einzufügen, so muss man das Zeichen Escapen, dies geschieht mit einem einfachen Backslash: "\$" wird zu "$".
Metazeichen werden in später in einer Untersektion noch weiter besprochen so wie ihre Bedeutungen.

Zeichentypen

. Findet jedes einzelne Zeichen außer, standardmäßig, eines Zeilenumbruchs. Findet auch Zeilenumbrüche wenn die Option (?s) aktiviert wurde.
\d Findet eine Dezimalziffer (0 bis 9). Auch jegliche Unicodedezimalziffer in jeglicher Sprache sofern UCP aktiviert wurde.
\D Findet alles außer Ziffern.
\h Findet alle waagerechten Whitespace-Zeichen (siehe Tabelle weiter unten).
\H Findet alle Zeichen außer waagerechte Whitespace-Zeichen.
\N Findet alle Zeichen außer Zeilenumbrüche ungeachtet dessen ob die Option (?s) aktiviert wurde.
\p{ppp} Nur wenn UCP aktiviert wurde: Findet alle Unicode-Zeichen mit der Eigenschaft ppp.
Beispielsweise findet "\b\p{Cyrillic}+" alle kyrillischen Wörter. "\p{Sc}" jegliches Währungssymbol.
Siehe die oben genannte Dokumentation für weitere Erläuterungen und Details.
\P{ppp} Nur wenn UCP aktiviert wurde: Findet alle Unicode-Zeichen die nicht die gegebene Eigenschafft ppp haben.
\R Findet alle Unicode-Zeilenumbrüche standardmäßig oder die der aktiven (*BSR_...) Einstellung.
Standardmäßig findet \R "(?>\r\n|\n|\r)" wobei "(?>...)" eine atomare Gruppe ist welche die Folge "\r\n" (@CRLF) nicht umbrechbar macht.
\s Findet alle Whitespace-Zeichen: Chr(9) bis Chr(13), welche Tabulator, Zeilenschaltung, senkrechter Tab, Seitenvorschub, Wagenrücklauf und das Leerzeichen sind ( Chr(32) ).
\S Findet alles außer Whitespace-Zeichen.
\v Findet alle vertikalen Whitespace-Zeichen (siehe Tabelle weiter unten).
\V Findet alle Zeichen außer vertikale Whitespace-Zeichen.
\w Findet alle Wörterzeichen: a-z, A-Z ,0-9 oder Unterstrich (_).
\W Findet alle Nicht-Wörterzeichen.
\X Nur wenn UCP aktiviert wurde: findet alle erweiterten Unicode Grapheme Cluster welches eine nicht umbrechbare Sequenz an Codepunkten ist welche ein einziges Zeichen für einen Nutzer darstellen.
    Als Konsequenz findet \X mehr als ein Zeichen im Eingabestring gegenteilig zu all den anderen Sequenzen in dieser Tabelle.

Mengen von Whitespace-Zeichen (Leerzeichen)


Horizontale Whitespace-Zeichen welche von \h gefunden werden

\h ist standardmäßig äquivalent zu "[\x09 \xA0]" (oder "[\x09 \xA0\x{1680}\x{180E}\x{2000}-\x{200A}\x{202F}\x{205F}\x{3000}]" when UCP aktiviert wurde.)
Diese Menge besteht aus: Horizontaler Tab (HT), Leerzeichen (Space), nicht-brechendes Leerzeichen
(unter anderem: Ogham Leerzeichen Markierung, Monoglischer Vokalseparator, En quad, Em quad, Em space, Three-per-em space, Four-per-em space, Six-per-em space, Figure space,
Punctuation space, Thin space, Hair space, Narrow no-break space, Medium mathematical space, Ideographic space wenn UCP aktiviert wurde.)

Vertikale Whitespace-Zeichen welche von \v gefunden werden
\v ist standardmäßig äquivalent zu "[\x0A-\x0D]" (oder "[\x0A-\x0D\x{0085}\x{2028}\x{2029}]" wenn UCP aktiviert wurde.)
Diese Menge besteht aus: Zeilenvorschub (LF), Vertikaler Tab (VT), Form feed (FF), Wagenrücklauf (CR) (unter anderem: Nächste Zeile (Next Line (NEL)), Zeilenseparator (Line Separator), Paragraph Separator wenn UCP aktiviert wurde.)

Whitespace-Zeichen welche von \s gefunden werden
\s ist äquivalent zu "[\h\x0A\x0C\x0D]" (ohne \xA0 von \h wenn UCP aktiviert ist)
Diese Menge besteht aus: Allen Zeichen in \h und Zeilenvorschub (LF), Form feed (FF), Wagenrücklauf (CR).

Whitespace-Zeichen welche von [[:space:]] gefunden werden
[[:space:]] ist äquivalent zu "\s".
Diese Menge besteht aus: Allen Zeichen in \s und dem vertikalen Tab (VT).


Zeichenklassen und POSIX Klassen


Zeichenklassen

Eine Zeichenklasse definiert eine Menge von erlaubten (respektive verbotenen) Zeichen, welches dem nächsten Zeichen im Eingabestring überstimmen (respektive nicht übereinstimmen) muss.
Innerhalb einer Zeichenklasse verlieren die meisten der Metazeichen ihre spezielle Bedeutung (wie z.B. $ . oder *) oder bedeuten etwas anderes (wie z.B. ^).
[ ... ] Findet jedes Zeichen in der Menge. [aeiou] findet alle kleingeschriebenen Vokale.
Eine zusammenhängende Menge kann definiert werden, indem ein Bindestrich zwischen dem ersten und letzten Zeichen gesetzt wird. [a-z] findet alle kleingeschriebenen Zeichen.
Um einen Bindestrich in einer Menge einzubeziehen (-), ist der Bindestrich als erstes, letztes Zeichen des Sets zu verwenden oder er kann auch escaped werden (\-).
Man sollte beachten, dass das Muster "[A-z]" nicht dasselbe wie "[A-Za-z]": das Vorherige ist äquivalent zu "[A-Z\[\\\]^_`a-z]".
Um eine schließende Klammer in einer Menge zu verwenden, ist es als erstes Zeichen in der Menge zu verwenden oder man muss ihn escapen: "[][]" und "[\[\]]" werden beide entweder "[" oder "]" finden.
Es ist zu beachten, dass in einer Charakterklasse nur \d, \D, \h, \H, \p{}, \P{}, \s, \Q...\E, \S,
\v, \V, \w, \W, und \x Sequenzen ihre besondere Bedeutung behalten, wobei \b gleich dem Backspacezeichen ist (Chr(8)).
[^ ... ] Findet alle Zeichen welche nicht in der Menge enthalten sind: "[^0-9]" findet alle Nicht-Ziffern.
Um ein Caret (^) in die Menge einzubinden, muss es nach dem Anfang der Menge stehen oder seine Bedeutung muss mittels Escaping aufgehoben werden (\^).

POSIX Klassen
Diese benannten Mengen werden innerhalb einer Charakterklasse verwendet: "[z[:digit:]w-y]" ist äquivalent zu "[w-z0-9]".
Um eine POSIX Klasse zu negieren muss ein Caret (^) nach dem ersten Doppelpunkt stehen: "[[:^digit:]]".
Wenn UCP aktiviert wurde, werden einige POSIX Klassen zu einigen Unicode Charakteruntermengen erweitert werden.
Anderenfalls sind sie standardmäßig zu 7-bit ASCII limitiert.
[:alnum:] ASCII-Zeichen und Ziffern (die selben wie [^\W_] oder [A-Za-z0-9]).
Wenn UCP aktiviert wurde: Unicode-Zeichen (die selben wie [^\W_] oder \p{Xan}).
[:alpha:] ASCII-Zeichen (die selben wie [^\W_] oder [A-Za-z]).
Wenn UCP aktiviert wurde: Unicode-Zeichen (die selben wie [^\W_] oder \p{L}).
[:ascii:] ASCII-Zeichen (die selben wie ([\x00-\x7F])).
[:blank:] Leerzeichen oder Tab (@TAB) (die selben wie \h oder [\x09\x20]).
Wenn UCP aktiviert wurde: horizontale Unicode-Whitespaces (die selben wie \h).
[:cntrl:] ASCII-Kontroll-Zeichen (die selben wie (Chr(0) ... Chr(31) und Chr(127))).
[:digit:] ASCII-Dezimalziffern (die selben wie \d oder [0-9]).
Wenn UCP aktiviert wurde: Unicode-Dezimalziffern (die selben wie \d oder \p{Nd}).
[:graph:] ASCII-Druck-Zeichen, ohne dem Leerzeichen (die selben wie Chr(33) ... Chr(126)).
[:lower:] ASCII-Kleinbuchstaben-Zeichen (die selben wie [a-z])
Wenn UCP aktiviert wurde: Unicode-Kleinbuchstaben-Zeichen (die selben wie \p{L1}).
[:print:] ASCII-Druck-Zeichen, mit dem Leerzeichen (die selben wie (Chr(32) ... Chr(126))
[:punct:] ASCII-Punkt-Zeichen, [:print:] ohne [:alnum:] und dem Leerzeichen (33-47, 58-64, 91-96, 123-126)
[:space:] ASCII-Whitespace-Zeichen (die selben wie [\h\x0A-\x0D]). [:space:] ist nicht genau das gleiche wie \s: es beinhaltet VT, Chr(11).
[:upper:] ASCII-Großbuchstaben-Zeichen (die selben wie [A-Z]).
Wenn UCP aktiviert wurde: Unicode-Großbuchstaben-Zeichen (die selben wie \p{Lu}).
[:word:] ASCII-"Wort"-Zeichen (die selben wie \w oder [[:alnum:]_]).
Wenn UCP aktiviert wurde: Unicode-"Wort"-Zeichen (die selben wie \w oder [[:alnum:]_] oder \p{XwD}).
[:xdigit:] Hexadezimale Ziffern (die selben wie [0-9A-Fa-f]).

Gruppen


Gruppen werden verwendet um Untermuster zu trennen und sind essenzielle Bestandteile mächtiger regulärer Ausdrücke.
Gruppen können entweder fangend (abspeichernd, capturing) oder ignorierend sein und können ungeachtet ihrer Natur (bis auf Kommentargruppen) geschachtelt werden.
Ein regulärer Ausdruck darf bis zu 65535 (2^16 - 1) fangende Gruppen enthalten.
Optionszeichen (bereits erwähnt) können einfach zwischen "?" und dem ":" einer nicht-fangenden Gruppe eingefügt werden:
"(?-i:[aeiou]{5})" findet fünf kleingeschriebene Vokale. In diesem Fall sind die Optionen nur lokal in der Gruppe angewendet und nicht global.
( ... ) Gruppe. Die Elemente in der Gruppe werden in Reihenfolge bearbeitet und können zusammen wiederholt werden.
    Zum Beispiel entspricht"(ab)+c" "abc" oder "ababc", aber nicht "abac". Eine Gruppe speichert auch den Text ab, der mit der Menge übereinstimmt,
    um ihn bei einem Rückverweis und in dem Rückgabearray der Funktion zu benutzen, abhängig von dem Flag-Parameter.
    Sie werden nummeriert beginnend von der 1 in der Reihenfolge wie ihre Klammeröffnungen sind.
    Gruppen können auch als Unterroutinen in einem anderen Bereich des Musters behandelt werden, sogar rekursiv.
(?<name> ... ) Benannte Gruppe. Kann später mittels Name sowie als Nummer referenziert werden.
    Es sollte vermieden werden den Namen "DEFINE" zu verwenden (Siehe "Bedinge Muster").
(?: ... ) Nicht-fangende Gruppe. Speichert keine der übereinstimmenden Zeichen im Array und kann nicht als Rückreferenz verwendet werden.
(?| ... ) Nicht-fangende Gruppe mit Reset. Setzt die Gruppe in jeder Top-Level-Alternative (höchste Klammerung) zurück:"
    "(?|(Mon)|(Tue)s|(Wed)nes|(Thu)rs|(Fri)|(Sat)ur|(Sun))day" findet einen Wochentag und ihre Abkürzung in der Gruppennummer 1.
(?> ... ) Atomare nicht-fangende Gruppe: Speert und backtrackt von dem was gefunden wurde. (Siehe Quantifizierer und Gierigkeit weiter unten.)
    Atomare Gruppen, wie besitzergreifende Quantifizierer, sind immer gierig.
(?# ... ) Kommentargruppe: Werden immer ignoriert (darf keine geschlossene Klammern ")" enthalten, aus diesem Grunde sind sie auch nicht schachtelbar).

Quantifizierer und Gierigkeit


Quantifizierer (oder Wiederholungsspezifizierer) geben an wie viele vorangehende Zeichen, Klassen, Referencen oder Gruppen gefunden werden sollen.
Optionale Gierigkeit gibt an wie aggressiv sich die Wiederholung verhalten soll. Beispielsweise findet "\d{3,5}" mindestens drei aber nicht mehr als fünf Dezimalziffern.
Standardmäßig sind die Muster "gierig", was bedeutet, dass Quantifizierer wie * + ? {...} den längsten String finden welcher noch den Rest des Musters erfüllt.
Gierigkeit kann für das gesamte Muster invertiert werden indem man die Option (?U) am Anfang ds Musters angibt oder lokal indem man ein Fragezeichen "?" nach einem Quantifizierer setzt.
nicht-gieriger (faul) Wiederholungen werden den kleinsten möglichen String finden welcher noch den Rest des Musters erfüllt.
Bei einem Eingabestring von "aaab" wird das Muster "(a*)([ab]+)" "aaa" finden und dann "b" aber "(?U)(a*)([ab]+)" findet "" dann "a":
Ein leerer String ist genug um das faule "(a*)" zu erfüllen und das gefangene "a" wird vom "([ab]+)" Untermuster gefunden.

Besitzergreifende Quantifizierer sind atomar und gierig. Sie sind eine Abkürzung für simple atomare Gruppen.
"\d++" ist eine Abkürzung für "(?>\d+)" und dessen Verhalten ist "finde eine komplette Sequenz von einer oder mehreren Ziffern aber gib niemals eins davon zurück".
In Konsequenz kann "\d++(\d)" niemals die letzte Ziffer (in fetter Schriftart) finden, da das letzte Zeichen bereits gefunden und von "\d++" gesperrt wurde.

Dies in Betrachtung mit der einfachen Gierigkeit, wo "\d+(\d)" erst die komplette Sequenz mit Ziffern mit "\d+" findet aber dann das letzte backtrackt um "(\d)" zu erlauben, dass es es fangen kann.
Es gibt mehr als zwei Gründe um atomare Gruppen oder besitzergreifende Quantifizierer zu nutzen:
Entweder um eine Folge von Zeichen zu finden welche auch individuell auftauchen können (z.B. "\r\n" in der Definition von \R),
oder um das schnelle Scheitern der Engine herbeizuführen wo man ungebundene Wiederholungen verwendet damit die Engine nicht sehr große Gruppen sucht und dann scheitert.
? 0 oder 1, gierig.
?+ 0 oder 1, besitzergreifend.
?? 0 oder 1, faul.
* 0 oder mehr, gierig.
*+ 0 oder mehr, besitzergreifend.
*? 0 oder mehr, faul.
+ 1 oder mehr, gierig.
++ 1 oder mehr, besitzergreifend.
+? 1 oder mehr, faul.
{x} genau x.
{x,y} mindestens x und nicht mehr als y, gierig.
{x,y}+ mindestens x und nicht mehr als y, besitzergreifend.
{x,y}? mindestens x und nicht mehr als y, faul.
{x,} x oder mehr, gierig.
{x,}+ x oder mehr, besitzergreifend.
{x,}? x oder mehr, faul.

Verschiebung (Alternation)

X|Y Findet entweder das Untermuster X oder Y: "ab|dc|ground" findet "ac" oder "dc" oder "ground".

Rückreferenzen und Referenzen zu Unterroutinen


Rückreferenzen erlauben es einem den Inhalt einer vorgegangenen gefangenen Gruppe zu nutzen.
\n Referenziert eine vorgegangene Gruppe durch ihre absolute Nummer.
    Warnung: Wenn die Gruppennummer n nicht existiert, wird es als Zeichen mit einem Wert n behandelt. Sofern n keine gültige Oktalzahl ist erfolgt ein Error.
    Aufgrund dieser Mehrdeutigkeit ist diese Form nicht zu empfehlen. Die nachfolgenden Formen sind eher zu bevorzugen.
\gn Referenziert eine vorgegangene Gruppe durch ihre absolute Nummer.
\g{n} Referenziert eine vorgegangene Gruppe durch ihre absolute Nummer. Ähnlich wie das obere aber hier wird deutlich wo n beginnt und aufhört:
    Hilfreich wenn die folgenden Zeichen Ziffern sind.
\g-n Referenziert eine vorgegangene Gruppe durch ihre relative Nummer.
\k<name> Referenziert eine vorgegangene durch ihren Namen.

Referenzen zu Unterroutinen
Fangende Gruppen sind Untermuster welche aufgerufen werden können (auch rekursiv) genau wie eine Subroutine in einer Programmiersprache. In AutoIt wäre das beispielsweise eine Funktion.
Das Untermuster wird einfach am aktuellen Punkt neu ausgeführt. Siehe Referenzdokumentation für Details und Beispiele.
(?R) or (?0) Führt das gesamte Suchmuster rekursiv neu aus.
(?n) Ruft ein Untermuster durch ihre absolute Nummer auf.
(?+n) Ruft ein Untermuster durch ihre relative Nummer auf.
(?-n) Ruft ein Untermuster durch ihre relative Nummer auf.
(?&name) Ruft ein Untermuster durch ihren Namen auf.

Anker (Anchors) und Behauptungen (Assertions)


Anker und Behauptungen sind tests die an der aktuellen Abfrageposition nichts verändern und dadurch weder Zeichen verschlingen oder welche fangen.

Ein Anker testet die Position an der aktuellen Abfrageposition.
^ Das Caret-Zeichen findet außerhalb einer Charakterklasse den Start des Eingabestrings und den Beginn einer neuen Zeile nach einem nicht-finalen Zeilenumbruch (nicht-final bedeutet, das danach noch Text folgt) sofern die Option (?m) aktiv ist.
Standardmäßig ist die Zeilenumbruchsfolge der Wagenrücklauf @CRLF.
Innerhalb einer Charakterklasse komplementiert das Caret ^ die Klasse indem es alle Buchstaben die danach folgen nicht findet.
$ Außerhalb einer Charakterklasse findet das Dollar-Zeichen das Ende des Eingabestrings oder das Ende einer Zeile markiert durch einen Zeilenumbruch sofern (?m) aktiv ist.
Innerhalb einer Charakterklasse wird das $ als Literal behandelt und hat keine spezielle Bedeutung.
\A Findet nur am absoluten Anfang des Eingabestrings unabhängig von der multiline-Option (?m). Findet nie wenn der Offset nicht 1 ist.
\G Findet nur wenn die aktuelle Position die Position des ersten Fundes im Eingabestring ist.
\z Findet nur am Ende des Eingabestrings unabhängig von der multiline-Option (?m).
\Z Findet nur am Ende des Eingabestrings oder vor einem Zeilenumbruch am Ende unabhängig von der multiline-Option (?m).

Eine Behauptungen testet die Zeichen vorangehend (look-behind), am (Wortgrenze, word boundary) oder folgend (look-ahead) der aktuellen Abfrageposition.
\b Findet bei Wortgrenze. Das heißt zwischen Zeichen und nicht beide \w oder \W. Siehe \w für die Bedeutung des Kennzeichners "Wort".
Innerhalb einer Charakterklasse bedeutet \b ein Backspace (Chr(8)).
\B Findet wenn es nicht an der Wortgrenze ist.
(?=X) Positiv Folgend: Findet, wenn das Untermuster X an der aktuellen Abfrageposition übereinstimmt.
(?!X) Negativ Folgend: Findet, wenn das Untermuster X an der aktuellen Abfrageposition nicht übereinstimmt.
(?<=X) Positiv Vorangehend: Findet, wenn das Untermuster X an den vorangehenden Zeichen übereinstimmt.
    Das Untermuster X muss eine feste Länge besitzen und darf nicht undefinierte Quantifizierer wie * + oder ? enthalten.
(?<!X) Negativ Vorangehend: Findet, wenn das Untermuster X an den vorangehenden Zeichen nicht übereinstimmt.
    Das Untermuster X muss eine feste Länge besitzen und darf nicht undefinierte Quantifizierer wie * + oder ? enthalten.

Zurücksetzung des Fundes (Reset)


Es kann vorkommen, dass es notwendig ist das bisher gefundene zu verwerfen um relevantere Daten später im Eingabestring zu finden.
\K Setzt den Beginn eines Fundes an die aktuelle Abfrageposition im Eingabestring. Man sollte dabei beachten, dass bereits gefangene Gruppen nun alleine stehen und immer noch im Rückgabearray auftauchen und
    dadurch ist es möglich sie später auch zu referenzieren. Die Aktion durch \K ist ähnlich aber nicht identisch zum vorangehenden Vorgehensweise (look-behind) und unterscheidet sich darin,
    dass \K mit verschiedenen Längen arbeiten kann.

Bedingte Muster


Diese Konstrukte sind ähnlich zu If...EndIf und If...Else...EndIf Verzweigungen.
(?(Bedingung)yes-pattern) Erlaubt die bedingte Ausführung eines Musters.
(?(Bedingung)erfüllendes-Muster|nicht-erfüllendes-Muster) Wählt zwischen zwei bestimmten Mustern je nachdem Ergebnis der (Bedingung).
(n) Testet, ob die gefangene Gruppe mit einer absoluten Nummer n gefunden wurde.
(+n) Testet, ob die gefangene Gruppe mit einer relativen Nummer +n gefunden wurde.
(-n) Testet, ob die gefangene Gruppe mit einer relativen Nummer -n gefunden wurde.
(<name>) Testet, ob die gefangene Gruppe mit dem Namen name gefunden wurde.
(R) Testet, ob eine Rekursion stattfand.
(Rn) Testet, ob die letzte Rekursion für eine gefangene Gruppe mit der absoluten Nummer n war.
(R&name) Testet, ob die letzte Rekursion für eine gefangene Gruppe mit dem Namen name war.
(DEFINE) Wird ohne Pattern benutzt und erlaubt die Zuweisung der Unterroutine von woanders.
"(?x) (?(DEFINE) (?<byte> 2[0-4]\d | 25[0-5] | 1\d\d | [1-9]?\d) )" definiert die Unterroutine "byte" welche eine der Komponenten einer IPv4-Adresse findet.
Die eigentliche Adresse kann mit "\b (?&byte) (\.(?&byte)){3} \b" gefunden werden.
(assertion) Hier ist assertion ist entweder eine positive oder negative, vorangehende (look-behind) oder folgende (look-ahead) Assertion (Behauptung).

Diverse fortgeschrittenere Features


Diese Optionen, die Escapes und die Konstrukte werden hier nur genannt, für eine Erläuterung warum, wie und wann man sie nutzen sollte siehe die Referenzdokumentation.

Ungewöhnliche Einstellungen und Optionen
(?J) Erlaubt Dubletten in Gruppen- und Unterroutinennamen (hier nicht weiter erläutert).
(?X) Verursacht Fehler durch einige out-of-context Sequenzen.
(*J) Aktiviert die Javascript-Kompatibilität (hier nicht weiter erläutert).
(*LIMIT_MATCH=n) Limitiert die Anzahl der Funde auf n.
(*LIMIT_RECURSION=n) Limitiert die maximale Rekursionstiefe auf n.
(*NO_START_OPT) Deaktiviert einige Optimierungen (hier nicht weiter erläutert).

Backtracking Steuerung
(*ACCEPT) Erzwingt einen sofortigen Sucherfolg in der aktuellen Unterroutine oder im Top-Level-Muster (dem höchsten).
(*FAIL) or (*F) Erzwingt einen sofortigen Suchmisserfolg.
(*MARK:name) or (*:name) (Siehe Referenzdokumentation.)
(*COMMIT) (Siehe Referenzdokumentation.)
(*PRUNE) (Siehe Referenzdokumentation.)
(*PRUNE:name) (Siehe Referenzdokumentation.)
(*SKIP) (Siehe Referenzdokumentation.)
(*SKIP:name) (Siehe Referenzdokumentation.)
(*THEN) (Siehe Referenzdokumentation.)
(*THEN:name) (Siehe Referenzdokumentation.)

Allgemeinte Kommentare über reguläre Ausdrücke in AutoIt


    1. Wenn UCP aktiviert ist wirkt sich die Groß-/Kleinschreibung auf das gesamte Unicode Gruppe 0 aus, standardmäßig nur auf die ASCII-Zeichen A-Z und a-z.
        Es existiert eine kleine Anzahl an viele-zu-einen (many-to-one) Verknüpfungen in Unicode wie z.B. das kleine griechische Sigma, diese werden durch PCRE mit UCP aktiviert unterstützt.
       
    2. Es existieren verschiedene Formen für das Escapen um eine Kompatibilität mit Perl, Ruby, Python, Javascript, .NET und anderen Engines herzustellen.
        Man sollte auf keinen Fall keine Konstrukte verwenden welche hier nicht aufgezählt wurden, denn einige funktionieren schlicht nicht, einige liefern falsche Resultate und einige bergen große Fehler oder stürzen ab.
       
    3. Die Standard-Zeilenumbruch-Konventionen ist die nicht-umbrechbare Sequenz @CRLF oder ein separates @CR bzw. @LF.
        Auf ähnliche Weise findet \R seine Gruppen durch die selbe Menge.
        Man sollte immer wissen was man als Eingabestring nimmt. Bedeutet der Wagenrücklauf (@CR) bzw. der Zeilenvorschub (@LF) was anderes als ihre eigentliche Bedeutung,
        so sollte man eventuell die Zeilenumbruchskonvention anpassen oder die Bedeutung des \R (siehe "Einstellungen").

Siehe auch das Reguläre Ausdrücke Tutorial in welchem man ein Script zum testen der eigenen regulären Ausdrücke ausführen kann.

Verwandte Funktionen

StringInStr, StringRegExpReplace

Beispiel

Beispiel 1

; Option 1, Verwendung eines Offsets

#include <MsgBoxConstants.au3>
#include <StringConstants.au3>

Local $aArray = 0, _
        $iOffset = 1

While 1
    $aArray = StringRegExp('<test>a</test> <test>b</test> <test>c</Test>', '(?i)<test>(.*?)</test>', $STR_REGEXPARRAYMATCH, $iOffset)
    If @error Then ExitLoop
    $iOffset = @extended
    For $i = 0 To UBound($aArray) - 1
        MsgBox($MB_SYSTEMMODAL, "RegExp-Test mit Option 1 - " & $i, $aArray[$i])
    Next
WEnd

Beispiel 2

; Option 2, einfacher Rückgabewert, php/preg_match()-Stil

#include <MsgBoxConstants.au3>
#include <StringConstants.au3>

Local $aArray = StringRegExp('<test>a</test> <test>b</test> <test>c</Test>', '(?i)<test>(.*?)</test>', $STR_REGEXPARRAYFULLMATCH)
For $i = 0 To UBound($aArray) - 1
    MsgBox($MB_SYSTEMMODAL, "RegExp Test mit Option 2 - " & $i, $aArray[$i])
Next

Beispiel 3

; Option 3, globale Rückgabe, alter AutoIt-Stil

#include <MsgBoxConstants.au3>
#include <StringConstants.au3>

Local $aArray = StringRegExp('<test>a</test> <test>b</test> <test>c</Test>', '(?i)<test>(.*?)</test>', $STR_REGEXPARRAYGLOBALMATCH)
For $i = 0 To UBound($aArray) - 1
    MsgBox($MB_SYSTEMMODAL, "RegExp-Test mit Option 3 - " & $i, $aArray[$i])
Next

Beispiel 4

; Option 4, globale Rückgabe, php/preg_match_all()-Stil

#include <MsgBoxConstants.au3>
#include <StringConstants.au3>

Local $aArray = StringRegExp('F1oF2oF3o', '(F.o)*?', $STR_REGEXPARRAYGLOBALFULLMATCH)
Local $aMatch = 0
For $i = 0 To UBound($aArray) - 1
    $aMatch = $aArray[$i]
    For $j = 0 To UBound($aMatch) - 1
        MsgBox($MB_SYSTEMMODAL, "RegExp-Test mit Option 4 - " & $i & ',' & $j, $aMatch[$j])
    Next
Next

Beispiel 5

#Region    ;************ Includes ************
#include <Array.au3>
#EndRegion ;************ Includes ************
$sTest = "Name Paul (Müller). Name Hans (Schmidt oder Meier)."
$sPattern = "Name\h(\w+)\h*\(([^\)]*)\)"
#cs
Name\h        "Name" gefolgt von einem horizontalen Tab/Leerzeichen.
(\w+)         Eine Folge von Wörterzeichen [a-zA-Z_0-9], 1-mal oder mehr, in einer Gruppe aufgefangen - Vorname.
\h*\(         Horizontale Tabs/Leerzeichen, 0-mal oder mehr, gefolgt von öffnender Klammer.
([^\)]*)      Alle Zeichen außer schließender Klammer, 0-mal oder mehr, in einer Gruppe aufgefangen - Nachname(n).
\)            Am Ende eine schließende Klammer.
#ce

Global $a2D[0][2]
Global $iArrayIdx = -1

$aMatch = StringRegExp($sTest, $sPattern, 1) ; $STR_REGEXPARRAYMATCH
ConsoleWrite("$aMatch --> " & _cwArray($aMatch, 1) & @LF) ; ==> Paul | Müller

$aMatch = StringRegExp($sTest, $sPattern, 2) ; $STR_REGEXPARRAYFULLMATCH
ConsoleWrite("$aMatch --> " & _cwArray($aMatch, 2) & @LF) ; ==> Name Paul (Müller) | Paul | Müller

$aMatch = StringRegExp($sTest, $sPattern, 3) ; $STR_REGEXPARRAYGLOBALMATCH
ConsoleWrite("$aMatch --> " & _cwArray($aMatch, 3) & @LF) ; ==> Paul | Müller | Hans | Schmidt oder Meier

$aMatch = StringRegExp($sTest, $sPattern, 4) ; $STR_REGEXPARRAYGLOBALFULLMATCH
ConsoleWrite("$aMatch --> " & _cwArray($aMatch, 4) & @LF) ; ==> [a-0]: Name Paul (Müller) | Paul | Müller | [a-1]: Name Hans (Schmidt oder Meier) | Hans | Schmidt oder Meier

Func _cwArray($a, $iFlag, $sText = "")
    Local $s
    For $i = 0 To UBound($a) - 1
        If IsArray($a[$i]) Then
            $iArrayIdx += 1
            $s &= "[a-" & $iArrayIdx & "]: " & _cwArray($a[$i], $iFlag, " (Unter-Array) " & $i)
        Else
            If $iFlag = 4 Then _ArrayAdd($a2D, '{Array} ' & $iArrayIdx & '  Item ' & $i & '|' & $a[$i])
            $s &= $a[$i] & " | "
        EndIf
    Next
    If $iFlag < 4 Then
        _ArrayDisplay($a, "Flag " & $iFlag & $sText)
    Else
        If Not StringInStr($sText, " (Unter-Array) ") Then
            _ArrayDisplay($a2D, "Flag " & $iFlag & " (Unter-Arrays) ")
        EndIf
    EndIf
    Return $s
EndFunc   ;==>_cwArray

Beispiel 6

#include <Array.au3>
#include <Constants.au3>

; ----------------- Anwendung von ?<!
; Suchmuster:
; alles außer "142"
; DANN "Hallo"

Dim $array[2]

$array[0] = "142Hallo"
$array[1] = "412Hallo"

For $i = 0 To UBound($array) - 1
    $regexp = StringRegExp($array[$i], "(?<!142)(Hallo)", 3)
    _ArrayDisplay($regexp, $array[$i])
Next




Beispiel 7

#include <Array.au3>
#include <Constants.au3>

; ----------------- Anwendung von Wiederholungszeichen
; Suchmuster:
; 2x Zahl
; 1x .
; 2x Zahl
; 1x .
; 4x Zahl

Dim $array[2]

$array[0] = "23.08.2010"
$array[1] = "23.08.10"

For $i = 0 To UBound($array) - 1
    $regexp = StringRegExp($array[$i], "\d{2}\.\d{2}\.\d{4}", 3)
    _ArrayDisplay($regexp, $array[$i])
Next




Beispiel 8

#include <Array.au3>
#include <Constants.au3>

; ----------------- Anwendung von \b
; Durch das Voranstellen von \b und das anhängen von \b an das Ende wird nur an der Wortgrenze gesucht.
; "Abgrund oder folge" wird nicht gefunden, da das Wort Abgrund und nicht Grund heisst

$sString = _
        "Grund oder Folge der Armut?" & @CRLF & _
        "Fahre ich in den Abgrund oder folge ich der Straße?"
$aResult = StringRegExp($sString, "(?i)\bgrund oder folge\b", 3)
_ArrayDisplay($aResult, "StringRegExp Results")




Beispiel 9

#include <Array.au3>
#include <Constants.au3>

; ----------------- Anwendung von gierigen und faulen Wiederholungszeichen
; Das erste * ist gierig. Es wird die längste Stelle gesucht
$aRegExp = StringRegExp("Die Abkürzung 'ISP' heißt 'Internet Service Provider'.", ".*'(.*)'.*", 3)
_ArrayDisplay($aRegExp)

; Durch anhängen eines ? wird es faul und es wird die kürzeste Stelle gesucht
$aRegExp = StringRegExp("Die Abkürzung 'ISP' heißt 'Internet Service Provider'.", ".*?'(.*?)'.*", 3)
_ArrayDisplay($aRegExp)

; Das erste * ist gierig. Es wird die längste Stelle gesucht
$aRegExp = StringRegExp("12-34.abc.def@mail.de", "(.*)\.(.*)*@(.*)\.(.*)", 3)
_ArrayDisplay($aRegExp)

; Durch anhängen eines ? wird es faul und es wird die kürzeste Stelle gesucht
$aRegExp = StringRegExp("12-34.abc.def@mail.de", "(.*?)\.(.*)*@(.*)\.(.*)", 3)
_ArrayDisplay($aRegExp)




Beispiel 10

#include <Array.au3>
#include <Constants.au3>

; ----------------- Anwendung von \n
; Das erste Wort (auf welches " Email: " folgt) wird in einer temporären Variable gespeichert (weil eingeklammert)
; Diese Variable wird mit \1 abgerufen. Die 1 steht dabei für die Nummer des Subpatterns.
$sString = "Name Email: Name@web.de" & @CRLF
$sString &= "Name Email: Peter@live.de" & @CRLF
$sString &= "Acanis Email: Acanis@gmx.net" & @CRLF
$sString &= "Acanis Email: Coolertyp@googlemail.com" & @CRLF
$aRegExp = StringRegExp($sString, "(\w+) Email: (\1@\w+\.\w+)", 3)
_ArrayDisplay($aRegExp)



Beispiel 11

#include <Array.au3>
#include <Constants.au3>

; ----------------- Anwendung von ?:
; Das folgende Beispiel soll aufzeigen, wie ein Subpattern gespeichert wird und wie nicht.
$sString = "Mein Name ist Peter" & @CRLF
$sString &= "Mein Name ist Karl" & @CRLF
$sString &= "Mein Name ist Max" & @CRLF

; So würde nur das Subpattern zurückgegeben werden
$aResult = StringRegExp($sString, "Mein Name ist (Karl|Max)", 3)
_ArrayDisplay($aResult)

; Durch voranstellen von ?: wird das Subpattern nicht gespeichert und es wird der komplette Satz als Ergebnis zurückgegeben
$aResult = StringRegExp($sString, "Mein Name ist (?:Karl|Max)", 3)
_ArrayDisplay($aResult)



Beispiel 12

#include <Array.au3>
#include <Constants.au3>

; ----------------- Verwendung von Subpatterns
; Das folgende Beispiel soll aufzeigen, wie ein Subpattern gespeichert wird und dieses dann später wieder verwendet wird.
$date = '01.03.2008' ; YYYY/MM/DD
$new = StringRegExpReplace($date, "(\d{2})\.(\d{2})\.(\d{4})", "$3/$2/$1")
MsgBox($MB_OK, "", $new)




Beispiel 13

#include <Array.au3>
#include <Constants.au3>

; ----------------- Verwendung von Wiederholungszeichen.
; Hier wird der Inhalt der Gruppe überschrieben, sobald ein Wiederholungszeichen auf die Gruppe angewandt wird
$sText = "aaabacad"
$aRet = StringRegExp($sText, "(a.)+", 3)
_ArrayDisplay($aRet)

Beispiel 14

#include <Array.au3>
#include <Constants.au3>

; ----------------- Anwendung von Wiederholungszeichen
; Suchmuster:
; 1x "P"
; mindestens 1x "a"
; 1x "r"

Dim $array[2]

$array[0] = "Ich habe 10 Paaaaaar zu Hause"
$array[1] = "Ich habe 10 Par zu Hause"

For $i = 0 To UBound($array) - 1
    $regexp = StringRegExp($array[$i], "Pa+r", 3) ;alternativ: Pa{1,}r
    _ArrayDisplay($regexp, $array[$i])
Next




Beispiel 15

#include <Array.au3>
#include <Constants.au3>

; ----------------- Anwendung von Oder und ?:
; Suchmuster:
; "-XY" ODER " XY" (?:\-XY| XY) >>> durch ?: wird nicht nur das Ergebnis der Oder-Bedingung sondern auch der Rest im Array ausgegeben
; DANN Zahlen (beliebige Anzahl) \d*
; DANN "-" \-

Dim $array[2]

$array[0] = "425-65-XY4587543-ghzgt7"
$array[1] = "4 25-65 XY4587543-ghzgt7"

For $i = 0 To UBound($array) - 1
    $regexp = StringRegExp($array[$i], "(?:\-XY| XY)\d*\-", 3)
    _ArrayDisplay($regexp, $array[$i])
Next