"the" => The fat cat sat on the mat. @@ -81,7 +80,8 @@ Ein regulärer Ausdruck ist ein einfaches Muster von Zeichen, welches für eine [Teste den regulären Ausdruck](https://regex101.com/r/dmRygT/1) -Der reguläre Ausdruck `123` entspricht der Zeichenkette `123`. Dieser reguläre Ausdruck kann mit einer Zeichenkette verglichen werden, in dem jedes Zeichen in dem regulären Ausdruck nacheinander verglichen wird. Reguläre Ausdrücke sind normalerweise case sensitiv, Beachtung von Groß-/Kleinschreibung, so dass der Ausdruck `The` nicht mit der Zeichenkette `the` überein stimmen würde. +Der reguläre Ausdruck `123` entspricht der Zeichenkette `123`. Auf Übereinstimmung mit einer Zeichenkette wird er überprüft, indem jedes Zeichen in dem regulären Ausdruck nacheinander mit jedem Zeichen der Zeichenkette verglichen wird. +Reguläre Ausdrücke berücksichtigen normalerweise Groß- und Kleinschreibung, sodass etwa der Ausdruck `The` nicht mit der Zeichenkette `the` übereinstimmen würde."The" => The fat cat sat on the mat. @@ -89,45 +89,46 @@ 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 \|.| -|\|Entfernt das nachfolgende Zeichen. Dies ermöglicht es Zeichen zu blockieren[ ] ( ) { } . * + ? ^ $ \ || -|^|Ü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.| +|||Alternation, entspricht entweder dem Teilausdruck vor oder nach dem \|.| +|\|Escaped das nachfolgende Zeichen. Dies ermöglicht es Zeichen zu blockieren[ ] ( ) { } . * + ? ^ $ \ || +|^|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`.".ar" => The car parked in the garage.[Teste den regulären Ausdruck](https://regex101.com/r/xc9GkU/1) -## 2.2 Zeichensätze +## 2.2 Zeichenklasse -Zeichensätze werden auch als Zeichenklasse bezeichnet. Zeichensätze werden in eckige Klammern angegeben. Um den Bereich der Zeichen anzugeben ist ein Bindestrich zu verwenden. Die Reihenfolge des Bereiches in den 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`."[Tt]he" => The car parked in the garage.[Teste den regulären Ausdruck](https://regex101.com/r/2ITLQ4/1) -Ein Punkt in einem Zeichensatz bedeutet jedoch einen wörtlichen Punkt. Der reguläre Ausdruck `ar[.]` bedeutet: ein kleingeschriebenes Zeichen `a`, gefolgt vom kleingeschriebenen Buchstaben `r`, gefolgt von dem wörtlichen Zeichen Punkt `.`. +Ein Punkt in einer Zeichenklasse bedeutet, anders als sonst, einen wörtlichen Punkt. Der reguläre Ausdruck `ar[.]` bedeutet: ein kleingeschriebenes Zeichen `a`, gefolgt vom kleingeschriebenen Buchstaben `r`, gefolgt von einem Punkt-Zeichen `.`."ar[.]" => A garage is a good place to park a car. @@ -135,9 +136,9 @@ Ein Punkt in einem Zeichensatz bedeutet jedoch einen wörtlichen Punkt. Der regu [Teste den regulären Ausdruck](https://regex101.com/r/wL3xtE/1) -### 2.2.1 Invertierter Zeichensatz +### 2.2.1 Negierte Zeichenklasse -Im Allgemeinen stellt das Caret-Symbol `^` den Anfang einer Zeichenkette dar. Wenn es aber nach der öffnenden eckigen Klammer gesetzt wird, dann wird der Zeichensatz negiert. Als Beispiel, der reguläre Ausdruck `[^c]ar` bedeutet: jeder Buchstabe 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`."[^c]ar" => The car parked in the garage. @@ -145,19 +146,17 @@ Im Allgemeinen stellt das Caret-Symbol `^` den Anfang einer Zeichenkette dar. We [Teste den regulären Ausdruck](https://regex101.com/r/nNNlq3/1) -## 2.3 Repetitions +## 2.3 Wiederholungen -Following meta characters `+`, `*` or `?` are used to specify how many times a -subpattern can occur. These meta characters act differently in different -situations. +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 The Star +### 2.3.1 Stern -The symbol `*` matches zero or more repetitions of the preceding matcher. The -regular expression `a*` means: zero or more repetitions of preceding lowercase -character `a`. But if it appears after a character set or class then it finds -the repetitions of the whole character set. For example, der reguläre Ausdruck -`[a-z]*` means: any number of lowercase letters in a row. +Das Symbol `*` stimmt mit beliebig vielen Wiederholungen des vorhergehenden Teilausdrucks überein. Der Ausdruck `a*` heißt: +null, eins oder mehrere `a`s in Folge. Da sich der Stern auf Teilausdrücke bezieht, kann er auch bspw. hinter einer Zeichenklasse stehen +und stimmt dann mit beliebig vielen Zeichen aus der Klasse in Folge überein. Zum Beispiel bedeutet der Ausdruck `[a-z]*`: eine +beliebige Anzahl von Kleinbuchstaben in Folge."[a-z]*" => The car parked in the garage #21. @@ -165,12 +164,10 @@ the repetitions of the whole character set. For example, der reguläre Ausdruck [Teste den regulären Ausdruck](https://regex101.com/r/7m8me5/1) -The `*` symbol can be used with the meta character `.` to match any string of -characters `.*`. The `*` symbol can be used with the whitespace character `\s` -to match a string of whitespace characters. For example, the expression -`\s*cat\s*` means: zero or more spaces, followed by lowercase character `c`, -followed by lowercase character `a`, followed by lowercase character `t`, -followed by zero or more spaces. +Das `*`-Symbol kann zusammen mit dem Metazeichen `.` verwendet werden, um mit einer vollkommen beliebigen Zeichenkette übereinzustimmen `.*`. +Es kann auch mit der vordefinierten Zeichenklasse `\s` verwendet werden, um mit beliebig viel Leerraum (Leerzeichen, Tabulatoren, Zeilenumbrüchen) +übereinzustimmen. Der Ausdruck `\s*cat\*` heißt zum Beispiel: null oder mehrere Leerzeichen, gefolgt von dem Buchstaben `c`, gefolgt vom Buchstaben `a`, +gefolgt vom Buchstaben `t` und schließlich gefolgt von null oder mehreren Leerzeichen."\s*cat\s*" => The fat cat sat on the concatenation. @@ -178,12 +175,11 @@ followed by zero or more spaces. [Teste den regulären Ausdruck](https://regex101.com/r/gGrwuz/1) -### 2.3.2 The Plus +### 2.3.2 Plus -The symbol `+` matches one or more repetitions of the preceding character. For -example, der reguläre Ausdruck `c.+t` means: lowercase letter `c`, followed by -at least one character, followed by the lowercase character `t`. It needs to be -clarified that `t` is the last `t` in the sentence. +Das `+`-Symbol stimmt mit einer oder mehr Wiederholungen des vorhergehenden Teilausdrucks überein. Der reguläre Ausdruck +`c.+t` bedeutet: Buchstabe `c`, gefolgt von mindestens einem beliebigen Zeichen, gefolgt vom Buchstaben `t`. Das `t` ist dabei +das letzte `t` in der hier zu sehenden Übereinstimmung, wobei es hier auch weitere Übereinstimmungen gäbe (siehe "Teste den regulären Ausdruck")."c.+t" => The fat cat sat on the mat. @@ -191,13 +187,11 @@ clarified that `t` is the last `t` in the sentence. [Teste den regulären Ausdruck](https://regex101.com/r/Dzf9Aa/1) -### 2.3.3 The Question Mark +### 2.3.3 Fragezeichen -In regular expression the meta character `?` makes the preceding character -optional. This symbol matches zero or one instance of the preceding character. -For example, der reguläre Ausdruck `[T]?he` means: Optional the uppercase -letter `T`, followed by the lowercase character `h`, followed by the lowercase -character `e`. +In regulären Ausdrücken sorgt das Metazeichen `?` dafür, dass der vorhergehende Teilausdruck optional wird. +Somit stimmt es mit null oder einer Übereinstimmung des Teilausdrucks überein. +Zum Beispiel heißt der reguläre Ausdruck `[T]?he`: ein oder kein `T`, gefolgt von dem Buchstaben `h`, gefolgt von dem Buchstaben `e`."[T]he" => The car is parked in the garage. @@ -211,12 +205,11 @@ character `e`. [Teste den regulären Ausdruck](https://regex101.com/r/kPpO2x/1) -## 2.4 Braces +## 2.4 Geschweifte Klammern -In regular expression braces that are also called quantifiers are used to -specify the number of times that a character or a group of characters can be -repeated. For example, der reguläre Ausdruck `[0-9]{2,3}` means: Match at least -2 digits but not more than 3 ( characters in the range of 0 to 9). +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."[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0. @@ -224,9 +217,8 @@ repeated. For example, der reguläre Ausdruck `[0-9]{2,3}` means: Match at least [Teste den regulären Ausdruck](https://regex101.com/r/juM86s/1) -We can leave out the second number. For example, der reguläre Ausdruck -`[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma the -regular expression `[0-9]{3}` means: Match exactly 3 digits. +Die zweite Zahl kann ausgelassen werden. Somit heißt der Ausdruck `[0-9]{2,}`: zwei oder mehr Ziffern in Folge. +Wenn wir auch das Komma entfernen, heißt `[0-9]{3}`: genau drei Ziffern in Folge."[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0. @@ -240,16 +232,13 @@ regular expression `[0-9]{3}` means: Match exactly 3 digits. [Teste den regulären Ausdruck](https://regex101.com/r/Sivu30/1) -## 2.5 Capturing Group +## 2.5 Gruppierungen -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`."(c|g|p)ar" => The car is parked in the garage. @@ -257,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."(?:c|g|p)ar" => The car is parked in the garage. @@ -274,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."(T|t)he|car" => The car is parked in the garage. @@ -297,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 Escaping -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 `.`."(f|c|m)at\.?" => The fat cat sat on the mat. @@ -316,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`."(T|t)he" => The car is parked in the garage. @@ -349,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."(at\.)" => The fat cat. sat. on the mat. @@ -366,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 ("zurückschauen") und Lookahead ("vorausschauen") (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| -|? "(T|t)he(?=\sfat)" => The fat cat sat on the mat. @@ -420,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."(T|t)he(?!\sfat)" => The fat cat sat on the mat. @@ -436,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."(?<=(T|t)he\s)(fat|mat)" => The fat cat sat on the mat. @@ -449,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 `(? "(?<!(T|t)he\s)(cat)" => The cat sat on cat. @@ -462,26 +426,24 @@ 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 -The `i` modifier is used to perform case-insensitive matching. For example, the -regular expression `/The/gi` means: uppercase letter `T`, followed by lowercase -character `h`, followed by character `e`. And at the end of regular expression -the `i` flag tells der reguläre Ausdruck engine to ignore the case. As you can -see we also provided `g` flag because we want to search for the pattern in the -whole input string. +Der `i` Modifikator wird benutzt, um schreibungsunbhängige Übereinstimmungen zu finden. Zum Beispiel heißt der reguläre Ausdruck +`/The/gi`: großes `T`, gefolgt von `h`, dann `e`. Und am Ende des Ausdrucks ist der `i` Modifikator zu finden, welcher der Maschine +zu verstehen gibt, dass Groß- und Kleinschreibung ignoriert werden sollen. Wie zu sehen ist, wird auch der `g` Modifikator benutzt, +da wir die gesamte Eingabe nach dem Muster absuchen wollen."The" => The fat cat sat on the mat. @@ -495,13 +457,12 @@ whole input string. [Teste den regulären Ausdruck](https://regex101.com/r/ahfiuh/1) -### 5.2 Global search +### 5.2 Globale Suche -The `g` modifier is used to perform a global match (find all matches rather than -stopping after the first match). For example, der reguläre Ausdruck`/.(at)/g` -means: any character except new line, followed by lowercase character `a`, -followed by lowercase character `t`. Because we provided `g` flag at the end of -der reguläre Ausdruck now it will find all matches in the input string, not just the first one (which is the default behavior). +Der `g` Modifikator wird benutzt, um eine globale Suche durchzuführen (alle Übereinstimmungen finden, nicht nach der ersten aufhören). +Zum Beispiel heißt der reguläre Ausdruck `/.(at)/g`: ein beliebiges Zeichen (außer Zeilenumbruch), gefolgt von `a`, gefolgt von `t`. +Weil wir den `g` Modifikator angegeben haben, findet der reguläre Ausdruck nun alle Übereinstimmungen in der Eingabe, nicht nur die erste +(was das Standardverhalten ist)."/.(at)/" => The fat cat sat on the mat. @@ -515,15 +476,12 @@ der reguläre Ausdruck now it will find all matches in the input string, not jus [Teste den regulären Ausdruck](https://regex101.com/r/dO1nef/1) -### 5.3 Multiline +### 5.3 Mehrzeilig -The `m` modifier is used to perform a multi-line match. As we discussed earlier -anchors `(^, $)` are used to check if pattern is the beginning of the input or -end of the input string. But if we want that anchors works on each line we use -`m` flag. For example, der reguläre Ausdruck `/at(.)?$/gm` means: lowercase -character `a`, followed by lowercase character `t`, optionally anything except -new line. And because of `m` flag now regular expression engine matches pattern -at the end of each line in a string. +Der `m` Modifikator wird benutzt, um eine mehrzeilige Suche durchzuführen. Wie zuvor erwähnt werden Anker `(^, $)` genutzt, um zu überprüfen, +ob ein Muster dem Anfang oder dem Ende der Eingabe entspricht. Wenn wir stattdessen wollen, dass Anker zeilenweise funktionieren, nutzen wir den `m` +Modifikator. Zum Beispiel bedeutet der reguläre Ausdruck `/at(.)?$/gm`: `a`, gefolgt von `t`, dann optional ein beliebiges Zeichen außer +Zeilenumbruch. Wegen des `m` Modifikators wird das Muster nun auf das Ende jeder Zeile statt nur das Ende der gesamten Eingabe angewandt."/.at(.)?$/" => The fat @@ -541,9 +499,10 @@ at the end of each line in a string. [Teste den regulären Ausdruck](https://regex101.com/r/E88WE2/1) -## 6. Greedy vs lazy matching -By default regex will do greedy matching , means it will match as long as -possible. we can use `?` to match in lazy way means as short as possible +## 6. Gierige vs Faule Übereinstimmung + +Standardmäßig finden reguläre Ausdrücke Übereinstimmungen mit Gier (eng. *greed*), d.h. es wird nach den längsten Übereinstimmungen gesucht. +Mit `?` können wir faul (eng. *lazy*) suchen, d.h. es wird nach den kürzesten Übereinstimmungen gesucht."/(.*at)/" => The fat cat sat on the mat.@@ -557,14 +516,13 @@ possible. we can use `?` to match in lazy way means as short as possible [Teste den regulären Ausdruck](https://regex101.com/r/AyAdgJ/2) +## Beitragen -## Contribution +* Öffne pull requests mit Verbesserungen +* Diskutiere Ideen in issues +* Erzähl es anderen +* Gib Rückmeldung [](https://twitter.com/ziishaned) -* Open pull request with improvements -* Discuss ideas in issues -* Spread the word -* Reach out with any feedback [](https://twitter.com/ziishaned) - -## License +## Lizenz MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)