Hi,
ich möchte mit diesem Tutorial einen Einblick in die fortgeschrittenen Techniken von RegEx geben und denen, die bereits
grundlegende RegEx-Kenntnisse haben, mehr Möglichkeiten eröffnen.
Dieses Tutorial setzt das vorhandene Tutorial von @Link vorraus, dies ist hier zu finden:
RegEx Tutorial - Blutige Anfänger und Fortgeschrittene
Es ist möglich, dass sich beide Tutorials an manchen Stellen überschneiden, da ich nicht das gesamte Tutorial von Link mit
meinem abgleichen werde. Sollte das passieren, dann sind die behandelten Inhalte hier trotzdem gut aufgehoben
Dieses Tutorial arbeitet aktuell abstrakt - es gibt noch keinen direkten .NET Code, dieser folgt aber mit Sicherheit noch.
Die Interessierten werden sich trotzdem zurecht finden.
Los gehts!
Übersicht
Grundlagen
Dieses Tutorial setzt gewisse Kenntnisse und Grundlagen vorraus, wie in der Einleitung beschrieben. Man sollte beispielsweise wissen was ein Pattern ist, was ein Token
ist und wie man RegEx im .NET Framework verwendet. Ebenfalls wichtig ist es, die Grundlagen von RegEx zu kennen und anwenden zu können. Dass ein
außer NewLine matcht sollte genauso klar sein wie die Nutzung von Gruppen und Quantifiern. Alle weiteren Grundkenntnisse von RegEx würde ich empfehlen, aber auch mit
dem o.g. Wissen sollte man sich in diesem Tutorial noch zurecht finden.
Wie funktioniert RegEx?
Erstmal möchte ich mich mit der Funktionsweise von RegEx befassen, denn die kann oft helfen, das eigene Pattern besser zu verstehen.
Die RegEx-Engine setzt 2 Cursors - ich nenne sie hier jetzt mal Cursors - einen an den Anfang des Patterns und einen an den Anfang des zu überprüfenden Strings.
Man kann sich diese Cursors wie die blinkende Linie in einem Textfeld vorstellen.
Nun beginnt RegEx damit, die Inhalte zu vergleichen. Es wird versucht, den ersten Character im String mit dem ersten Token des Patterns abzugleichen.
Natürlich gibt es hier noch Quantifier, so wie
im Pattern passt, dann springt der Cursor im Pattern und im Inhalt eins weiter, und versucht wieder, den Character nach dem Cursor mit dem Token nach dem Cursor im Pattern
abzugleichen. Schlägt dieser Test nun fehl, dann springt der Cursor im Inhalt wieder eine Stelle nach vorn, der Cursor im Pattern setzt sich jedoch zurück und beginnt wieder von
vorn. Anschaulich gestaltet:
String:
Pattern:
Schritt 1:
Der Cursor sitzt sowohl im Pattern als auch im String auf Position 0, daher vor jeglichem Inhalt.
String:
Pattern:
Schritt 2:
Die Engine versucht, den ersten Character im String mit dem ersten Token im Pattern abzugleichen. Dieser Test ist erfolgreich: Das erste Token im Pattern ist der Character a,
der erste Character im String ist ebenfalls ein a. Beide Cursor springen in der Position eins nach vorn.
String:
Pattern:
Schritt 3:
Die Engine versucht erneut, den nächsten Character im String mit dem nächsten Token im Pattern abzugleichen. Wieder ist der Test erfolgreich: Das folgende Token
alle Character außer NewLine, der folgende Character ist ein c, beides stimmt also überein, die Position des Cursors sprint wieder eins nach vorn.
String:
Pattern:
Schritt 4:
Die Engine versucht beide Schritte erneut. Diesmal scheitert der Abgleich allerdings, wenn das folgende Token
auf das c folgende WhiteSpace zu matchen. Der Cursor im Pattern springt wieder auf Position 0, der Cursor im String wiederum eins weiter.
String:
Pattern:
Weitere Schritte:
Der Rest sollte klar sein: Die Engine matcht wieder Token für Token und findet die darauffolgende Zeichenkette "abc", weil sie dem Pattern
Unterschiede von RegEx in verschiedenen Programmiersprachen
Ein weiteres Thema, das oft Probleme bereitet, ist die Unterstützung von RegEx in verschiedenen Programmiersprachen. Die Ursache hierfür sind die verschiedenen RegEx-Engines, die jeweils
eben auch unterschiedliche Funktionalität bereitstellen. (siehe en.wikipedia.org/wiki/Comparis…egular_expression_engines)
Folglich kann ein und das selbe RegEx-Pattern in unterschiedlichen Programmiersprachen zu unterschiedlichen Ergebnissen führen. Auf die Gefahr hin, nicht völlig aktuelle Informationen zu verbreiten,
ziehe ich als Beispiel "possessive Quantifiers" heran, die meines Wissens nach von .NET nicht untersützt werden.
Abhilfe schaffen hier diverse Online-Tools, die beim Konvertieren helfen oder zumindest das Testen erleichtern, sodass man erkennt, welche Unterschiede das Pattern
in verschiedenen Programmiersprachen aufweist.
Greedy, Lazy, Backtracking, Posessive
Bevor ich zu den Advanced Patterns komme ist es wichtig, erst einmal zu verstehen was Quantifiers sind und wie sie funktionieren.
Grundsätzlich gibt es drei Varianten von Quantifiern, welche ich erst einmal erkläre. @'Link''s Tutorial beschreibt das Token
"bis zum nächsten Vorkommen von", was so nicht völlig korrekt ist, bzw. einen falschen Eindruck vermitteln kann. Für Anfänger ist das auch eine sehr gute Beschreibung, ich möchte
das Ganze hier allerdings näher erläutern.
Greedy:
Greedy ist das Standardverhalten eines Quantifiers. Greedy heißt, dass der vorangehende Quantifier, also beispielsweise ein
sodass das Pattern ein Match ergibt. Nehmen wir also ein einfaches Beispiel:
String:
Pattern:
Das Pattern beschreibt ein beliebiges Zeichen, welches 0 oder mehrmals wiederholt wird. Der
als Match des Patterns erkannt wird, denn wie oben erwähnt bewirkt ein "Greedy"-Quantifier, dass so viele Vorkommen wie möglich gematcht werden.
Lazy:
Lazy ist das genaue Gegenteil zum oben genannten "Greedy"-Quantifier. Es wird durch ein
um dem
das Ergebnis des folgenden Tests schließen lässt:
String:
Pattern:
Was wird nun also gematcht? Erstmal garnichts. Durch die Spezifizierung des Quantifiers geht dieser nun "lazy" vor, das heißt, er matcht so wenig wie möglich, achtet aber trotzdem
darauf, dass das Pattern gematcht werden kann. Hierdurch entsteht auch die Darstellung in @'Link''s Tutorial, "bis zum nächsten Vorkommen von", denn nehmen wir nun
Pattern:
so wird das gesamte Wort "Hallo" gematcht. Die Engine hat bemerkt, dass ein Match zustande kommt, wenn die ersten vier Buchstaben vom "Lazy"-Quantifier gematcht werden und somit
das Wort gematcht. Lazy matcht also so wenige Vorkommen wie möglich, beachtet aber das Pattern.
Backtracking:
Ein nicht weniger wichtiger Bestandteil von RegEx ist das Backtracking, was die Grundlage für "Posessive"-Quantifier bildet (folgen gleich).
Backtracking heißt, dass, wie bereits oben bei "Lazy" angedeutet, die Engine auf das Pattern an sich achtet. Man betrachte folgendes Beispiel:
String:
Pattern:
Ich bitte dich - den Leser - einmal direkt darüber nachzudenken was die Engine in diesem Fall machen würde, und ob ein Match vorliegt oder nicht.
Wenn eine Meinung herrscht, dann kommt hier das Ergebnis:
Es existiert ein Match. Wenn jemand aber tatsächlich darüber nachgedacht hat, dann wird demjenigen aufgefallen sein, dass das laut obiger Definition
doch gar nicht passieren darf, denn der
bis ans Ende matchen, um danach kein passendes "o" mehr zu finden, was eigentlich darin resultieren sollte, dass RegEx kein Match findet. Warum findet RegEx
also ein Match?
Des Rätsels Lösung nennt sich Backtracking und ist wesentlicher Bestandteil von RegEx. In der Tat matcht RegEx durch den "Greedy"-Quantifier bis zum Ende durch
und findet dann kein "o" mehr. Allerdings ist es ebenfalls intelligent genug zu bemerken, dass, wenn man ein Zeichen weniger durch das
ein Match gefunden worden wäre. Die Engine springt also einen Character zurück und matcht dann noch das "o". Dieses Vehalten nennt sich Backtracking, und wird hier gebraucht:
Posessive:
Posessive Quantifiers stellen sich über das o.g. Backtracking und "verbieten" es. Das heißt, ist etwas einmal gematcht, dann war es das vorerst, egal was dem Token noch folgt. Ein posessive
Quantifier wird durch ein auf den Quantifier folgendes
String:
Pattern:
Es fällt auf: Wir haben 2 Mal das
werden sollen. Das zweite bezieht sich auf diesen Quantifier und macht ihn "posessive" - es verhindert Backtracking. Lässt obige Kombination nun also ein Match zu oder nicht? Nein.
Das Beispiel entspricht exakt dem der Backtracking-Section, wir haben nur ein einzelnes
Anzumerken ist, dass Posessive Quantifiers von .NET nicht unterstützt werden.
Zusammenfassend:
Greedy ist das Standardverhalten eines Quantifiers, matcht so viele Vorkommen wie möglich und beachtet das Pattern (Backtracking).
Lazy matcht so wenige Vorkommen wie möglich und beachtet ebenfalls das Pattern (Backtracking), wird mit
Posessive matcht so viele Vorkommen wie möglich, ignoriert dabei das Pattern (kein Backtracking), wird mit
Backtracking nennt man das Verhalten von RegEx, bei einem kein Match erzeugenden Pattern im String zurückzugehen um ein Match zu finden.
RegEx Advanced Patterns
In diesem Abschnitt möchte ich gezielt auf Patterns und Tokens eingehen, die man - gerade als RegEx-Anfänger - nicht zwingend kennt, die aber doch ganz nützlich sein können.
Dies sind keine ganzen Code-Snippets, mehr wichtige Grundbestandteile von RegEx. Ich werde die einzelnen Patterns auflisten und kurz erklären, ab und an möglicherweise an Beispielen,
ich möchte aktuell allerdings (noch) nicht auf jedes davon spezifisch eingehen. Das kommt dann vielleicht noch
Code Snippets
- folgen
Nützliche Tools zur Verwendung von RegEx
Hier noch ein paar Tools, deren Verwendung ich jedem nur ans Herz legen kann. Grundsätzlich ist es für RegEx wichtig, einen RegEx-Tester zu haben. Der beste nicht-.NET-Tester
ist meiner Meinung nach eindeutig regex101.com, der beste Online-.NET-Tester regexstorm.net/tester.
Ebenfalls wichtig ist die Verwendung von Online-Resourcen zum nachstöbern, teils also CheatSheets.
Was folgt
Auch wenn dieses Tutorial noch nicht komplett vollständig ist hoffe ich, dass ich einen kleinen Einblick in die tieferen Ebenen von
RegEx geben konnte. Ich werde dieses Tutorial in den nächsten Wochen Stück für Stück erweitern und es hoffentlich zu einer vertrauenswürdigen
und informativen Quelle für "Advanced RegEx" machen können.
Konstruktive Kritik ist immer erwünscht.
Grüße,
Nikx
ich möchte mit diesem Tutorial einen Einblick in die fortgeschrittenen Techniken von RegEx geben und denen, die bereits
grundlegende RegEx-Kenntnisse haben, mehr Möglichkeiten eröffnen.
Dieses Tutorial setzt das vorhandene Tutorial von @Link vorraus, dies ist hier zu finden:
RegEx Tutorial - Blutige Anfänger und Fortgeschrittene
Es ist möglich, dass sich beide Tutorials an manchen Stellen überschneiden, da ich nicht das gesamte Tutorial von Link mit
meinem abgleichen werde. Sollte das passieren, dann sind die behandelten Inhalte hier trotzdem gut aufgehoben
Dieses Tutorial arbeitet aktuell abstrakt - es gibt noch keinen direkten .NET Code, dieser folgt aber mit Sicherheit noch.
Die Interessierten werden sich trotzdem zurecht finden.
Los gehts!
Übersicht
- Grundlagen
- Wie funktioniert RegEx?
- Unterschiede von RegEx in verschiedenen Programmiersprachen
- RegEx Advanced Patterns
- Code-Snippets
- Nützliche Tools zur Verwendung von RegEx
Grundlagen
Dieses Tutorial setzt gewisse Kenntnisse und Grundlagen vorraus, wie in der Einleitung beschrieben. Man sollte beispielsweise wissen was ein Pattern ist, was ein Token
ist und wie man RegEx im .NET Framework verwendet. Ebenfalls wichtig ist es, die Grundlagen von RegEx zu kennen und anwenden zu können. Dass ein
.
jeden Characteraußer NewLine matcht sollte genauso klar sein wie die Nutzung von Gruppen und Quantifiern. Alle weiteren Grundkenntnisse von RegEx würde ich empfehlen, aber auch mit
dem o.g. Wissen sollte man sich in diesem Tutorial noch zurecht finden.
Wie funktioniert RegEx?
Erstmal möchte ich mich mit der Funktionsweise von RegEx befassen, denn die kann oft helfen, das eigene Pattern besser zu verstehen.
Die RegEx-Engine setzt 2 Cursors - ich nenne sie hier jetzt mal Cursors - einen an den Anfang des Patterns und einen an den Anfang des zu überprüfenden Strings.
Man kann sich diese Cursors wie die blinkende Linie in einem Textfeld vorstellen.
Nun beginnt RegEx damit, die Inhalte zu vergleichen. Es wird versucht, den ersten Character im String mit dem ersten Token des Patterns abzugleichen.
Natürlich gibt es hier noch Quantifier, so wie
+
oder *
, die überspringe ich hier der Einfachheit halber aber mal. Wenn der erste Character zum ersten Tokenim Pattern passt, dann springt der Cursor im Pattern und im Inhalt eins weiter, und versucht wieder, den Character nach dem Cursor mit dem Token nach dem Cursor im Pattern
abzugleichen. Schlägt dieser Test nun fehl, dann springt der Cursor im Inhalt wieder eine Stelle nach vorn, der Cursor im Pattern setzt sich jedoch zurück und beginnt wieder von
vorn. Anschaulich gestaltet:
String:
ac abc
Pattern:
a.c
Schritt 1:
Der Cursor sitzt sowohl im Pattern als auch im String auf Position 0, daher vor jeglichem Inhalt.
String:
|ac abc
Pattern:
|a.c
Schritt 2:
Die Engine versucht, den ersten Character im String mit dem ersten Token im Pattern abzugleichen. Dieser Test ist erfolgreich: Das erste Token im Pattern ist der Character a,
der erste Character im String ist ebenfalls ein a. Beide Cursor springen in der Position eins nach vorn.
String:
a|c abc
Pattern:
a|.c
Schritt 3:
Die Engine versucht erneut, den nächsten Character im String mit dem nächsten Token im Pattern abzugleichen. Wieder ist der Test erfolgreich: Das folgende Token
.
steht füralle Character außer NewLine, der folgende Character ist ein c, beides stimmt also überein, die Position des Cursors sprint wieder eins nach vorn.
String:
ac| abc
Pattern:
a.|c
Schritt 4:
Die Engine versucht beide Schritte erneut. Diesmal scheitert der Abgleich allerdings, wenn das folgende Token
c
, welches den Character c genau matcht, versucht, den im Stringauf das c folgende WhiteSpace zu matchen. Der Cursor im Pattern springt wieder auf Position 0, der Cursor im String wiederum eins weiter.
String:
ac |abc
Pattern:
|a.c
Weitere Schritte:
Der Rest sollte klar sein: Die Engine matcht wieder Token für Token und findet die darauffolgende Zeichenkette "abc", weil sie dem Pattern
a.c
entspricht.Unterschiede von RegEx in verschiedenen Programmiersprachen
Ein weiteres Thema, das oft Probleme bereitet, ist die Unterstützung von RegEx in verschiedenen Programmiersprachen. Die Ursache hierfür sind die verschiedenen RegEx-Engines, die jeweils
eben auch unterschiedliche Funktionalität bereitstellen. (siehe en.wikipedia.org/wiki/Comparis…egular_expression_engines)
Folglich kann ein und das selbe RegEx-Pattern in unterschiedlichen Programmiersprachen zu unterschiedlichen Ergebnissen führen. Auf die Gefahr hin, nicht völlig aktuelle Informationen zu verbreiten,
ziehe ich als Beispiel "possessive Quantifiers" heran, die meines Wissens nach von .NET nicht untersützt werden.
Abhilfe schaffen hier diverse Online-Tools, die beim Konvertieren helfen oder zumindest das Testen erleichtern, sodass man erkennt, welche Unterschiede das Pattern
in verschiedenen Programmiersprachen aufweist.
Greedy, Lazy, Backtracking, Posessive
Bevor ich zu den Advanced Patterns komme ist es wichtig, erst einmal zu verstehen was Quantifiers sind und wie sie funktionieren.
Grundsätzlich gibt es drei Varianten von Quantifiern, welche ich erst einmal erkläre. @'Link''s Tutorial beschreibt das Token
.*?
als"bis zum nächsten Vorkommen von", was so nicht völlig korrekt ist, bzw. einen falschen Eindruck vermitteln kann. Für Anfänger ist das auch eine sehr gute Beschreibung, ich möchte
das Ganze hier allerdings näher erläutern.
Greedy:
Greedy ist das Standardverhalten eines Quantifiers. Greedy heißt, dass der vorangehende Quantifier, also beispielsweise ein
*
, so viele Vorkommen matcht wie irgend möglich,sodass das Pattern ein Match ergibt. Nehmen wir also ein einfaches Beispiel:
String:
Hallo
Pattern:
.*
Das Pattern beschreibt ein beliebiges Zeichen, welches 0 oder mehrmals wiederholt wird. Der
*
-Quantifier ist standardmäßig greedy, was dazu führt, dass das gesamte Wort "Hallo"als Match des Patterns erkannt wird, denn wie oben erwähnt bewirkt ein "Greedy"-Quantifier, dass so viele Vorkommen wie möglich gematcht werden.
Lazy:
Lazy ist das genaue Gegenteil zum oben genannten "Greedy"-Quantifier. Es wird durch ein
?
gekennzeichnet. Um dies direkt zu verdeutlichen ziehen wir das selbe Beispiel erneut heran, verwenden diesmal aber ein ?
,um dem
*
-Quantifier mitzuteilen, dass er doch bitte "lazy" vorgehe. Trotz aller Erwartungen möchte ich hier anmerken, dass "Lazy" aus dem Englischen kommt und "faul" bedeutet, was aufdas Ergebnis des folgenden Tests schließen lässt:
String:
Hallo
Pattern:
.*?
Was wird nun also gematcht? Erstmal garnichts. Durch die Spezifizierung des Quantifiers geht dieser nun "lazy" vor, das heißt, er matcht so wenig wie möglich, achtet aber trotzdem
darauf, dass das Pattern gematcht werden kann. Hierdurch entsteht auch die Darstellung in @'Link''s Tutorial, "bis zum nächsten Vorkommen von", denn nehmen wir nun
Pattern:
.*?o
,so wird das gesamte Wort "Hallo" gematcht. Die Engine hat bemerkt, dass ein Match zustande kommt, wenn die ersten vier Buchstaben vom "Lazy"-Quantifier gematcht werden und somit
das Wort gematcht. Lazy matcht also so wenige Vorkommen wie möglich, beachtet aber das Pattern.
Backtracking:
Ein nicht weniger wichtiger Bestandteil von RegEx ist das Backtracking, was die Grundlage für "Posessive"-Quantifier bildet (folgen gleich).
Backtracking heißt, dass, wie bereits oben bei "Lazy" angedeutet, die Engine auf das Pattern an sich achtet. Man betrachte folgendes Beispiel:
String:
Hallo
Pattern:
.+o
Ich bitte dich - den Leser - einmal direkt darüber nachzudenken was die Engine in diesem Fall machen würde, und ob ein Match vorliegt oder nicht.
Wenn eine Meinung herrscht, dann kommt hier das Ergebnis:
Es existiert ein Match. Wenn jemand aber tatsächlich darüber nachgedacht hat, dann wird demjenigen aufgefallen sein, dass das laut obiger Definition
doch gar nicht passieren darf, denn der
+
-Quantifier ist doch standardmäßig "Greedy", und matcht so viele Zeichen wie möglich. Somit müsste er dochbis ans Ende matchen, um danach kein passendes "o" mehr zu finden, was eigentlich darin resultieren sollte, dass RegEx kein Match findet. Warum findet RegEx
also ein Match?
Des Rätsels Lösung nennt sich Backtracking und ist wesentlicher Bestandteil von RegEx. In der Tat matcht RegEx durch den "Greedy"-Quantifier bis zum Ende durch
und findet dann kein "o" mehr. Allerdings ist es ebenfalls intelligent genug zu bemerken, dass, wenn man ein Zeichen weniger durch das
.+
gematcht hätte,ein Match gefunden worden wäre. Die Engine springt also einen Character zurück und matcht dann noch das "o". Dieses Vehalten nennt sich Backtracking, und wird hier gebraucht:
Posessive:
Posessive Quantifiers stellen sich über das o.g. Backtracking und "verbieten" es. Das heißt, ist etwas einmal gematcht, dann war es das vorerst, egal was dem Token noch folgt. Ein posessive
Quantifier wird durch ein auf den Quantifier folgendes
+
gekennzeichnet (nicht zu verwechseln mit dem eigentlichen Quantifier +
, der ist standardmäßig immernoch greedy). Ein Beispiel:String:
Hallo
Pattern:
.++o
Es fällt auf: Wir haben 2 Mal das
+
-Token verwendet? Warum? Das erste von beiden ist der normale Quantifier, welcher besagt, dass ein oder mehr Vorkommen des vorrangehenden Tokens gematchtwerden sollen. Das zweite bezieht sich auf diesen Quantifier und macht ihn "posessive" - es verhindert Backtracking. Lässt obige Kombination nun also ein Match zu oder nicht? Nein.
Das Beispiel entspricht exakt dem der Backtracking-Section, wir haben nur ein einzelnes
+
hinzugefügt - die Engine kann nicht so vorgehen wie oben und findet das "o" nicht - kein Match.Anzumerken ist, dass Posessive Quantifiers von .NET nicht unterstützt werden.
Zusammenfassend:
Greedy ist das Standardverhalten eines Quantifiers, matcht so viele Vorkommen wie möglich und beachtet das Pattern (Backtracking).
Lazy matcht so wenige Vorkommen wie möglich und beachtet ebenfalls das Pattern (Backtracking), wird mit
?
verwendet.Posessive matcht so viele Vorkommen wie möglich, ignoriert dabei das Pattern (kein Backtracking), wird mit
+
verwendet.Backtracking nennt man das Verhalten von RegEx, bei einem kein Match erzeugenden Pattern im String zurückzugehen um ein Match zu finden.
RegEx Advanced Patterns
In diesem Abschnitt möchte ich gezielt auf Patterns und Tokens eingehen, die man - gerade als RegEx-Anfänger - nicht zwingend kennt, die aber doch ganz nützlich sein können.
Dies sind keine ganzen Code-Snippets, mehr wichtige Grundbestandteile von RegEx. Ich werde die einzelnen Patterns auflisten und kurz erklären, ab und an möglicherweise an Beispielen,
ich möchte aktuell allerdings (noch) nicht auf jedes davon spezifisch eingehen. Das kommt dann vielleicht noch
(?:Hallo)
- Non-Capture-Group: Wird nicht als Capture-Group gewertet.(?=Hallo)
- LookAhead: Prüft, ob die nachfolgende Zeichenfolge dem Pattern entspricht.(?<=Hallo)
- LookBehind: Prüft, ob die vorrangehende Zeichenfolge dem Pattern entspricht.(?!Hallo)
- Negativer LookAhead: Prüft, ob die nachfolgende Zeichenfolge nicht dem Pattern entspricht.(?<!Hallo)
- Negativer LookBehind: Prüft, ob die vorrangehende Zeichenfolge nicht dem Pattern entspricht.(?>A+)
- Atomic Group: Wenn die Engine die schließende Klammer verlassen hat ist ein Backtrack hier nicht mehr möglich.(?<named>Hallo)
- Named Group: Kann in den Groups per Name abgerufen werden.(.{2})\s\1)
- Backreference: \GroupNumber matcht den Inhalt, der von der Gruppe mit der Nummer 1 gecaptured wurde, hier zum Beispiel "Hi Hi", nicht jedoch "Hi Yo".(?(condition)then|else)
- Condition: If-Then-Else-Konstrukt, Verwendung meist im Zusammenhang mit anderen Gruppen (Gruppe 1 gesetzt? (?(1)then)
). Else ist optional.(?# Hi)
- Comments: Inline-Kommentare im RegEx.Code Snippets
- folgen
Nützliche Tools zur Verwendung von RegEx
Hier noch ein paar Tools, deren Verwendung ich jedem nur ans Herz legen kann. Grundsätzlich ist es für RegEx wichtig, einen RegEx-Tester zu haben. Der beste nicht-.NET-Tester
ist meiner Meinung nach eindeutig regex101.com, der beste Online-.NET-Tester regexstorm.net/tester.
Ebenfalls wichtig ist die Verwendung von Online-Resourcen zum nachstöbern, teils also CheatSheets.
Was folgt
- Cheat Sheets
- Beispiel-Projekt
- Code-Snippets
- Weitere Advanced Patterns
- Genauere Unterscheidungen zwischen .NET und anderen Sprachen
- Tipps
- .NET Code
Auch wenn dieses Tutorial noch nicht komplett vollständig ist hoffe ich, dass ich einen kleinen Einblick in die tieferen Ebenen von
RegEx geben konnte. Ich werde dieses Tutorial in den nächsten Wochen Stück für Stück erweitern und es hoffentlich zu einer vertrauenswürdigen
und informativen Quelle für "Advanced RegEx" machen können.
Konstruktive Kritik ist immer erwünscht.
Grüße,
Nikx
"Life isn't about winning the race. Life is about finishing the race and how many people we can help finish the race." ~Marc Mero
Nun bin ich also auch soweit: Keine VB-Fragen per PM! Es gibt hier ein Forum, verdammt!
Nun bin ich also auch soweit: Keine VB-Fragen per PM! Es gibt hier ein Forum, verdammt!
Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Nikx“ ()