TheCloud/learn-regex
1
0
Fork 0
mirror of https://github.com/ziishaned/learn-regex.git synced 2025-08-23 11:56:10 -04:00
Code Issues Packages Projects Releases Wiki Activity

Continue work until flags

Browse Source
This commit is contained in:
JohnnyJayJay 2020-06-25 16:08:45 +02:00
parent 4fc2c9ed70
commit e21f70b7dc
1 changed files with 125 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

276
translations/README-de.md
View File

@ -46,14 +46,14 @@ Der abgebildete reguläre Ausdruck erlaubt bspw. folgende Eingaben `john_doe`, `
- [Basis Vergleiche](#1-basis-vergleiche)
- [Sonderzeichen](#2-sonderzeichen)
- [Punkt](#21-punkt)
- [Zeichensätze](#22-zeichensätze)
- [Invertierter Zeichensatz](#221-invertierter-zeichensatz)
- [Zeichenklasse](#22-zeichenklasse)
- [Negierte Zeichenklasse](#221-negierte-zeichenklasse)
- [Wiederholungen](#23-wiederholungen)
- [Stern *](#231-stern)
- [Plus +](#232-plus)
- [Fragezeichen ?](#233-fragezeichen)
- [Klammern {}](#24-klammern)
- [Zeichengruppen](#25-zeichengruppen)
- [Stern *](#231-der-stern)
- [Plus +](#232-das-plus)
- [Fragezeichen ?](#233-das-fragezeichen)
- [Geschweifte Klammern {}](#24-geschweifte-klammern)
- [Gruppierung](#25-gruppierung)
- [Alternation |](#26-alternation)
- [Auswertung von Sonderzeichen](#27-auswertung-von-sonderzeichen)
- [Anker](#28-anker)
@ -89,29 +89,30 @@ Der reguläre Ausdruck `123` entspricht der Zeichenkette `123`. Dieser reguläre
[Teste den regulären Ausdruck](https://regex101.com/r/1paXsy/1)
## 2. Sonderzeichen
## 2. Metazeichen
Sonderzeichen sind Bausteine von regulären Ausdrücken. Sonderzeichen stehen nicht für sich selbst, sondern werden in speziellen Fällen interpretiert. Einige Sonderzeichen haben eine besondere Bedeutung und sind innerhalb eckiger Klammern `[]`. Folgende Sonderzeichen sind möglich:
Metazeichen sind Bausteine von regulären Ausdrücken. Sie stehen nicht für sich selbst, sondern haben eine besondere Bedeutung und werden in spezieller Weise interpretiert.
Einige Metazeichen erhalten eine andere Bedeutung oder überhaupt erst eine besondere Bedeutung innerhalb eckiger Klammern `[]`. Folgende Metazeichen gibt es:
|Sonderzeichen|Beschreibung|
|Metazeichen|Beschreibung|
|:----:|----|
|.|Der Punkt entspricht jedem einzelnen Zeichen, außer einem Zeilenumbruch.|
|[ ]|Zeichen-Klasse, entspricht jedem Zeichen innerhalb der eckigen Klammern.|
|[^ ]|Negierte Zeichen-Klasse, entspricht jedem Zeichen welches nicht innerhalb der eckigen Klammern definiert ist.|
|*|Entspricht 0 oder mehr Wiederholungen der voran gestellten Zeichen.|
|+|Entspricht 1 oder mehr Wiederholungen der voran gestellten Zeichen.|
|?|Macht das vorhergehende Zeichen optional.|
|{n,m}|Klammern, entspricht mindestens "n", aber nicht mehr als "m" Wiederholungen des Zeichens.|
|(xyz)|Zeichengruppe, entspricht den Zeichen xyz in der exakten Reihenfolge.|
|||Alternation, entspricht entweder den Zeichen vor oder nach dem Sonderzeichen \|.|
|&#92;|Entfernt das nachfolgende Zeichen. Dies ermöglicht es Zeichen zu blockieren <code>[ ] ( ) { } . * + ? ^ $ \ &#124;</code>|
|^|Überprüft den Anfang einer Eingabe.|
|$|Überprüft das Ende einer Eingabe.|
|.|Der Punkt entspricht jedem einzelnen Zeichen, außer Zeilenumbrüchen.|
|[ ]|Zeichenklasse, entspricht jedem Zeichen innerhalb der eckigen Klammern.|
|[^ ]|Negierte Zeichenklasse, entspricht jedem Zeichen welches nicht innerhalb der eckigen Klammern definiert ist.|
|*|Entspricht 0 oder mehr Wiederholungen des vorhergehenden Teilausdrucks.|
|+|Entspricht 1 oder mehr Wiederholungen des vorhergehenden Teilausdrucks.|
|?|Macht den vorhergehenden Teilausdruck optional.|
|{n,m}|Entspricht mindestens "n", aber nicht mehr als "m" Wiederholungen des vorhergehenden Teilausdrucks.|
|(xyz)|Gruppierung, entspricht den Zeichen xyz in der exakten Reihenfolge.|
|&#124;|Alternation, entspricht entweder dem Teilausdruck vor oder nach dem \|.|
|&#92;|Escaped das nachfolgende Zeichen. Dies ermöglicht es Zeichen zu blockieren <code>[ ] ( ) { } . * + ? ^ $ \ &#124;</code>|
|^|Entspricht dem Anfang der Eingabe.|
|$|Entspricht dem Ende der Eingabe.|
## 2.1 Punkt
Der Punkt `.` ist die einfachste Möglichkeit von Sonderzeichen. Das Sonderzeichen `.`
entspricht jedem einzelnen Zeichen. Es wird kein Zeilenumbruch oder Enter-Zeichen gefunden. Als Beispiel, der reguläre Ausdruck `.ar` bedeutet: ein beliebiges Zeichen, gefolgt von dem Buchstaben `a`, gefolgt vom Buchstaben `r`.
Der Punkt `.` ist das einfachste Beispiel für ein Metazeichen. Er steht für jedes beliebiges Zeichen mit der Ausnahme von Zeilenumbrüchen/Enter-Zeichen.
Als Beispiel, der reguläre Ausdruck `.ar` bedeutet: ein beliebiges Zeichen, gefolgt von dem Buchstaben `a`, gefolgt vom Buchstaben `r`.
<pre>
".ar" => The <a href="#learn-regex"><strong>car</strong></a> <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@ -120,7 +121,7 @@ Der Punkt `.` ist die einfachste Möglichkeit von Sonderzeichen. Das Sonderzeich
## 2.2 Zeichenklasse
Zeichenklassen werden auch als Zeichenmengen oder -sätze bezeichnet. Sie werden in eckige Klammern definiert. Um eine Zeichenfolge wie `A-Z` oder `0-9` zu definieren, kann ein Bindestrich `-` verwendet werden. Die Reihenfolge sonstiger Zeichen innerhalb der eckigen Klammern spielt keine Rolle. Zum Beispiel bedeutet der reguläre Ausdruck `[Tt]he`: ein groß geschriebenes `T` oder ein kleingeschriebenes `t`, gefolgt vom Buchstaben `h` und weiter gefolgt vom Buchstaben `e`.
Zeichenklassen werden auch als Zeichenmengen oder -sätze bezeichnet (eng. *character set/class*). Sie werden in eckige Klammern definiert. Um eine Zeichenfolge wie `A-Z` oder `0-9` zu definieren, kann ein Bindestrich `-` verwendet werden. Die Reihenfolge sonstiger Zeichen innerhalb der eckigen Klammern spielt keine Rolle. Zum Beispiel bedeutet der reguläre Ausdruck `[Tt]he`: ein groß geschriebenes `T` oder ein kleingeschriebenes `t`, gefolgt vom Buchstaben `h` und weiter gefolgt vom Buchstaben `e`.
<pre>
"[Tt]he" => <a href="#learn-regex"><strong>The</strong></a> car parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@ -137,7 +138,7 @@ Ein Punkt in einer Zeichenklasse bedeutet, anders als sonst, einen wörtlichen P
### 2.2.1 Negierte Zeichenklasse
Im Allgemeinen stellt das Zirkumflex `^` den Anfang einer Zeichenkette dar. Wenn es aber nach der öffnenden eckigen Klammer gesetzt wird, dann wird die Zeichenklasse negiert. Als Beispiel, der reguläre Ausdruck `[^c]ar` bedeutet: ein beliebiges Zeichen außer `c`, gefolgt vom Buchstaben `a`, gefolgt vom Buchstaben `r`.
Im Allgemeinen stellt das Zirkumflex `^` den Anfang einer Zeichenkette dar. Wenn es aber nach der öffnenden eckigen Klammer gesetzt wird, dann wird die Zeichenklasse negiert (eng. *negated character set*). Als Beispiel, der reguläre Ausdruck `[^c]ar` bedeutet: ein beliebiges Zeichen außer `c`, gefolgt vom Buchstaben `a`, gefolgt vom Buchstaben `r`.
<pre>
"[^c]ar" => The car <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@ -147,7 +148,7 @@ Im Allgemeinen stellt das Zirkumflex `^` den Anfang einer Zeichenkette dar. Wenn
## 2.3 Wiederholungen
Die Metazeichen `+`, `*` und `?` bieten einen einfachen Weg, anzugeben, wie oft sich ein bestimmter Teilausdruck wiederholen soll. Sie gehören damit zu den sogenannten "Quantoren".
Die Metazeichen `+`, `*` und `?` bieten einen einfachen Weg, anzugeben, wie oft sich ein bestimmter Teilausdruck wiederholen soll. Sie gehören damit zu den sogenannten "Quantifizierern" (eng. *quantifier*).
Sie können sich je nach Situation unterschiedlich verhalten.
### 2.3.1 Der Stern
@ -206,7 +207,7 @@ Zum Beispiel heißt der reguläre Ausdruck `[T]?he`: ein oder kein `T`, gefolgt
## 2.4 Geschweifte Klammern
Geschweifte Klammern `{}` gehören wie die zuvor behandelten Metazeichen zu den Quantoren. Sie werden verwendet,
Geschweifte Klammern `{}` gehören wie die zuvor behandelten Metazeichen zu den Quantifizierern. Sie werden verwendet,
um genau anzugeben wie oft ein Teilausdruck minimal und maximal hintereinander übereinstimmen muss.
Zum Beispiel bedeutet der reguläre Ausdruck `[0-9]{2,3}`: Mindestens zwei, aber maximal drei Ziffern (Zeichenfolge 0-9) hintereinander.
@ -233,16 +234,11 @@ Wenn wir auch das Komma entfernen, heißt `[0-9]{3}`: genau drei Ziffern in Folg
## 2.5 Gruppierungen
Eine Gruppierung fasst eine Gruppe von Teilausdrücken in Klammern `(...)` zusammen.
A capturing group is a group of sub-patterns that is written inside Parentheses
`(...)`. Like as we discussed before that in regular expression if we put a quantifier
after a character then it will repeat the preceding character. But if we put quantifier
after a capturing group then it repeats the whole capturing group. For example,
der reguläre Ausdruck `(ab)*` matches zero or more repetitions of the character
"ab". We can also use the alternation `|` meta character inside capturing group.
For example, der reguläre Ausdruck `(c|g|p)ar` means: lowercase character `c`,
`g` or `p`, followed by character `a`, followed by character `r`.
Eine Gruppierung (eng. *capturing group*) fasst eine Gruppe von Teilausdrücken in Klammern `(...)` zusammen.
Eine Gruppierung selbst ist ebenfalls ein Teilausdruck, weshalb Quantoren wie `{}`, `*` oder `?` auf sie angewendet werden können.
Zum Beispiel stimmt der reguläre Ausdruck `(ab)*` mit null oder mehr Vorkommen von `a` und `b` hintereinander überein.
Auch das "Oder"-Metazeichen `|` kann innerhalb einer Gruppierung verwendet werden. Der reguläre Ausdruck `(c|g|p)ar` bedeutet:
kleines `c`, `g` oder `p`, gefolgt vom Buchstaben `a`, gefolgt vom Buchstaben `r`. Dies ist äquivalent zu `[cgp]ar`.
<pre>
"(c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@ -250,16 +246,16 @@ For example, der reguläre Ausdruck `(c|g|p)ar` means: lowercase character `c`,
[Teste den regulären Ausdruck](https://regex101.com/r/tUxrBG/1)
Note that capturing groups do not only match but also capture the characters for use in
the parent language. The parent language could be python or javascript or virtually any
language that implements regular expressions in a function definition.
Gruppierungen stimmen nicht nur mit Zeichenketten überein, sondern "merken" sich auch die übereinstimmenden Zeichen in der Gruppe für die Verwendung in der Elternsprache
(auch Rückwärtsreferenz genannt).
Die Elternsprache kann Python, JavaScript oder sonst irgendeine Sprache sein, die reguläre Ausdrücke implementiert.
### 2.5.1 Non-capturing group
A non-capturing group is a capturing group that only matches the characters, but
does not capture the group. A non-capturing group is denoted by a `?` followed by a `:`
within parenthesis `(...)`. For example, der reguläre Ausdruck `(?:c|g|p)ar` is similar to
`(c|g|p)ar` in that it matches the same characters but will not create a capture group.
### 2.5.1 Gruppierungen ohne Rückwärtsreferenz
Gruppierungen ohne Rückwärtsreferenz (eng. *non-capturing groups*) sind Gruppierungen, die nur mit den Zeichen übereinstimmen, diese aber nicht für spätere Verwendung zwischenspeichern.
Solche Gruppierungen werden mit einem `?`, gefolgt von einem `:` in Klammern `(...)` definiert.
Somit gleicht der reguläre Ausdruck `(?:c|g|p)ar` dem Ausdruck `(c|g|p)ar` in seiner Übereinstimmung mit den Zeichenketten, aber im Gegensatz erzeugt er keine Rückwärtsreferenz.
<pre>
"(?:c|g|p)ar" => The <a href="#learn-regex"><strong>car</strong></a> is <a href="#learn-regex"><strong>par</strong></a>ked in the <a href="#learn-regex"><strong>gar</strong></a>age.
@ -267,22 +263,19 @@ within parenthesis `(...)`. For example, der reguläre Ausdruck `(?:c|g|p)ar` is
[Teste den regulären Ausdruck](https://regex101.com/r/Rm7Me8/1)
Non-capturing groups can come in handy when used in find-and-replace functionality or
when mixed with capturing groups to keep the overview when producing any other kind of output.
See also [4. Lookaround](#4-lookaround).
Gruppierungen ohne Rückwärtsreferenz können für Finden-und-Ersetzen oder in Kombination mit normalen Gruppierungen nützlich sein, um den Überblick zu behalten,
wenn auf Basis der Übereinstimmungen eine Ausgabe erzeugt wird. Siehe auch [4. Lookaround](#4-lookaround).
## 2.6 Alternation
In a regular expression, the vertical bar `|` is used to define alternation.
Alternation is like an OR statement between multiple expressions. Now, you may be
thinking that character set and alternation works the same way. But the big
difference between character set and alternation is that character set works on
character level but alternation works on expression level. For example, the
regular expression `(T|t)he|car` means: either (uppercase character `T` or lowercase
`t`, followed by lowercase character `h`, followed by lowercase character `e`) OR
(lowercase character `c`, followed by lowercase character `a`, followed by
lowercase character `r`). Note that I put the parentheses for clarity, to show that either expression
in parentheses can be met and it will match.
In einem regulären Ausdruck wird der Trennstrich `|` verwendet, um Alternativen (eng. *alternation*) zu definieren.
Alternation ist wie ein "ODER" zwischen mehreren Teilausdrücken. Nun könnte man annehmen, dass
Zeichenklassen und Alternation auf die gleiche Art und Weise funktionieren. Aber der große Unterschied
zwischen diesen beiden ist, dass Zeichenklassen für einzelne Zeichen funktionieren, während für Alternationen
beliebige Teilausdrücke verwendet werden können. So heißt der reguläre Ausdruck `(T|t)he|car` beispielsweise:
Entweder ein großes `T` oder kleines `t`, dann der Buchstabe `h` gefolgt vom Buchstaben `e` ODER
`c`, gefolgt von `a`, gefolgt von `r`. Man beachte die Klammern, die zur Trennung der einen Alternation von der anderen
gesetzt wurden.
<pre>
"(T|t)he|car" => <a href="#learn-regex"><strong>The</strong></a> <a href="#learn-regex"><strong>car</strong></a> is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@ -290,18 +283,15 @@ in parentheses can be met and it will match.
[Teste den regulären Ausdruck](https://regex101.com/r/fBXyX0/1)
## 2.7 Escaping special character
## 2.7 Escape
Backslash `\` is used in regular expression to escape the next character. This
allows us to specify a symbol as a matching character including reserved
characters `{ } [ ] / \ + * . $ ^ | ?`. To use a special character as a matching
character prepend `\` before it.
Der Backslash `\` wird in regulären Ausdrücken verwendet, um die besondere Bedeutung des folgenden Zeichens aufzuheben (eng. *escape*) oder ihm eine besondere Bedeutung zu verleihen
(s. [Vordefinierte Zeichenklassen](#3-vordefinierte-zeichenklassen)).
Er erlaubt es, für andere Zwecke reservierte Zeichen wie die Metazeichen `{ } [ ] / \ + * . $ ^ | ?` als Literale, also wörtliche Übereinstimmungen zu nutzen.
Um mit einem besonderen Zeichen wortwörtlich übereinzustimmen, muss es auf ein `\` folgen.
For example, der reguläre Ausdruck `.` is used to match any character except
newline. Now to match `.` in an input string der reguläre Ausdruck
`(f|c|m)at\.?` means: lowercase letter `f`, `c` or `m`, followed by lowercase
character `a`, followed by lowercase letter `t`, followed by optional `.`
character.
Der reguläre Ausdruck `.` zum Beispiel wird benutzt, um mit einem beliebigen Zeichen übereinzustimmen.
Der Ausdruck `(f|c|m)at\.?` hebt diese Bedeutung auf: `f`, `c` oder `m`, gefolgt von `a`, gefolgt von `t`, schließlich gefolgt von einem optionalen `.`.
<pre>
"(f|c|m)at\.?" => The <a href="#learn-regex"><strong>fat</strong></a> <a href="#learn-regex"><strong>cat</strong></a> sat on the <a href="#learn-regex"><strong>mat.</strong></a>
@ -309,24 +299,19 @@ character.
[Teste den regulären Ausdruck](https://regex101.com/r/DOc5Nu/1)
## 2.8 Anchors
## 2.8 Anker
In regular expressions, we use anchors to check if the matching symbol is the
starting symbol or ending symbol of the input string. Anchors are of two types:
First type is Caret `^` that check if the matching character is the start
character of the input and the second type is Dollar `$` that checks if matching
character is the last character of the input string.
In regulären Audrücken werden Anker (eng. *anchor*) verwendet, um zu überprüfen, ob der Teilausdruck mit dem
Anfang oder dem Ende der Teilausgabe übereinstimmt. Es gibt zwei Arten von Ankern: das Zirkumflex `^`
stimmt mit dem Anfang, das Dollarzeichen `$` mit dem Ende der Eingabe überein.
### 2.8.1 Caret
### 2.8.1 Zirkumflex
Caret `^` symbol is used to check if matching character is the first character
of the input string. If we apply the following regular expression `^a` (if a is
the starting symbol) to input string `abc` it matches `a`. But if we apply
regular expression `^b` on above input string it does not match anything.
Because in input string `abc` "b" is not the starting symbol. Let's take a look
at another regular expression `^(T|t)he` which means: uppercase character `T` or
lowercase character `t` is the start symbol of the input string, followed by
lowercase character `h`, followed by lowercase character `e`.
Das Zirkumflex `^` (eng. *caret*) wird benutzt um zu überprüfen, ob der Teilausdruck mit dem Anfang der Zeichenkette übereinstimmt.
Wenn wir den regulären Ausdruck `^a` auf die Eingabe `abc` anwenden, stimmt er mit `a` überein.
Aber wenn wir auf die gleiche Eingabe den Ausdruck `^b` anwenden, gibt es keine Übereinstimmungen, weil in der Zeichenkette `abc` kein "b"
am Anfang steht. Schauen wir uns einen anderen Ausdruck an: `^(T|t)he`. Dieser bedeutet: kleines `t` oder großes `T` am Anfang der Eingabe,
gefolgt von `h`, gefolgt von `e`.
<pre>
"(T|t)he" => <a href="#learn-regex"><strong>The</strong></a> car is parked in <a href="#learn-regex"><strong>the</strong></a> garage.
@ -342,10 +327,8 @@ lowercase character `h`, followed by lowercase character `e`.
### 2.8.2 Dollar
Dollar `$` symbol is used to check if matching character is the last character
of the input string. For example, regular expression `(at\.)$` means: a
lowercase character `a`, followed by lowercase character `t`, followed by a `.`
character and the matcher must be end of the string.
Das Dollarzeichen `$` wird benutzt um zu überprüfen, ob der Teilausdruck mit dem Ende der Zeichenkette übereinstimmt.
Der reguläre Ausdruck `(at\.)$` etwa bedeutet: `a`, gefolgt von `t` und dann `.` am Ende der Eingabe.
<pre>
"(at\.)" => The fat c<a href="#learn-regex"><strong>at.</strong></a> s<a href="#learn-regex"><strong>at.</strong></a> on the m<a href="#learn-regex"><strong>at.</strong></a>
@ -359,53 +342,47 @@ character and the matcher must be end of the string.
[Teste den regulären Ausdruck](https://regex101.com/r/t0AkOd/1)
## 3. Shorthand Character Sets
## 3. Vordefinierte Zeichenklassen
Regular expression provides shorthands for the commonly used character sets,
which offer convenient shorthands for commonly used regular expressions. The
shorthand character sets are as follows:
Reguläre Ausdrücke haben Kürzel für die am häufigsten benötigten Zeichenklassen, was viele Ausdrücke vereinfacht und kürzer macht.
Das sind die vordefinierten Zeichenklassen:
|Shorthand|Description|
|:----:|----|
|.|Any character except new line|
|\w|Matches alphanumeric characters: `[a-zA-Z0-9_]`|
|\W|Matches non-alphanumeric characters: `[^\w]`|
|\d|Matches digit: `[0-9]`|
|\D|Matches non-digit: `[^\d]`|
|\s|Matches whitespace character: `[\t\n\f\r\p{Z}]`|
|\S|Matches non-whitespace character: `[^\s]`|
|.|Beliebiges Zeichen außer Zeilenumbruch|
|\w|Stimmt mit alphanumerischen Zeichen überein: `[a-zA-Z0-9_]`|
|\W|Stimmt mit nicht-alphanumerischen Zeichen überein: `[^\w]`|
|\d|Stimmt mit Ziffern überein: `[0-9]`|
|\D|Stimmt mit Zeichen, die keine Ziffern sind überein: `[^\d]`|
|\s|Stimmt mit Leerraum überein: `[\t\n\f\r\p{Z}]`|
|\S|Stimmt mit allem außer Leerraum überein: `[^\s]`|
## 4. Lookaround
Lookbehind and lookahead (also called lookaround) are specific types of
***non-capturing groups*** (Used to match the pattern but not included in matching
list). Lookarounds are used when we have the condition that this pattern is
preceded or followed by another certain pattern. For example, we want to get all
numbers that are preceded by `$` character from the following input string
`$4.44 and $10.88`. We will use following regular expression `(?<=\$)[0-9\.]*`
which means: get all the numbers which contain `.` character and are preceded
by `$` character. Following are the lookarounds that are used in regular
expressions:
Lookbehind ("nach hinten sehend") und Lookahead ("vorausschauend") (auch Lookaround ("Umsehen") genannt) sind besondere Arten von **Gruppierungen ohne Rückwärtsreferenz**
(zur Erinnerung: das sind Gruppierungen, die zwar mit dem Muster übereinstimmen, aber sich die Übereinstimmung nicht "merken").
Sie werden in Situationen verwendet, wo wir ein Muster einfangen wollen, dem andere Muster folgen oder vorhergehen.
Zum Beispiel wollen wir alle Zahlen aus der Zeichenkette `$4.44 and $10.88`, vor denen ein Dollarzeichen `$` steht. Wir benutzen dafür den folgenden regulären Audruck:
`(?<=\$)[0-9.]*`. Das heißt: Stimme mit allen Zeichenketten überein, die Ziffern `0-9` oder Punkte `.` enthalten und die einem Dollarzeichen `$` folgen.
|Symbol|Description|
Das sind die Lookarounds, die es gibt:
|Symbol|Name|
|:----:|----|
|?=|Positive Lookahead|
|?!|Negative Lookahead|
|?<=|Positive Lookbehind|
|?<!|Negative Lookbehind|
|?=|Positiver Lookahead|
|?!|Negativer Lookahead|
|?<=|Positiver Lookbehind|
|?<!|Negativer Lookbehind|
### 4.1 Positive Lookahead
### 4.1 Positiver Lookahead
The positive lookahead asserts that the first part of the expression must be
followed by the lookahead expression. The returned match only contains the text
that is matched by the first part of the expression. To define a positive
lookahead, parentheses are used. Within those parentheses, a question mark with
equal sign is used like this: `(?=...)`. Lookahead expression is written after
the equal sign inside parentheses. For example, der reguläre Ausdruck
`(T|t)he(?=\sfat)` means: optionally match lowercase letter `t` or uppercase
letter `T`, followed by letter `h`, followed by letter `e`. In parentheses we
define positive lookahead which tells regular expression engine to match `The`
or `the` which are followed by the word `fat`.
Ein positiver Lookahead versichert, dass der Teilausdruck vor dem Lookahead von dem Lookahead-Teilausdruck gefolgt wird.
Das Ergebnis der Übereinstimmung beinhaltet dabei nur den Teilausdruck vor dem Lookahead.
Klammern werden genutzt, um positive Lookaheads zu definieren. Nach der öffnenden Klammer müssen ein Fragezeichen und ein Gleichheitszeichen
stehen: `(?=...)`. Der Lookahead-Ausdruck wird nach dem Gleichheitszeichen notiert.
Zum Beispiel bedeutet der reguläre Ausdruck `(T|t)he(?=\sfat)`: kleines `t` oder großes `T`, dann ein `h`, dann ein `e`. Der positive Lookahead in den Klammern
ist eine zusätzliche Bedingung, die dafür sorgt, dass der Ausdruck nur mit `the` oder `The` übereinstimmt, welches von einem Leerzeichen und den Buchstaben
`f`, `a` und `t` gefolgt wird.
<pre>
"(T|t)he(?=\sfat)" => <a href="#learn-regex"><strong>The</strong></a> fat cat sat on the mat.
@ -413,15 +390,11 @@ or `the` which are followed by the word `fat`.
[Teste den regulären Ausdruck](https://regex101.com/r/IDDARt/1)
### 4.2 Negative Lookahead
### 4.2 Negativer Lookahead
Negative lookahead is used when we need to get all matches from input string
that are not followed by a pattern. Negative lookahead is defined same as we define
positive lookahead but the only difference is instead of equal `=` character we
use negation `!` character i.e. `(?!...)`. Let's take a look at the following
regular expression `(T|t)he(?!\sfat)` which means: get all `The` or `the` words
from input string that are not followed by the word `fat` precedes by a space
character.
Negative Lookaheads werden verwendet, um alle Übereinstimmungen in einer Zeichenkette zu bekommen, auf die **nicht** ein bestimmtes Muster folgt.
Ein Negativer Lookahead wird wie ein positiver Lookahead definiert, nur dass statt einem Gleichheitszeichen ein Ausrufezeichen `!` benutzt wird, d.h.
`(?!...)`. Aus dem regulären Ausdruck `(T|t)he(?!\sfat)` folgt somit: alle `The` oder `the`, auf die **kein** Leerzeichen und das Wort `fat` folgt, stimmen überein.
<pre>
"(T|t)he(?!\sfat)" => The fat cat sat on <a href="#learn-regex"><strong>the</strong></a> mat.
@ -429,12 +402,11 @@ character.
[Teste den regulären Ausdruck](https://regex101.com/r/V32Npg/1)
### 4.3 Positive Lookbehind
### 4.3 Positiver Lookbehind
Positive lookbehind is used to get all the matches that are preceded by a
specific pattern. Positive lookbehind is denoted by `(?<=...)`. For example, the
regular expression `(?<=(T|t)he\s)(fat|mat)` means: get all `fat` or `mat` words
from input string that are after the word `The` or `the`.
Positive Lookbehinds werden verwendet, um alle Übereinstimmungen in einer Zeichenkette zu bekommen, denen ein bestimmtes Muster vorhergeht.
Postive Lookbehinds werden mit `(?<=...)` notiert. Der reguläre Ausdruck `(?<=(T|t)he\s)(fat|mat)` zum Beispiel bedeutet: alle `fat` oder `mat`,
die nach `The ` oder `the ` kommen, stimmen überein.
<pre>
"(?<=(T|t)he\s)(fat|mat)" => The <a href="#learn-regex"><strong>fat</strong></a> cat sat on the <a href="#learn-regex"><strong>mat</strong></a>.
@ -442,12 +414,11 @@ from input string that are after the word `The` or `the`.
[Teste den regulären Ausdruck](https://regex101.com/r/avH165/1)
### 4.4 Negative Lookbehind
### 4.4 Negativer Lookbehind
Negative lookbehind is used to get all the matches that are not preceded by a
specific pattern. Negative lookbehind is denoted by `(?<!...)`. For example, the
regular expression `(?<!(T|t)he\s)(cat)` means: get all `cat` words from input
string that are not after the word `The` or `the`.
Negative Lookbehinds werden verwendet, um alle Übereinstimmungen in einer Zeichenkette zu bekommen, denen **nicht** ein bestimmtes Muster vorhergeht.
Negative Lookbehinds werden mit `(?<!...)` notiert. Der reguläre Ausdruck `(?<!(T|t)he\s)(cat)` zum Beispiel bedeutet: alle `cat`, die nicht nach
`The ` oder `the ` kommen, stimmen überein.
<pre>
"(?&lt;!(T|t)he\s)(cat)" => The cat sat on <a href="#learn-regex"><strong>cat</strong></a>.
@ -455,19 +426,22 @@ string that are not after the word `The` or `the`.
[Teste den regulären Ausdruck](https://regex101.com/r/8Efx5G/1)
## 5. Flags
## 5. Modifikatoren
Flags are also called modifiers because they modify the output of a regular
expression. These flags can be used in any order or combination, and are an
integral part of the RegExp.
Modifikatoren (eng. *flags* oder *modifiers*) verändern die Ausgabe eines regulären Ausdrucks. Sie können in beliebiger Kombination oder Reihenfolge
genutzt werden und sind ein integraler Bestandteil regulärer Ausdrücke.
|Flag|Description|
|Modifikator|Beschreibung|
|:----:|----|
|i|Case insensitive: Sets matching to be case-insensitive.|
|g|Global Search: Search for a pattern throughout the input string.|
|m|Multiline: Anchor meta character works on each line.|
|i|Schreibungsunabhängig: Unterschiede bei Groß- und Kleinschreibung in den Mustern werden ignoriert.|
|g|Globale Suche: Die Suche geht durch die gesamte Eingabe.|
|m|Mehrzeilig: Anker-Metazeichen funktionieren für Anfang/Ende jeder Zeile.|
### 5.1 Case Insensitive
### 5.1 Schreibungsunabhängig
Der `i` Modifikator wird benutzt, um schreibungsunbhängige Übereinstimmungen zu finden. Zum Beispiel heißt der reguläre Ausdruck
`/The/gi`: großes `T`
The `i` modifier is used to perform case-insensitive matching. For example, the
regular expression `/The/gi` means: uppercase letter `T`, followed by lowercase