|
|
| (108 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt) |
| Zeile 1: |
Zeile 1: |
| Mustervergleiche und Reguläre Ausdrücke
| | '''Regular Expression''' (Regulärer Ausdruck) - Sprache zur Beschreibung von Zeichenketten |
|
| |
|
| == Einführung == | | == Beschreibung == |
| | Ein '''regulärer Ausdruck''' (''regular expression'','''RegExp''' oder '''Regular expression''') ist eine [http://de.wikipedia.org/wiki/Zeichenkette Zeichenkette], die der Beschreibung von Zeichenketten mithilfe bestimmter [http://de.wikipedia.org/wiki/Syntax syntaktischer] Regeln dient. |
|
| |
|
| Ein '''regulärer Ausdruck''' ([http://de.wikipedia.org/wiki/Englische_Sprache englisch] ''regular expression'', abgekürzt '''RegExp''' oder '''Regex''') ist in der [http://de.wikipedia.org/wiki/Informatik Informatik] eine [http://de.wikipedia.org/wiki/Zeichenkette Zeichenkette], die der Beschreibung von [http://de.wikipedia.org/wiki/Menge_%28Mathematik%29 Mengen] von Zeichenketten mit Hilfe bestimmter [http://de.wikipedia.org/wiki/Syntax syntaktischer] Regeln dient.
| | * Reguläre Ausdrücke finden vorwiegend in der [http://de.wikipedia.org/wiki/Softwareentwicklung Softwareentwicklung] Verwendung; für fast alle [http://de.wikipedia.org/wiki/Programmiersprache Programmiersprachen] existieren [http://de.wikipedia.org/wiki/Implementierung Implementierungen]. |
| | * Eine Regular Expression (im folgenden mit RE abgekürzt) ist so etwas wie ein Suchmuster, das dazu dient, komplizierte Suchanfragen mit wenigen Zeichen zu formulieren. |
| | * Die Syntax ist standardisiert und wird von verschiedenen Programmen verstanden, z. B. sed, egrep, expr, perl. Das interpretierende Programm versucht, aus einer größeren Zeichenmenge (i.A. einer Zeile) eine Teilmenge zu finden, die zu der RE "passt". |
| | * Oft gibt es mehrere Teilmengen, die passen. In diesem Fall wird die größte Teilmenge als Ergebnis verwendet. |
| | * [http://de.wikipedia.org/wiki/Pattern_Matching Pattern Matching] |
| | * Reguläre Ausdrücke können als Filterkriterien in der Textsuche verwendet werden, indem der Text mit dem Muster des regulären Ausdrucks abgeglichen wird. |
| | * So ist es beispielsweise möglich, alle Wörter aus einer Wortliste herauszusuchen, die mit ''S'' beginnen und auf ''D'' enden – ohne die dazwischenliegenden Buchstaben und wahlweise deren Anzahl explizit vorgeben zu müssen. |
|
| |
|
| Reguläre Ausdrücke finden vor allem in der [http://de.wikipedia.org/wiki/Softwareentwicklung Softwareentwicklung] Verwendung; für fast alle [http://de.wikipedia.org/wiki/Programmiersprache Programmiersprachen] existieren [http://de.wikipedia.org/wiki/Implementierung Implementierungen].
| | === Zeichenketten finden === |
| | * Eine häufige Anwendung regulärer Ausdrücke besteht darin, spezielle Zeichenketten in einer Menge von Zeichenketten zu finden. |
| | * Die im Folgenden angegebene Beschreibung ist eine (oft benutzte) Konvention, um Konzepte wie ''Zeichenklasse'', ''Quantifizierung'', ''Verknüpfung'' und ''Zusammenfassen'' konkret zu realisieren. |
| | * [http://de.wikipedia.org/wiki/Metazeichen Metazeichen] |
| | * Hierbei wird ein regulärer Ausdruck aus den Zeichen des zugrunde liegenden Alphabets in Kombination mit den [http://de.wikipedia.org/wiki/Metazeichen Metazeichen] <tt>[ ] ( ) { } | ? + - * ^ $ \ .</tt> (teilweise kontextabhängig) gebildet. |
| | * Die Meta-Eigenschaft eines Zeichens kann durch ein vorangestelltes [http://de.wikipedia.org/wiki/Backslash Backslash]-Zeichen aufgehoben werden. |
| | * Alle übrigen Zeichen des Alphabets stehen für sich selbst. |
| | * [http://de.wikipedia.org/w/index.php?title=Textersetzung&action=edit&redlink=1 Textersetzungen] |
| | * Ein weiteres Beispiel für den Einsatz als [http://de.wikipedia.org/wiki/Filtrierung Filter] ist die Möglichkeit, komplizierte [http://de.wikipedia.org/w/index.php?title=Textersetzung&action=edit&redlink=1 Textersetzungen] durchzuführen. |
| | * Neben den aufgeführten analytischen Aufgaben können reguläre Ausdrücke auch verwendet werden, um Mengen von Wörtern zu erzeugen, ohne jedes Wort einzeln angeben zu müssen. |
| | * So lässt sich beispielsweise ein Ausdruck angeben, der bei einer gegebenen (Maximal-)Zeichenanzahl alle denkbaren Zeichenkombinationen („Wörter“) erzeugt, die mit ''S'' beginnen und mit ''D'' enden. Auf diese Weise können etwa [http://de.wikipedia.org/wiki/Brute-Force systematisch] [http://de.wikipedia.org/wiki/E-Mail-Adresse E-Mail-Adressen] (vor allem der Teil vor dem [http://de.wikipedia.org/wiki/@ @]) für den [http://de.wikipedia.org/wiki/Spam Spam]-Versand [http://de.wikipedia.org/wiki/Codegenerator generiert] werden. |
|
| |
|
| Eine Regular Expression (im folgenden mit RE abgekürzt) ist so etwas wie ein Suchmuster, das dazu dient, komplizierte Suchanfragen mit wenigen Zeichen zu formulieren.
| | === Erweiterungen === |
| | * Die meisten heutigen Implementierungen unterstützen Erweiterungen wie zum Beispiel Rückwärtsreferenzen ''(backreferences).'' Hierbei handelt es sich nicht mehr um reguläre Ausdrücke im Sinne der theoretischen Informatik, denn die so erweiterten Ausdrücke beschreiben nicht mehr notwendigerweise Sprachen vom Typ 3 der [http://de.wikipedia.org/wiki/Chomsky-Hierarchie Chomsky-Hierarchie]. |
| | * Die folgenden Syntaxbeschreibungen beziehen sich auf die Syntax der gängigen Implementierungen mit Erweiterungen, sie entsprechen also nur teilweise der obigen Definition aus der theoretischen Informatik. |
|
| |
|
| Die Syntax ist standardisiert und wird von verschiedenen Programmen verstanden, z.B. sed, egrep, expr, perl. Das interpretierende Programm versucht, aus einer größeren Zeichenmenge (i.A. einer Zeile) eine Teilmenge zu finden, die zu der RE "passt".
| | === Anwendung regulärer Ausdrücke === |
| | [http://de.wikipedia.org/wiki/Ken_Thompson Ken Thompson] nutzte diese Notation in den 1960ern, um ''qed'' (eine Vorgängerversion des Unix-Editors [http://de.wikipedia.org/wiki/Ed ed]) zu bauen und später das Werkzeug [http://de.wikipedia.org/wiki/Grep grep] zu schreiben. |
|
| |
|
| Oft gibt es mehrere Teilmengen, die passen. In diesem Fall wird die größte Teilmenge als Ergebnis verwendet.
| | Seither implementieren viele Programme und Bibliotheken von Programmiersprachen Funktionen, um ''reguläre Ausdrücke'' zum Suchen und Ersetzen von Zeichenketten zu nutzen. |
|
| |
|
| [http://de.wikipedia.org/wiki/Pattern_Matching Pattern Matching]
| | ''' Beispiele für Regular expressionp-Implementierungen ''' |
| | |
| Reguläre Ausdrücke können als Filterkriterien in der Textsuche verwendet werden, indem der Text mit dem Muster des regulären Ausdrucks abgeglichen wird.
| |
| | |
| So ist es beispielsweise möglich, alle Wörter aus einer Wortliste herauszusuchen, die mit ''S'' beginnen und auf ''D'' enden – ohne die dazwischenliegenden Buchstaben und wahlweise deren Anzahl explizit vorgeben zu müssen.
| |
| | |
| '''Zeichenketten finden'''
| |
| | |
| Eine häufige Anwendung regulärer Ausdrücke besteht darin, spezielle Zeichenketten in einer Menge von Zeichenketten zu finden. Die im Folgenden angegebene Beschreibung ist eine (oft benutzte) Konvention, um Konzepte wie ''Zeichenklasse'', ''Quantifizierung'', ''Verknüpfung'' und ''Zusammenfassen'' konkret zu realisieren.
| |
| | |
| [http://de.wikipedia.org/wiki/Metazeichen Metazeichen]
| |
| | |
| Hierbei wird ein regulärer Ausdruck aus den Zeichen des zugrunde liegenden Alphabets in Kombination mit den [http://de.wikipedia.org/wiki/Metazeichen Metazeichen] <tt>[ ] ( ) { } | ? + - * ^ $ \ .</tt> (teilweise kontextabhängig) gebildet. Die Meta-Eigenschaft eines Zeichens kann durch ein vorangestelltes [http://de.wikipedia.org/wiki/Backslash Backslash]-Zeichen aufgehoben werden. Alle übrigen Zeichen des Alphabets stehen für sich selbst.
| |
| | |
| [http://de.wikipedia.org/w/index.php?title=Textersetzung&action=edit&redlink=1 Textersetzungen]
| |
| | |
| Ein weiteres Beispiel für den Einsatz als [http://de.wikipedia.org/wiki/Filtrierung Filter] ist die Möglichkeit, komplizierte [http://de.wikipedia.org/w/index.php?title=Textersetzung&action=edit&redlink=1 Textersetzungen] durchzuführen. Neben den aufgeführten analytischen Aufgaben können reguläre Ausdrücke auch verwendet werden, um Mengen von Wörtern zu erzeugen, ohne jedes Wort einzeln angeben zu müssen.
| |
| | |
| So lässt sich beispielsweise ein Ausdruck angeben, der bei einer gegebenen (Maximal-)Zeichenanzahl alle denkbaren Zeichenkombinationen („Wörter“) erzeugt, die mit ''S'' beginnen und mit ''D'' enden. Auf diese Weise können etwa [http://de.wikipedia.org/wiki/Brute-Force-Methode systematisch] [http://de.wikipedia.org/wiki/E-Mail-Adresse E-Mail-Adressen] (vor allem der Teil vor dem [http://de.wikipedia.org/wiki/@ @]) für den [http://de.wikipedia.org/wiki/Spam Spam]-Versand [http://de.wikipedia.org/wiki/Codegenerator generiert] werden.
| |
| | |
| '''Erweiterungen'''
| |
| | |
| Die meisten heutigen Implementierungen unterstützen Erweiterungen wie zum Beispiel Rückwärtsreferenzen ''(backreferences).'' Hierbei handelt es sich nicht mehr um reguläre Ausdrücke im Sinne der theoretischen Informatik, denn die so erweiterten Ausdrücke beschreiben nicht mehr notwendigerweise Sprachen vom Typ 3 der [http://de.wikipedia.org/wiki/Chomsky-Hierarchie Chomsky-Hierarchie].
| |
| | |
| Die folgenden Syntaxbeschreibungen beziehen sich auf die Syntax der gängigen Implementierungen mit Erweiterungen, sie entsprechen also nur teilweise der obigen Definition aus der theoretischen Informatik.
| |
| | |
| ==== Anwendung regulärer Ausdrücke ====
| |
| | |
| [http://de.wikipedia.org/wiki/Ken_Thompson Ken Thompson] nutzte diese Notation in den 1960ern, um ''qed'' (eine Vorgängerversion des Unix-Editors [http://de.wikipedia.org/wiki/Ed ed]) zu bauen und später das Werkzeug [http://de.wikipedia.org/wiki/Grep grep] zu schreiben.
| |
| | |
| Seither implementieren viele Programme und Bibliotheken von Programmiersprachen Funktionen, um ''reguläre Ausdrücke'' zum Suchen und Ersetzen von Zeichenketten zu nutzen.
| |
| | |
| ===== Beispiele für Regexp-Implementierungen =====
| |
| {| class="wikitable sortable" | | {| class="wikitable sortable" |
| |- | | |- |
| | | '''Programme''' | | | | '''Programme''' |
| | colspan="2" | '''Bibliotheken der Programmiersprachen ''' | | | colspan="2" | '''Bibliotheken der Programmiersprachen ''' |
| |- | | |- |
| | | * [http://de.wikipedia.org/wiki/Sed_%28Unix%29 sed] | | || |
| | * [http://de.wikipedia.org/wiki/Sed_%28Unix%29 sed] |
| * [http://de.wikipedia.org/wiki/Grep grep] | | * [http://de.wikipedia.org/wiki/Grep grep] |
| * [http://de.wikipedia.org/wiki/Emacs emacs] | | * [http://de.wikipedia.org/wiki/Emacs emacs] |
| * vi | | * vi |
| | | || |
| | | * [http://de.wikipedia.org/wiki/Perl_%28Programmiersprache%29 Perl] | | * [http://de.wikipedia.org/wiki/Perl_%28Programmiersprache%29 Perl] |
| * [http://de.wikipedia.org/wiki/C_%28Programmiersprache%29 C] | | * [http://de.wikipedia.org/wiki/C_%28Programmiersprache%29 C] |
| * [http://de.wikipedia.org/wiki/Java_%28Programmiersprache%29 Java] | | * [http://de.wikipedia.org/wiki/Java_%28Programmiersprache%29 Java] |
| * [http://de.wikipedia.org/wiki/Python_%28Programmiersprache%29 Python] | | * [http://de.wikipedia.org/wiki/Python_%28Programmiersprache%29 Python] |
| | | || |
| | | * [http://de.wikipedia.org/wiki/PHP PHP] | | * [http://de.wikipedia.org/wiki/PHP PHP] |
| * [http://de.wikipedia.org/wiki/Ruby_%28Programmiersprache%29 Ruby] | | * [http://de.wikipedia.org/wiki/Ruby_%28Programmiersprache%29 Ruby] |
| * [http://de.wikipedia.org/wiki/.NET .NET]-Framework | | * [http://de.wikipedia.org/wiki/.NET .NET]-Framework |
| | |} |
|
| |
|
| |-
| |
| |}
| |
| Auch die [http://de.wikipedia.org/wiki/Textverarbeitung Textverarbeitung] und die [http://de.wikipedia.org/wiki/Tabellenkalkulation Tabellenkalkulation] des Office-Paketes [http://de.wikipedia.org/wiki/OpenOffice.org OpenOffice.org] bieten die Möglichkeit, mit regulären Ausdrücken im Text zu suchen. | | Auch die [http://de.wikipedia.org/wiki/Textverarbeitung Textverarbeitung] und die [http://de.wikipedia.org/wiki/Tabellenkalkulation Tabellenkalkulation] des Office-Paketes [http://de.wikipedia.org/wiki/OpenOffice.org OpenOffice.org] bieten die Möglichkeit, mit regulären Ausdrücken im Text zu suchen. |
|
| |
|
| ==== Unterschiede der Implementierungen ==== | | === Implementierungen === |
| | | {| class="wikitable options" |
| * In Programmiersprachen haben sich überwiegend die [http://de.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions Perl Compatible Regular Expressions] (PCRE) durchgesetzt, die sich an der Umsetzung in Perl orientieren.
| |
| | |
| ===== [http://de.wikipedia.org/wiki/Portable_Operating_System_Interface POSIX.2] unterscheidet =====
| |
| | |
| * '''Basic Regular Expressions (BRE)'''
| |
| ** „grundlegende“ reguläre Ausdrücke
| |
| * '''Extended Regular Expressions (ERE)'''
| |
| ** „erweiterte“ reguläre Ausdrücke
| |
| | |
| Einige Programme, zum Beispiel der [http://de.wikipedia.org/wiki/Texteditor Texteditor] [http://de.wikipedia.org/wiki/Vim Vim], bieten die Möglichkeit, zwischen verschiedenen Regexp-Syntaxen hin- und herzuschalten.
| |
| | |
| == Sonderzeichen in Suchmustern == | |
| | |
| {| class="wikitable sortable" | |
| |-
| |
| | | <tt>'''.'''</tt>
| |
| | | Steht für ein beliebiges *einzelnes* Zeichen, mit Ausnahme des Zeilenendezeichens
| |
| |-
| |
| | | <tt>'''*'''</tt>
| |
| | | * Steht für eine beliebige (auch leere) Menge des einzelnen Zeichens vor dem Sternchen.
| |
| * Das vorangehende Zeichen kann auch ein regulärer Ausdruck sein.
| |
| * Beispielsweise steht .* für eine beliebige Anzahl eines beliebigen Zeichens
| |
| | |
| |-
| |
| | | <tt>'''^'''</tt>
| |
| | | Übereinstimmung, wenn der folgende Ausdruck am Zeilenanfang steht
| |
| |-
| |
| | | <tt>'''$'''</tt>
| |
| | | Übereinstimmung, wenn der vorhergehende Azusdruck am Zeilenende steht
| |
| |-
| |
| | | <tt>'''\'''</tt>
| |
| | | Schaltet die Sonderbedeutung des nachfolgenden Zeichens ab
| |
| |-
| |
| | | <tt>'''[ ]'''</tt>
| |
| | | * Steht für *ein* beliebiges Zeichen aus der eingeklammerten Gruppe.
| |
| * Mit dem Bindestrich kann man einen Bereich aufeinanderfolgender Zeichen auswählen ([a-e]).
| |
| * Ein Zirkumflex (^) wirkt als Umkehrung: [^a-z] erfaßt alle Zeichen, die keine Kleinbuchstaben sind.
| |
| * Ein Bindestrich oder eine schließende eckige Klammer am Listenanfang werden als Teil der Liste angesehen, alle anderen Sonderzeichen verlieren in der Liste ihre Bedeutung
| |
| | |
| |-
| |
| | | <tt>'''( )'''</tt>
| |
| | | * Speichert das Muster zwischen \( und \) in einem speziellen Puffer.
| |
| * In einer Zeile können bis zu neun solcher Puffer belegt werden.
| |
| * In Substitutionen können sie über die Zeichenfolgen \1 bis \9 wieder benutzt werden
| |
| | |
| |-
| |
| | | <tt>'''{ }'''</tt>
| |
| | | * Steht für den Vorkommensbereich des unmittelbar vorhergehenden Zeichens.
| |
| * \{n\} bezieht sich auf genau n Vorkommen,
| |
| * \{n,\} auf mindestens n Vorkommen und
| |
| * \{n,m\} auf eine beliebige Anzahl von Vorkommen zwischen n und m.
| |
| * Dabei müssen n und m im Bereich zwischen 0 und 256 liegen
| |
| | |
| |-
| |
| | | <tt>'''<\'''</tt>
| |
| | |
| | | Steht für ein Zeichen am Anfang (<) oder am Ende (>) eines Wortes
| |
| |-
| |
| | | <tt>'''+'''</tt>
| |
| | | Steht für ein oder mehrere Vorkommen des vorhergehenden regulären Ausdrucks = \{1,\}
| |
| |-
| |
| | | <tt>'''?'''</tt>
| |
| | | Steht für kein oder ein Vorkommen des vorhergehenden Ausdrucks. = \{0,1\}
| |
| |-
| |
| | | <tt>'''|'''</tt>
| |
| | | Übereinstimmung, wenn entweder der vorhergehende oder der nachfolgende reguläre Ausdruck übereinstimmen
| |
| |-
| |
| | | <tt>'''( )'''</tt>
| |
| | | Steht für die eingeschlossene Gruppe von regulären Ausdrücken
| |
| | |
| |-
| |
| |}
| |
| === Trennzeichen ===
| |
| | |
| When entering a regular expression in a programming language, they may be represented as a usual string literal, hence usually quoted; this is common in C, Java, and Python for instance, where the regular expression <tt>re</tt> is entered as <tt>"re"</tt>. However, they are often written with slashes as [http://en.wikipedia.org/wiki/Delimiter delimiters], as in <tt>/re/</tt> for the regular expression <tt>re</tt>.
| |
| | |
| This originates in ed, where <tt>/</tt> is the editor command for searching, and an expression <tt>/re/</tt> can be used to specify a range of lines (matching the pattern), which can be combined with other commands on either side, most famously <tt>g/re/p</tt> as in [http://en.wikipedia.org/wiki/Grep grep] ("global regex print").
| |
| | |
| A similar convention is used in [http://en.wikipedia.org/wiki/Sed sed], where search and replace is given by <tt>s/regexp/replacement/</tt> and patterns can be joined with a comma to specify a range of lines as in <tt>/re1/,/re2/</tt>.
| |
| | |
| This notation is particularly well-known due to its use in [http://en.wikipedia.org/wiki/Perl Perl], where it forms part of the syntax distinct from normal string literals. In some cases, such as sed and Perl, alternative delimiters can be used to avoid collision with contents, and to avoid having to escape occurrences of the delimiter character in the contents.
| |
| | |
| For example, in sed the command <tt>s,/,X,</tt> will replace a <tt>/</tt> with an <tt>X</tt>, using commas as delimiters.
| |
| | |
| === Standards ===
| |
| | |
| The [http://en.wikipedia.org/wiki/Institute_of_Electrical_and_Electronics_Engineers IEEE] [http://en.wikipedia.org/wiki/POSIX POSIX] standard has three sets of compliance: BRE, ERE, and SRE for Basic, Extended, and Simple Regular Expressions. SRE is [http://en.wikipedia.org/wiki/Deprecation deprecated], in favor of BRE, as both provide backward compatibility. The subsection below covering the ''character classes'' applies to both BRE and ERE.
| |
| | |
| BRE and ERE work together. ERE adds <tt>?</tt>, <tt>+</tt>, and <tt>|</tt>, and it removes the need to escape the metacharacters <tt>( )</tt> and <tt>{ }</tt>, which are ''required'' in BRE. Furthermore, as long as the POSIX standard syntax for regular expressions is adhered to, there can be, and often is, additional syntax to serve specific (yet POSIX compliant) applications.
| |
| | |
| Although POSIX.2 leaves some implementation specifics undefined, BRE and ERE provide a "standard" which has since been adopted as the default syntax of many tools, where the choice of BRE or ERE modes is usually a supported option.
| |
| | |
| For example, GNU grep has the following options: "grep -E" for ERE, and "grep -G" for BRE (the default), and "grep -P" for Perl regular expressions.
| |
| | |
| [http://en.wikipedia.org/wiki/Perl Perl] regular expressions have become a de facto standard, having a rich and powerful set of atomic expressions. Perl has no "basic" or "extended" levels, where the <tt>( )</tt> and <tt>{ }</tt> may or may not have literal meanings.
| |
| | |
| They are always metacharacters, as they are in "extended" mode for POSIX. To get their ''literal'' meaning, you escape them. Other metacharacters are known to be literal or symbolic based on context alone.
| |
| | |
| Perl offers much more functionality: "lazy" regular expressions, [http://en.wikipedia.org/wiki/Backtracking backtracking], named capture groups, and [http://en.wikipedia.org/wiki/Recursion_%28computer_science%29 recursive] patterns, all of which are powerful additions to POSIX BRE/ERE.
| |
| | |
| ==== POSIX Basic Regular Expression (BRE) ====
| |
| | |
| Bei der Standard Basic Regular Syntax (BRE) müssen die Metazeichen<tt>( )</tt> und <tt>{ }</tt> maskiert werden, <tt>\(\)</tt> und <tt>\{\}</tt>, bei der Extended Regular Syntax (ERE) nicht.
| |
| | |
| {| class="wikitable sortable"
| |
| |-
| |
| | | '''Metacharacter'''
| |
| | | '''Description'''
| |
| |-
| |
| | | <tt>'''.'''</tt>
| |
| | | Matches any single character (many applications exclude [http://en.wikipedia.org/wiki/Newline newlines], and exactly which characters are considered newlines is flavor-, character-encoding-, and platform-specific, but it is safe to assume that the line feed character is included). Within POSIX bracket expressions, the dot character matches a literal dot. For example, <tt>a.c</tt> matches "abc", etc., but <tt>[a.c]</tt> matches only "a", ".", or "c".
| |
| |-
| |
| | | <tt>'''[ ]'''</tt>
| |
| | | A bracket expression. Matches a single character that is contained within the brackets. For example, <tt>[abc]</tt> matches "a", "b", or "c". <tt>[a-z]</tt> specifies a range which matches any lowercase letter from "a" to "z". These forms can be mixed: <tt>[abcx-z]</tt> matches "a", "b", "c", "x", "y", or "z", as does <tt>[a-cx-z]</tt>.
| |
| | |
| The <tt>-</tt> character is treated as a literal character if it is the last or the first (after the <tt>^</tt>, if present) character within the brackets: <tt>[abc-]</tt>, <tt>[-abc]</tt>. Note that backslash escapes are not allowed. The <tt>]</tt> character can be included in a bracket expression if it is the first (after the <tt>^</tt>) character: <tt>[]abc]</tt>.
| |
| |-
| |
| | | <tt>'''[^ ]'''</tt>
| |
| | | Matches a single character that is not contained within the brackets. For example, <tt>[^abc]</tt> matches any character other than "a", "b", or "c". <tt>[^a-z]</tt> matches any single character that is not a lowercase letter from "a" to "z". Likewise, literal characters and ranges can be mixed.
| |
| |-
| |
| | | <tt>'''^'''</tt>
| |
| | | Matches the starting position within the string. In line-based tools, it matches the starting position of any line.
| |
| |-
| |
| | | <tt>'''$'''</tt>
| |
| | | Matches the ending position of the string or the position just before a string-ending newline. In line-based tools, it matches the ending position of any line.
| |
| |-
| |
| | | <tt>'''( )'''</tt>
| |
| | | Defines a marked subexpression. The string matched within the parentheses can be recalled later (see the next entry, <tt>\n</tt>). A marked subexpression is also called a block or capturing group. BRE mode requires <tt>\( \)</tt>.
| |
| |-
| |
| | | <tt>'''\n'''</tt>
| |
| | | Matches what the nth marked subexpression matched, where n is a digit from 1 to 9. This construct is vaguely defined in the POSIX.2 standard. Some tools allow referencing more than nine capturing groups.
| |
| |-
| |
| | | <tt>'''*'''</tt>
| |
| | | Matches the preceding element zero or more times. For example, <tt>ab*c</tt> matches "ac", "abc", "abbbc", etc. <tt>[xyz]*</tt> matches "", "x", "y", "z", "zx", "zyx", "xyzzy", and so on. <tt>(ab)*</tt> matches "", "ab", "abab", "ababab", and so on.
| |
| |-
| |
| | | <tt>'''{m,n}'''</tt>
| |
| | | Matches the preceding element at least m and not more than n times. For example, <tt>a{3,5}</tt> matches only "aaa", "aaaa", and "aaaaa". This is not found in a few older instances of regular expressions. BRE mode requires <tt>\{m,n\}</tt>.
| |
| | |
| |-
| |
| |}
| |
| ====== Beispiele ======
| |
| | |
| .at * matches any three-character string ending with "at", including "hat", "cat", and "bat".
| |
| | |
| [hc]at * matches "hat" and "cat".
| |
| | |
| [^b]at * matches all strings matched by <tt>.at</tt> except "bat".
| |
| | |
| [^hc]at * matches all strings matched by <tt>.at</tt> other than "hat" and "cat".
| |
| | |
| ^[hc]at * matches "hat" and "cat", but only at the beginning of the string or line.
| |
| | |
| [hc]at$ * matches "hat" and "cat", but only at the end of the string or line.
| |
| | |
| \[.\] * matches any single character surrounded by "[" and "]" since the brackets are escaped, for example: "[a]" and "[b]".
| |
| | |
| s.* * matches any number of characters preceded by s, for example: "saw" and "seed".
| |
| | |
| ==== POSIX Extended Regular Expression (ERE) ====
| |
| | |
| The meaning of metacharacters [http://en.wikipedia.org/wiki/Escape_sequence escaped] with a backslash is reversed for some characters in the POSIX Extended Regular Expression (ERE) syntax.
| |
| | |
| With this syntax, a backslash causes the metacharacter to be treated as a literal character. So, for example, <tt>\( \)</tt> is now <tt>( )</tt> and <tt>\{ \}</tt> is now <tt>{ }</tt>. Additionally, support is removed for <tt>\''n''</tt> backreferences and the following metacharacters are added:
| |
| | |
| {| class="wikitable sortable"
| |
| |-
| |
| | | '''Metacharacter'''
| |
| | | '''Description'''
| |
| |-
| |
| | | <tt>'''?'''</tt>
| |
| | | Matches the preceding element zero or one time.
| |
| | |
| For example, <tt>ab?c</tt> matches only "ac" or "abc".
| |
| |-
| |
| | | <tt>'''+'''</tt>
| |
| | | Matches the preceding element one or more times.
| |
| | |
| For example, <tt>ab+c</tt> matches "abc", "abbc", "abbbc", and so on, but not "ac".
| |
| |-
| |
| | | <tt>'''|'''</tt>
| |
| | | The choice (also known as alternation or set union) operator matches either the expression before or the expression after the operator.
| |
| | |
| For example, <tt>abc|def</tt> matches "abc" or "def".
| |
| | |
| |-
| |
| |}
| |
| ====== Beispiele ======
| |
| | |
| [hc]+at * matches "hat", "cat", "hhat", "chat", "hcat", "cchchat", and so on, but not "at".
| |
| | |
| [hc]?at * matches "hat", "cat", and "at".
| |
| | |
| [hc]*at * matches "hat", "cat", "hhat", "chat", "hcat", "cchchat", "at", and so on.
| |
| | |
| cat|dog * matches "cat" or "dog".
| |
| | |
| ===== Beispiel =====
| |
| | |
| '''$ echo Hallo | grep [[:upper:]ab]'''
| |
| '''Ha'''llo* trifft Großbuchstaben und die Kleinbuchstaben “a” und “b”
| |
| | |
| ==== Weitere Beispiele ====
| |
| Ein wichtiges Element der REs ist das Platzhalterzeichen ".". Es ist Platzhalter für jedes beliebige Zeichen, also numerische, alphabetische oder Sonderzeichen. Ein "." steht für ein einziges beliebiges Zeichen.
| |
| | |
| echo "ihr Name ist Mayer, sein Name ist Meier" | sed -n '/Ma.er/p'
| |
| * die RE "Ma.er" passt auf "Mayer", daher ist die Suchbedingung erfüllt.
| |
| * Nicht die Ergebnismenge "Mayer", sondern die ganz Zeile wird ausgeben.
| |
| | |
| echo "ihr Name ist Mayer, sein Name ist Meier" | sed -n '/M..er/p'
| |
| * "Mayer" und "Meier" passen, es gibt also 2 Ergebnismengen.
| |
| * Wie im ersten Fall wird die ganze Zeile ausgegeben.
| |
| * Die Anzahl der Ergebnismengen erfährt man nicht.
| |
| | |
| Die Anzahl der Platzhalterzeichen lässt sich weiter spezifizieren. Leider müssen die geschweiften Klammern, "+" und "?" escaped werden durch Voranstellung des "\".
| |
| | |
| .\{n\} # n mal "."
| |
| .\{,n\} # 0-n mal "."
| |
| .\{n,\} # n bis unendlich mal "."
| |
| .\{m,n\} # m-n mal "."
| |
| .* # 0 bis unendlich mal "."
| |
| .\+ # 1 bis unendlich mal "."
| |
| .\? # 0-1 mal "."
| |
| | |
| echo "ihr Name ist Mayer, sein Name ist Meier" | sed -n '/M.\{2\}er/p'
| |
| | |
| * die RE "M..er" ist identisch mit "M.\{2\}er"
| |
| * die Klammern müssen "escaped" werden, damit sed sie richtig interpretiert: \{...\}
| |
| | |
| echo "ihr Name ist Mayer, sein Name ist Meier" | sed -n '/M.*er/p'*
| |
| | |
| * Es gibt mehrere Ergebnismengen:
| |
| # Mayer
| |
| # Mayer, sein Name ist Meier
| |
| # Meier
| |
| | |
| * Es gilt (2), weil es die größte Ergebnismenge ist
| |
| | |
| Unabhängig davon, ob keine, eine oder mehrere Ergebnismengen gefunden werden, wird immer die gesamte Zeile ausgegeben. Wenn man nur die effektive (größte) Ergebnismenge sehen will, muss man egrep mit der "-o" Option zu Hilfe nehmen
| |
| | |
| echo "ihr Name ist Mayer, sein Name ist Meier" | egrep -o 'M.*er'
| |
| | |
| * Die RE steht anders als bei sed innerhalb von einfachen Hochkommta.
| |
| * -o bewirkt, dass nur die effektive Ergebnismenge angezeigt wird
| |
| | |
| Die effektive Ergebnismenge lässt sich auch durch den s-Befehl herausbekommen:
| |
| | |
| echo "ihr Name ist Mayer, sein Name ist Meier" | sed 's/M.*er/X/g'
| |
| | |
| * Beim Suchen & Ersetzen wird die effektive Ergebnismenge durch "X" ersetzt
| |
| | |
| ==== Der einfachste Reguläre Ausdruck ====
| |
| | |
| Die einfachste RE besteht aus einem Suchstring ohne weitere Deskriptoren, also z.B. dem Wort "Mayer".
| |
| | |
| echo "ihr Name ist Mayer, sein Name ist Meier" | sed 's/Mayer/X/g'
| |
| * "Mayer" ist effektive Ergebnismenge und wird durch "X" ersetzt
| |
| | |
| Beachten Sie, dass die folgende RE ein anderes Ergebnis liefert:
| |
| | |
| echo "ihr Name ist Mayer, sein Name ist Meier" | sed 's/.'''*Mayer.*/X/g''''
| |
| * diese RE trifft auf die gesamte Zeile zu, nicht nur auf "Mayer"!
| |
| | |
| === Mustererkennung ===
| |
| | |
| In der folgenden Tabelle wird gezeigt, in welchen Unix-Tools welche Zeichen zur Verfügung stehen.
| |
| | |
| {| class="wikitable sortable"
| |
| |-
| |
| | |
| |
| | | '''ed'''
| |
| | | '''ex'''
| |
| | | '''sed'''
| |
| | | '''awk'''
| |
| | | '''grep'''
| |
| | | '''egrep'''
| |
| | |
| |
| |-
| |
| | | <tt>'''.'''</tt>
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | Ein beliebiges Zeichen
| |
| |-
| |
| | | <tt>'''*'''</tt>
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | Kein, ein oder mehrere Vorkommen des vorhergehenden Ausdrucks.
| |
| |-
| |
| | | <tt>'''^'''</tt>
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | Zeilenanfang
| |
| |-
| |
| | | <tt>'''$'''</tt>
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | Zeilenende
| |
| |-
| |
| | | <tt>'''\'''</tt>
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | Hebt die Sonderbedeutung des folgenden Zeichens auf.
| |
| |-
| |
| | | <tt>'''[ ]'''</tt>
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | Ein Zeichen aus der Gruppe
| |
| |-
| |
| | | <tt>'''[^ ]'''</tt>
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | Kein Zeichen aus der Gruppe
| |
| |-
| |
| | | <tt>'''( )'''</tt>
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | |
| |
| | |
| |
| | |
| |
| | | Speichert das Muster zur späteren Wiederholung.
| |
| |-
| |
| | | <tt>'''{ }'''</tt>
| |
| | | X
| |
| | |
| |
| | | X
| |
| | |
| |
| | | X
| |
| | |
| |
| | | Vorkommensbereich
| |
| |-
| |
| | | <tt>'''<'''</tt>
| |
| | | X
| |
| | | X
| |
| | |
| |
| | |
| |
| | |
| |
| | |
| |
| | | Wortanfang
| |
| |-
| |
| | | <tt>'''>'''</tt>
| |
| | | X
| |
| | | X
| |
| | |
| |
| | |
| |
| | |
| |
| | |
| |
| | | Wortende
| |
| |-
| |
| | | <tt>'''+'''</tt>
| |
| | |
| |
| | |
| |
| | |
| |
| | | X
| |
| | |
| |
| | | X
| |
| | | Ein oder mehrere Vorkommen des vorhergehenden Ausdrucks.
| |
| |-
| |
| | | <tt>'''?'''</tt>
| |
| | |
| |
| | |
| |
| | |
| |
| | | X
| |
| | |
| |
| | | X
| |
| | | Kein oder ein Vorkommen des vorhergehenden Ausdrucks.
| |
| |-
| |
| | | <tt>'''|'''</tt>
| |
| | |
| |
| | |
| |
| | |
| |
| | | X
| |
| | |
| |
| | | X
| |
| | | Trennt die für die Übereinstimmung verfügbaren Alternativen.
| |
| |-
| |
| | | <tt>'''( )'''</tt>
| |
| | |
| |
| | |
| |
| | |
| |
| | | X
| |
| | |
| |
| | | X
| |
| | | Gruppiert Ausdrücke für den Test.
| |
| | |
| |-
| |
| |}
| |
| == Zeichenliterale ==
| |
| | |
| Diejenigen Zeichen, die direkt (wörtlich, literal) übereinstimmen müssen, werden auch direkt notiert.
| |
| | |
| Je nach System gibt es auch Möglichkeiten, das Zeichen durch den * Oktalcode (<tt>'''\''ooo'''''</tt>)
| |
| * Hexadezimalcode (<tt>'''\''ooo'''''</tt> bzw. <tt>'''\x''hh'''''</tt>) oder die
| |
| * hexadezimale Unicode-Position (<tt>'''\u''hhhh'''''</tt>)
| |
| | |
| anzugeben.
| |
| | |
| === Ein beliebiges Zeichen ===
| |
| | |
| Ein Punkt (<tt>'''.'''</tt>) bedeutet, dass an seinem Platz ein (fast) beliebiges Zeichen stehen kann.
| |
| | |
| Die meisten RegExp-Implementierungen sehen standardmäßig [http://de.wikipedia.org/wiki/Newline Newline] (Zeilenumbruch) nicht als beliebiges Zeichen an.
| |
| | |
| In einigen Programmen kann mithilfe des sogenannten ''Single-Line''-Modifiers <tt>s</tt> (zum Beispiel in <tt>/foo.bar/s</tt>) ebendies erreicht werden.
| |
| | |
| == Listen (bracket expressions) ==
| |
| | |
| Erwartet man an einer Stelle innerhalb des Regulären Ausdrucks nicht ein ganz bestimmtes Zeichen, sondern nur eines aus einer spezifischen Liste, so kann man dies durch eine sogenannte ''bracket expression'' ausdrücken.
| |
| | |
| Die Liste der Zeichen, aus der das zu findende Zeichen stammen soll, wird dazu einfach in eckigen Klammern "<tt>[]</tt>" angegeben. Um beispielsweise alle Buchstaben "a", egal ob groß oder klein, zu finden, verwendet man folgenden regulären Ausdruck: "<tt>[Aa]</tt>"
| |
| | |
| Möchte man alle Zeichen finden, die nicht in der Liste stehen, die Liste also negieren, so muss das erste Zeichen in der Liste ein Caret "<tt>^</tt>" sein. Ein regulärer Ausdruck der Form "<tt>[^Aa]</tt>" passt also auf alle Zeichen, die weder ein großes noch ein kleines "a" sind.
| |
| | |
| ==== Kurzes Beispiel ====
| |
| | |
| [Aa]lpha* findet alle Textstücke "Alpha" und "alpha".
| |
| | |
| ==== Range Expression ====
| |
| | |
| Um die Listen der ''bracket extensions'' kompakt darstellen zu können, werden ''range expressions'' verwendet. Ein ''range expression'' wird durch zwei Zeichen, die durch einen Bindestrich miteinander verbunden sind, dargestellt:
| |
| | |
| [a-d]
| |
| | |
| Ein solcher Ausdruck passt auf alle Zeichen, die in der Sortierung des Zeichensatzes zwischen die beiden Zeichen fallen.
| |
| | |
| === Auswahl einzelner Zeichen ===
| |
| | |
| ==== Zeichenauswahl ([ und ]) ====
| |
| | |
| * Der Ausdruck in eckigen Klammern steht dann für ''genau ein'' Zeichen aus dieser Auswahl.
| |
| * Innerhalb dieser Zeichenklassendefinitionen haben einige Symbole andere Bedeutungen als im normalen Kontext.
| |
| | |
| ==== Zeichenklassen (Character Classes) ====
| |
| | |
| Eine Character Class definiert einen Zeichenvorrat. Sie besteht aus einer Menge von ein oder mehreren Zeichen und wird innerhalb von eckigen Klammern angegeben. Die Reihenfolge der Zeichen ist beliebig.
| |
| | |
| Beispiele:
| |
| [ae]* Zeichenvorrat besteht nur aus "a" und "e"
| |
| [aeiou]* alle Vokale in Kleinbuchstaben
| |
| [aeiouAEIOU]* in Klein- und Großbuchstaben
| |
| [a-fh-k]* Buchstaben a-f und h-k
| |
| [^a]* alle Zeichen außer "a"
| |
| [^abc]* alle Zeichen außer "a", "b" oder "c" (Reihenfolge gleichgültig!)
| |
| | |
| ==== Kontextabhängige Symbole ====
| |
| | |
| Teilweise ist die Bedeutung eines Symbols vom Kontext abhängig, in dem es innerhalb der Klammern auftritt.
| |
| | |
| {| class="wikitable sortable"
| |
| |- | | |- |
| | | '''^''' | | | Basic Regular Expressions (BRE) || „grundlegende“ reguläre Ausdrücke |
| | | * Beispielsweise bedeutet ein [http://de.wikipedia.org/wiki/Zirkumflex Zirkumflex] „<tt>'''^'''</tt>“ am Anfang einer Zeichenklassendefinition, dass die Zeichenklasse negiert/invertiert wird (im Sinne der [http://de.wikipedia.org/wiki/Komplement_%28Mengenlehre%29 Komplementbildung]). | |
| * Steht ein Zirkumflex jedoch irgendwo sonst in der Definition, ist es literal zu verstehen.
| |
| | |
| |- | | |- |
| | | '''-''' | | | Extended Regular Expressions (ERE) || „erweiterte“ reguläre Ausdrücke |
| | | Ebenfalls kontextabhängig ist die Bedeutung des Bindestrich-Zeichens (<tt>'''-'''</tt>). Zudem unterscheiden sich hier die Regexp-Engines (zum Beispiel POSIX und PCRE) in einigen Punkten voneinander. * Steht <tt>-</tt> zwischen zwei Zeichen in der Klassendefinition, zum Beispiel „<tt>[a-g]</tt>“, so ist es als Beschreibung eines Zeichenintervalls oder Zeichenbereichs bezüglich der [http://de.wikipedia.org/wiki/ASCII ASCII]-Tabelle zu verstehen. | |
| * Das genannte Beispiel wäre äquivalent zu „<tt>[abcdefg]</tt>“. Am Anfang oder Ende einer Zeichenklasse stehende Bindestriche werden literal interpretiert.
| |
| | |
| |- | | |- |
| | | Perl Compatible Regular Expressions (PCRE) || In Programmiersprachen haben sich überwiegend die [http://de.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions Perl Compatible Regular Expressions] (PCRE) durchgesetzt, die sich an der Umsetzung in Perl orientieren. |
| |} | | |} |
| ===== Beispiel =====
| |
| „[^ ]$“ * Zeichenkette muss aus mind. einem Zeichen bestehen und
| |
| das letzte Zeichen darf kein Leerzeichen sein
| |
|
| |
| ==== Sortierung ====
| |
|
| |
| Leider hängt diese Sortierung von der verwendeten ''locale''-Einstellung ab. In der Standard ''C locale'' würde obiges Muster "<tt>[a-d]</tt>" einem regulären Ausdruck von "<tt>[abcd]</tt>" entsprechen, während er bei vielen anderen ''locales'' einem Ausdruck "<tt>[aBbCcDd]</tt>" entsprechen würde.
| |
|
| |
| Um die ''C locale'' für die Zeichensortierung zu erzwingen, kann man der Variablen LC_CTYPE den Wert C zuweisen:
| |
|
| |
| LC_CTYPE=C befehl* gilt nur für diesen Befehl
| |
|
| |
| LC_CTYPE=C grep -E [a-d] Datei
| |
| export LC_CTYPE=C* gilt für alle nachfolgenden Befehle
| |
|
| |
| Die meisten Zeichen mit besonderer Bedeutung verlieren diese Bedeutung innerhalb eines ''bracket expressions''. Um ein Zeichen "<tt>]</tt>" in die Liste aufzunehmen, muss es an der ersten Stelle in der Liste stehen.
| |
|
| |
| Um das Caret "<tt>^</tt>" in die Liste aufzunehmen, kann es irgendwo in der Liste stehen, nur nicht an der ersten Stelle. Um den Bindestrich "<tt>-</tt>" in die Liste einzufügen, muss es an letzter Stelle stehen.
| |
|
| |
| === Vordefinierten Zeichenklassen ===
| |
|
| |
| In vielen neueren Implementationen können innerhalb der eckigen Klammern nach [http://de.wikipedia.org/wiki/POSIX POSIX] auch Klassen (vordefinierte Listen) angegeben werden, die selbst wiederum eckige Klammern enthalten.
| |
|
| |
| {| class="wikitable sortable"
| |
| |-
| |
| | | '''POSIX'''
| |
| | | '''Non-standard'''
| |
| | | '''Perl/Tcl'''
| |
| | | '''Vim'''
| |
| | | '''ASCII'''
| |
| | | '''Description'''
| |
| |-
| |
| | | <tt>[:alnum:]</tt>
| |
| | |
| |
| | |
| |
| | |
| |
| | | <tt>[A-Za-z0-9]</tt>
| |
| | | Alphanumeric characters
| |
| |-
| |
| | |
| |
| | | <tt>[:word:]</tt>
| |
| | | <tt>\w</tt>
| |
| | | <tt>\w</tt>
| |
| | | <tt>[A-Za-z0-9_]</tt>
| |
| | | Alphanumeric characters plus "_"
| |
| |-
| |
| | |
| |
| | |
| |
| | | <tt>\W</tt>
| |
| | | <tt>\W</tt>
| |
| | | <tt>[^A-Za-z0-9_]</tt>
| |
| | | Non-word characters
| |
| |-
| |
| | | <tt>[:alpha:]</tt>
| |
| | |
| |
| | |
| |
| | | <tt>\a</tt>
| |
| | | <tt>[A-Za-z]</tt>
| |
| | | Alphabetic characters
| |
| |-
| |
| | | <tt>[:blank:]</tt>
| |
| | |
| |
| | |
| |
| | | <tt>\s</tt>
| |
| | | <tt>[ [http://en.wikipedia.org/wiki/%5Ct \t]]</tt>
| |
| | | Space and tab
| |
| |-
| |
| | |
| |
| | |
| |
| | | <tt>\b</tt>
| |
| | | <tt>\< \></tt>
| |
| | | <tt>(?<=\W)(?=\w)|(?<=\w)(?=\W)</tt>
| |
| | | Word boundaries
| |
| |-
| |
| | | <tt>[:cntrl:]</tt>
| |
| | |
| |
| | |
| |
| | |
| |
| | | <tt>[\x00-\x1F\x7F]</tt>
| |
| | | [http://en.wikipedia.org/wiki/Control_character Control characters]
| |
| |-
| |
| | | <tt>[:digit:]</tt>
| |
| | |
| |
| | | <tt>\d</tt>
| |
| | | <tt>\d</tt>
| |
| | | <tt>[0-9]</tt>
| |
| | | Digits
| |
| |-
| |
| | |
| |
| | |
| |
| | | <tt>\D</tt>
| |
| | | <tt>\D</tt>
| |
| | | <tt>[^0-9]</tt>
| |
| | | Non-digits
| |
| |-
| |
| | | <tt>[:graph:]</tt>
| |
| | |
| |
| | |
| |
| | |
| |
| | | <tt>[\x21-\x7E]</tt>
| |
| | | Visible characters
| |
| |-
| |
| | | <tt>[:lower:]</tt>
| |
| | |
| |
| | |
| |
| | | <tt>\l</tt>
| |
| | | <tt>[a-z]</tt>
| |
| | | Lowercase letters
| |
| |-
| |
| | | <tt>[:print:]</tt>
| |
| | |
| |
| | |
| |
| | | <tt>\p</tt>
| |
| | | <tt>[\x20-\x7E]</tt>
| |
| | | Visible characters and the space character
| |
| |-
| |
| | | <tt>[:punct:]</tt>
| |
| | |
| |
| | |
| |
| | |
| |
| | | <tt>[][!"#$%&'()*+,./:;<=>?@\^_`{| class="wikitable sortable"}~-]</tt>
| |
| | | Punctuation characters
| |
| |-
| |
| | | <tt>[:space:]</tt>
| |
| | |
| |
| | | <tt>\s</tt>
| |
| | | <tt>\_s</tt>
| |
| | | <tt>[ [http://en.wikipedia.org/wiki/%5Ct \t][http://en.wikipedia.org/wiki/%5Cr \r][http://en.wikipedia.org/wiki/%5Cn \n][http://en.wikipedia.org/wiki/%5Cv \v][http://en.wikipedia.org/wiki/%5Cf \f]]</tt>
| |
| | | [http://en.wikipedia.org/wiki/Whitespace_character Whitespace characters]
| |
| |-
| |
| | |
| |
| | |
| |
| | | <tt>\S</tt>
| |
| | |
| |
| | | <tt>[^ \t\r\n\v\f]</tt>
| |
| | | Non-whitespace characters
| |
| |-
| |
| | | <tt>[:upper:]</tt>
| |
| | |
| |
| | |
| |
| | | <tt>\u</tt>
| |
| | | <tt>[A-Z]</tt>
| |
| | | Uppercase letters
| |
| |-
| |
| | | <tt>[:xdigit:]</tt>
| |
| | |
| |
| | |
| |
| | | <tt>\x</tt>
| |
| | | <tt>[A-Fa-f0-9]</tt>
| |
| | | Hexadecimal digits
| |
| |-
| |
| |}
| |
| POSIX Zeichenklassen können nur innerhalb von Klammer-Ausdrücken genutzt werden.
| |
|
| |
| ====== Vordefinierten Zeichenklassen müssen in eckige Klammern ======
| |
|
| |
| ====== falsch ======
| |
|
| |
| grep -E '[:alnum:]' Datei
| |
| * findet z.B. 'a', da es eines der Zeichen ':alnum:' ist, aber nicht 'b' oder '1'
| |
| * (die vordefinierte Liste wird nicht als solche interpretiert!)
| |
|
| |
| ====== richtig ======
| |
|
| |
| grep -E ''''['''[:alnum:]''']'''' Datei
| |
| * findet sowohl 'a', als auch 'b' oder '1', da die vordefinierte Liste nun als "Buchstabe oder Zahl" interpretiert wird
| |
|
| |
| ====== auch richtig ======
| |
|
| |
| grep -E ''''['''[:alnum:] ''']'''' Datei
| |
| * findet zusätzlich zu Buchstaben und Zahlen auch Leerzeichen
| |
|
| |
| ====== richtig ======
| |
|
| |
| grep -E '[0-9a-zA-Z]' Datei
| |
| * entspricht [[:alnum:]]
| |
|
| |
| ===== Zeichenklassen, hierarchisch sortiert =====
| |
|
| |
| {| class="wikitable sortable"
| |
| |-
| |
| || <tt>'''[:cntrl:]'''</tt> — Steuerzeichen. Im ASCII sind das die Zeichen 00 bis 1F und 7F (DEL).
| |
|
| |
| <tt>'''[:print:]'''</tt> — Druckbare Zeichen: [:alnum:], [:punct:] und Leerzeichen
| |
|
| |
| <tt>'''[:blank:]'''</tt> — [http://de.wikipedia.org/wiki/Leerzeichen Leerzeichen] oder [http://de.wikipedia.org/wiki/Tabulator Tabulator]
| |
|
| |
| <tt>'''[:space:]'''</tt> — [http://de.wikipedia.org/wiki/Leerraum Whitespace]: Horizontaler und vertikaler Tabulator, [http://de.wikipedia.org/wiki/Zeilenvorschub Zeilen]- und [http://de.wikipedia.org/w/index.php?title=Seitenvorschub&action=edit&redlink=1 Seitenvorschub], [http://de.wikipedia.org/wiki/Wagenrücklauf Wagenrücklauf] und Leerzeichen
| |
|
| |
| <tt>'''[:graph:]'''</tt> — Graphische Zeichen: [:alnum:] oder [:punct:]
| |
|
| |
| <tt>'''[:punct:]'''</tt> — Satzzeichen wie: ! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
| |
|
| |
| <tt>'''[:alnum:]'''</tt> — [http://de.wikipedia.org/wiki/Alphanumerische_Zeichen Alphanumerische Zeichen]: [:alpha:] oder [:digit:]
| |
|
| |
| <tt>'''[:xdigit:]'''</tt> — [http://de.wikipedia.org/wiki/Hexadezimalsystem Hexadezimale] Ziffern: 0 bis 9, A bis F, a bis f.
| |
|
| |
| <tt>'''[:digit:]'''</tt> — Die Ziffern 0 bis 9
| |
|
| |
| <tt>'''[:alpha:]'''</tt> — Buchstaben: [:lower:] oder [:upper:]
| |
|
| |
| <tt>'''[:lower:]'''</tt> — Kleinbuchstaben: nicht notwendigerweise nur von a bis z
| |
|
| |
| <tt>'''[:upper:]'''</tt> — Großbuchstaben: nicht notwendigerweise nur von A bis Z
| |
| |-
| |
| || '''Anmerkung'''
| |
|
| |
| Was Buchstaben sind, ist im Allgemeinen locale-abhängig, also abhängig von der eingestellten Region und Sprache.
| |
|
| |
| |-
| |
| |}
| |
| ===== Beispiel =====
| |
|
| |
| Die Buchstaben "y" und "i" sollen durch "xx" ersetzt werden.
| |
|
| |
| echo -e "Mayer\nMaier\nMeyer\nMeier" | sed 's/[yi]/xx/'
| |
|
| |
| Beachten Sie, dass beim Suchen und Ersetzen immer alle Zeilen komplett ausgegeben werden, unabhängig davon ob Ersetzungen durchgeführt wurden oder nicht. Daher lassen sich mehrere Suchen und Ersetzen Anweisungen gut aneinanderreihen.
| |
|
| |
| "i" und "y" sollen durch "ii" ersetzt werden, sodann "a" und "e" durch "oo"
| |
|
| |
| '''$ echo -e "Mayer\nMaier\nMeyer\nMeier" | sed -e 's/[iy]/ii/g' -e 's/[ae]/oo/g''''
| |
| Mooiioor
| |
|
| |
| ==== Vordefinierte Zeichenklassen ====
| |
|
| |
| Es gibt vordefinierte Zeichenklassen, die allerdings nicht von allen Implementierungen unterstützt werden, da sie lediglich Kurzformen sind und auch durch eine ''Zeichenauswahl'' beschrieben werden können.
| |
|
| |
| Wichtige Zeichenklassen sind:
| |
|
| |
| {| class="wikitable sortable"
| |
| |-
| |
| | | <tt>'''\d'''</tt>
| |
| | | '''d'''igit
| |
| | | eine Ziffer [0-9]
| |
| |-
| |
| | | <tt>'''\D'''</tt>
| |
| | | no '''d'''igit
| |
| | | ein Zeichen, das keine Ziffer ist, also [^\d]
| |
| |-
| |
| | | <tt>'''\w'''</tt>
| |
| | | '''w'''ordcharacter
| |
| | | ein Buchstabe, eine Ziffer oder der Unterstrich, also [a-zA-Z_0-9] (und evtl. weitere Buchstaben, z. B. Umlaute)
| |
| |-
| |
| | | <tt>'''\W'''</tt>
| |
| | | no '''w'''ordcharacter
| |
| | | ein Zeichen, das weder Buchstabe noch Zahl noch Unterstrich ist, also [^\w]
| |
| |-
| |
| | | <tt>'''\s'''</tt>
| |
| | | white'''s'''pace
| |
| | | meistens das Leerzeichen und die Klasse der [http://de.wikipedia.org/wiki/Steuerzeichen Steuerzeichen] \f, \n, \r, \t und \v
| |
| |-
| |
| | | <tt>'''\S'''</tt>
| |
| | | no white'''s'''pace
| |
| | | ein Zeichen, das kein Whitespace ist [^\s]
| |
| |-
| |
| | | <tt>'''\b'''</tt>
| |
| | |
| |
| | | leere Zeichenkette am Wortanfang oder am Wortende
| |
| |-
| |
| | | <tt>'''\B'''</tt>
| |
| | |
| |
| | | leere Zeichenkette, die ''nicht'' den Anfang oder das Ende eines Wortes bildet
| |
| |-
| |
| | | <tt>'''\<'''</tt>
| |
| | |
| |
| | | leere Zeichenkette am Wortanfang
| |
| |-
| |
| | | <tt>'''\>'''</tt>
| |
| | |
| |
| | | leere Zeichenkette am Wortende
| |
| |-
| |
| | | <tt>'''\n'''</tt>
| |
| | | newline
| |
| | | ein [http://de.wikipedia.org/wiki/Zeilenumbruch Zeilenumbruch] im Unix-Format
| |
| |-
| |
| | | <tt>'''\r'''</tt>
| |
| | | return
| |
| | | ein [http://de.wikipedia.org/wiki/Zeilenumbruch Zeilenumbruch] im Mac-Format
| |
| |-
| |
| | | <tt>'''\r\n'''</tt>
| |
| | |
| |
| | | ein [http://de.wikipedia.org/wiki/Zeilenumbruch Zeilenumbruch] im Windows-Format
| |
|
| |
| |-
| |
| |}
| |
| ==== Weitere Zeichen ====
| |
|
| |
| {| class="wikitable sortable"
| |
| |-
| |
| | | <tt>'''^'''</tt>
| |
| | | steht für den Zeilenanfang (nicht zu verwechseln mit „<tt>^</tt>“ bei der Zeichenauswahl mittels „<tt>[</tt>“ und „<tt>]</tt>“).
| |
| |-
| |
| | | <tt>'''$'''</tt>
| |
| | | kann je nach Kontext für das Zeilen- oder Stringende stehen, wobei bei manchen Implementierungen noch ein „\n“ folgen darf. Das tatsächliche Ende wird von <tt>\z</tt> gematcht.
| |
| |-
| |
| | | <tt>'''\'''</tt>
| |
| | | hebt gegebenenfalls die Metabedeutung des nächsten Zeichens auf. Beispielsweise lässt der Ausdruck „<tt>(A\*)+</tt>“ die Zeichenketten „A*“, „A*A*“, usw. zu. Auf diese Weise lässt sich auch ein Punkt „.“ mit „<tt>\.</tt>“ suchen, während nach „<tt>\</tt>“ mit „<tt>\\</tt>“ gesucht wird.
| |
|
| |
| |-
| |
| |}
| |
| === Weitere Beispiele ===
| |
|
| |
| [egh]* eines der Zeichen „e“, „g“ oder „h“
| |
|
| |
| [0-6]* eine Ziffer von „0“ bis „6“ (Bindestriche sind Indikator für einen Bereich)
| |
|
| |
| [A-Za-z0-9]* ein beliebiger lateinischer Buchstabe oder eine beliebige Ziffer
| |
|
| |
| [^a]* ein beliebiges Zeichen außer „a“ („^“ am Anfang einer Zeichenklasse negiert selbige)
| |
|
| |
| [-A-Z], [A-Z-]
| |
| bzw.
| |
| [A-Z\-a-z], allerdings nicht gemäß POSIX)* Auswahl enthält auch den Bindestrich „-“, wenn er das erste oder das letzte Zeichen in der Aufzählung einer Zeichenklasse ist
| |
| * bei PCRE, wenn seine Metafunktion innerhalb einer Auswahl durch ein vorangestelltes „\“-Zeichen aufgehoben wird<br/>gehört das hier hin?
| |
|
| |
| \<[Aa]+n+[ae]+\>* findet alle Wörter, die ungefähr wie Anne oder Anna aussehen, nur mit beliebig vielen "A", "n" und "e" (sofern sie jeweils mindestens ein mal vorkommen). ''AAnnneeea'' würde zum Beispiel auch passen.
| |
|
| |
| [Ss]up(er|ra)* findet alle Wörter, die ein Super, super, Supra oder supra enthalten.
| |
|
| |
| ^[[:digit:]]* findet alle Zeilen, die mit einer Ziffer beginnen.
| |
|
| |
| == Wiederholungsfaktoren (Quantoren) ==
| |
|
| |
| [http://de.wikipedia.org/wiki/Quantor Quantoren] (engl. ''quantifier'', auch ''Quantifizierer'') erlauben es, den vorherigen Ausdruck in verschiedener Vielfachheit in der Zeichenkette zuzulassen.
| |
|
| |
| {| class="wikitable sortable"
| |
| |-
| |
| | | <tt>'''?'''</tt>
| |
| | | Der voranstehende Ausdruck ist optional, er kann einmal vorkommen, muss es aber nicht, d. h. der Ausdruck kommt null- oder einmal vor. (Dies entspricht <tt>'''{''0'',''1''}'''</tt>)
| |
| |-
| |
| | | <tt>'''+'''</tt>
| |
| | | Der voranstehende Ausdruck muss mindestens einmal vorkommen, darf aber auch mehrfach vorkommen. (Dies entspricht <tt>'''{''1'',}'''</tt>)
| |
| |-
| |
| | | <tt>'''*'''</tt>
| |
| | | Der voranstehende Ausdruck darf beliebig oft (auch keinmal) vorkommen. (Dies entspricht <tt>'''{''0'',}'''</tt>)
| |
| |-
| |
| | >''n''</span>}'''</tt>
| |
| | | Der voranstehende Ausdruck muss exakt ''n''-mal vorkommen.
| |
| |-
| |
| | >''min''</span>,}'''</tt>
| |
| | | Der voranstehende Ausdruck muss mindestens ''min''-mal vorkommen.
| |
| |-
| |
| | >''max''</span>}'''</tt>
| |
| | | Der voranstehende Ausdruck muss mindestens ''min''-mal und darf maximal ''max''-mal vorkommen.
| |
| |-
| |
| | >''max''</span>}'''</tt>
| |
| | | Der voranstehende Ausdruck darf maximal ''max''-mal vorkommen.
| |
|
| |
| |-
| |
| |}
| |
| ==== Funktionsweise ====
| |
|
| |
| Die Quantoren beziehen sich dabei auf den '''vorhergehenden''' regulären Ausdruck, jedoch nicht zwangsläufig auf die durch ihn gefundene Übereinstimmung. * So wird zwar zum Beispiel durch <tt>a+</tt> ein „a“ oder auch „aaaa“ vertreten,
| |
| * jedoch entspricht <tt>[0-9]+</tt> nicht nur sich wiederholenden ''gleichen'' Ziffern, sondern auch Folgen gemischter Ziffern, beispielsweise „072345“.
| |
|
| |
| ==== Beispiele ====
| |
|
| |
| „[ab]+“ * entspricht „a“, „b“, „aa“, „bbaab“ etc.
| |
|
| |
| „[0-9]{2,5}“ * entspricht zwei, drei, vier oder fünf Ziffern in Folgez. B. „42“ oder „54072“, jedoch nicht den Zeichenfolgen „0“, „1.1“ oder „a1a1“.
| |
|
| |
| === Gieriges Verhalten von Quantoren ===
| |
|
| |
| Quantoren sind standardmäßig „gierig“ (engl. ''greedy'') implementiert.
| |
|
| |
| Soll eine Zeichenkette ''nur'' aus dem gesuchten Muster bestehen (und es nicht nur enthalten), so muss in den meisten Implementierungen explizit definiert werden, dass das Muster vom Anfang (<tt>\A</tt> oder <tt>^</tt>) bis zum Ende der Zeichenkette (<tt>\Z</tt>, <tt>\z</tt> oder <tt>$</tt>) reichen soll. * Andernfalls erkennt zum Beispiel <tt>[0-9]{2,5}</tt> auch bei der Zeichenkette „1234507“ die Teilzeichenkette „12345“.
| |
| * Aus dem gleichen Grund würde beispielsweise <tt>a*</tt> immer einen Treffer ergeben, da jede Zeichenfolge – selbst das [http://de.wikipedia.org/wiki/Leeres_Wort leere Wort] „“ – mindestens 0-mal das Zeichen „a“ enthält.
| |
| * Das heißt, ein regulärer Ausdruck wird zur größtmöglichen Übereinstimmung aufgelöst.
| |
|
| |
| ==== Genügsame Quantoren ====
| |
|
| |
| Da dieses Verhalten jedoch nicht immer so gewollt ist, lassen sich bei vielen neueren Implementierungen Quantoren als „genügsam“ oder „zurückhaltend“ (engl. ''non-greedy'', ''reluctant'') deklarieren.
| |
|
| |
| Zum Beispiel wird in Perl hierfür dem Quantor ein Fragezeichen <tt>'''?'''</tt> nachgestellt. Die Implementierung von genügsamen Quantoren ist vergleichsweise aufwändig (erfordert [http://de.wikipedia.org/wiki/Backtracking Backtracking]), weshalb nicht alle Implementierungen diese unterstützen.
| |
|
| |
| ===== Beispiel (Perl-Syntax) =====
| |
|
| |
| * Angenommen, es wird der reguläre Ausdruck <tt>'''A.*B'''</tt> auf die Zeichenfolge „ABCDEB“ angewendet, so würde er sie komplett als „ABCDEB“ finden.
| |
| * Mit Hilfe des „non-greedy“-Quantors „<tt>*?</tt>“ matcht der nun modifizierte Ausdruck – also <tt>'''A.*?B'''</tt> – nur die Zeichenkette „AB“, bricht also die Suche nach dem ersten gefundenen „B“ ab.
| |
| * Ein gleichwertiger regulärer Ausdruck für Interpreter, die diesen Quantor nicht unterstützen, wäre <tt>A[^B]*B</tt>.
| |
|
| |
| Die Zeichen <tt>^</tt> und <tt>$</tt> matchen im ''multiline-''Modus (wenn der m-Modifier gesetzt wird) auch Zeilenanfänge und -enden.
| |
|
| |
| ==== Possessives Verhalten ====
| |
|
| |
| Eine Variante des oben beschriebenen gierigen Verhaltens ist das ''possessive Matching''. Da hierbei jedoch das Backtracking verhindert wird, werden einmal übereinstimmende Zeichen nicht wieder freigegeben.
| |
|
| |
| Aufgrund dessen finden sich in der Literatur auch die synonymen Bezeichnungen ''atomic grouping'', ''independent subexpression'' oder ''non-backtracking subpattern''. Die Syntax für diese Konstrukte variiert bei den verschiedenen Programmiersprachen.
| |
|
| |
| Ursprünglich wurden solche Teilausdrücke ''(Subpattern)'' in Perl durch <tt>'''(?>'''<span >''Ausdruck''</span>''')'''</tt> formuliert.
| |
|
| |
| Daneben existieren seit Perl 5.10 die äquivalenten, in Java bereits üblichen possessiven Quantoren <tt>++</tt>, <tt>*+</tt>, <tt>?+</tt> und <tt>{''min'',''max''}+</tt>.
| |
|
| |
| Angenommen es wird auf die Zeichenfolge „ABCDEB“ der reguläre Ausdruck <tt>'''A.*+B'''</tt> angewendet, so würde er keine Übereinstimmung finden. * Bei der Abarbeitung des regulären Ausdrucks würde der Teil <tt>'''.*+'''</tt> bis zum Ende der Zeichenkette übereinstimmen.
| |
| * Um jedoch den gesamten Ausdruck zu matchen, müsste ein Zeichen (hier also das „B“) wieder freigegeben werden.
| |
| * Der possessive Quantor verbietet dies aufgrund des unterdrückten Backtrackings, weshalb keine erfolgreiche Übereinstimmung gefunden werden kann.
| |
|
| |
| == Gruppierungen und Referenzen ==
| |
|
| |
| === Gruppierungen ===
| |
|
| |
| Ausdrücke lassen sich mit runden Klammern <tt>'''('''</tt> und <tt>''')'''</tt> ''zusammenfassen'':
| |
|
| |
| '''„<tt>(abc)+</tt>“ erlaubt ein „abc“, „abcabc“, „abcabcabc“ etc.'''
| |
|
| |
| === Rückreferenzen ===
| |
|
| |
| Einige Implementierungen speichern die gefundenen Übereinstimmungen von Gruppierungen ab und ermöglichen deren Wiederverwendung im regulären Ausdruck oder bei der Textersetzung.
| |
|
| |
| Diese werden ''Rückwärtsreferenzen'' (engl. ''back references'') genannt.
| |
|
| |
| Häufig wird dazu die Schreibweise <tt>'''\''n'''''</tt> oder <tt>'''$''n'''''</tt> verwendet, wobei ''n'' die Übereinstimmung der ''n''-ten Gruppierung entspricht.
| |
|
| |
| Eine Sonderstellung stellt dabei ''n''=0 dar, das meist für die Übereinstimmung des gesamten regulären Ausdruck steht.
| |
|
| |
| '''Beispiel '''* Ein Suchen und Ersetzen mit <tt>'''AA(.*?)BB'''</tt> als regulären Suchausdruck und <tt>'''\1'''</tt> als Ersetzung ersetzt alle Zeichenketten, die von '''AA''' und '''BB''' eingeschlossen sind, durch den zwischen '''AA''' und '''BB''' enthaltenen Text.
| |
| * D.h. '''AA''' und '''BB''' und der Text dazwischen werden ersetzt durch den Text, der ursprünglich zwischen '''AA''' und '''BB''' stand, also fehlen '''AA''' und '''BB''' im Ergebnis.
| |
|
| |
| ==== Geklammerte Ausdrücke referenzieren ====
| |
|
| |
| Eine Teilzeichenkette, die auf einen geklammerten Teilausdruck gepasst hat, lässt sich durch "<tt>\n</tt>" referenzieren. Dabei steht "<tt>n</tt>" für eine einzelne Ziffer, die den n-ten geklammerten Teilausdruck auswählt.
| |
|
| |
| ==== Bezugnahme auf die Ergebnismenge ====
| |
|
| |
| Bei den bisherigen Anweisungen wurde der gesamte Zeileninhalt ausgegeben. Es gibt jedoch die Möglichkeit, direkt auf die effektive Ergebnismenge oder einen Teil daraus Bezug zu nehmen.
| |
|
| |
| Die hierfür erforderliche s-Anweisung führt kein Suchen und Ersetzen durch, sondern durchsucht den Datenstrom anhand der RE und bildet aufgrund des Ausdrucks in () nochmals eine Teilmenge, die ausgegeben werden kann.
| |
|
| |
| ===== BeispielTESTEN!! =====
| |
|
| |
| Aus der folgenden Zeile soll nur das Element "blau" ausgegeben werden.
| |
|
| |
| '''echo "-rot-blau-gelb" | sed 's/.*\(blau\).*/\1/g''''
| |
| Die gesamte RE lautet: /.*blau.*/
| |
|
| |
| Es soll jedoch nur der Teil der Ergebnismenge ausgegeben werden, der "blau" enthält. Folglich ist "blau" in runde Klammern zu setzen.
| |
|
| |
| /.*\(blau\).*/
| |
| '''echo "-rot-blau-gelb" | sed 's/.*\(blau\).*/\1/g''''
| |
|
| |
| * s"Suchen und Ersetzen", wobei kein "Ersetzen" durchgeführt wird
| |
| * .*Beginn der RE: beliebiges Zeichen 0-n mal
| |
| * \(blau\)"blau" soll, falls es sich aus der Ergebnismenge extrahieren läßt, ausgegeben werden
| |
| * .*Ende der RE: beliebiges Zeichen 0-n mal
| |
| * \1die Ergebnismenge der 1. geklammerten RE wird ausgegeben
| |
| * bei mehreren REs, wird jeder RE eine Zahl zugeordnet: \1 = 1.RE \2 = 2.RE usw.
| |
|
| |
| ==== Praktische Anwendung von Rückreferenzen ====
| |
|
| |
| Umschreiben einer URL
| |
|
| |
| [[Image:Grafik1.png]]
| |
|
| |
| === Gruppierungen ohne Rückreferenz ===
| |
|
| |
| ===== engl. non-capturing =====
| |
|
| |
| Die Syntax lautet in den meisten Implementierungen <tt>'''(?:</tt>…<tt>)'''</tt>.
| |
|
| |
| Regexp-Dokumentationen weisen darauf hin, dass die Erzeugung von Rückwärtsreferenzen stets vermieden werden soll, wenn kein späterer Zugriff auf sie erfolge.
| |
|
| |
| Denn die Erzeugung der Referenzen kostet Ausführungszeit und belegt Platz zur Speicherung der gefundenen Übereinstimmung.
| |
|
| |
| Zudem lassen die Implementationen nur eine begrenzte Anzahl an Rückwärtsreferenzen zu (häufig nur maximal 9).
| |
|
| |
| ==== Beispiel ====
| |
|
| |
| \d+(?:-\d+)** Findet Folgen von durch Bindestriche getrennte Zahlenfolgen, ohne dabei die letzte durch einen Bindestrich getrennte Zahlenfolge als Rückreferenz zu erhalten.
| |
|
| |
| == Suchen & Ersetzen ==
| |
|
| |
| Beim reinen s-Befehl werden immer alle Zeilen ausgegeben, unabhängig davon, ob Ersetzungen durchgeführt wurden oder nicht. Dies lässt sich ändern, indem man ihn mit dem p-Befehl kombiniert. Die Abläufe sind wie folgt:
| |
|
| |
| '''p-Befehl'''
| |
|
| |
| '''echo "dies wird nicht ausgegeben" | sed -n '/.*diiss.*/p''''
| |
| # gibt es eine Ergebnismenge, die zur RE "passt"?
| |
| # wenn ja, gibt die ganze Zeile aus.
| |
|
| |
| '''s-Befehl ohne p-Befehl'''
| |
|
| |
| '''echo "dies wird ausgegeben" | sed 's/wird/wird immer/''''
| |
| # gibt es eine Ergebnismenge, die zur RE "passt"?
| |
| # wenn ja, welches ist die effektive Ergebnismenge?
| |
| # ersetze diese durch den Replace-String
| |
| # gib die ganze Zeile aus (egal, ob geändert oder nicht)
| |
|
| |
| '''s-Befehl mit p-Befehl'''
| |
|
| |
| '''echo -e "xxx\nnächste Zeile" | sed -n 's/xxx/Ausgabe/p''''
| |
| # Die Kombination von s- und p-Befehl bewirkt, dass
| |
| # nur die geänderten Zeilen ausgegeben werden.
| |
| # Die Option -n darf nicht vergessen werden.
| |
|
| |
| Im Allgemeinen ist es sinnvoll, den g-Spezifizierer ("global") zu verwenden, der direkt vor oder hinter dem p-Befehl steht:
| |
|
| |
| '''echo -e "xxx--xxx\nnächste Zeile" | sed -n 's/xxx/Ausgabe/pg''''
| |
| # alle "xxx" werden ersetzt
| |
|
| |
| === Ersatzmuster ===
| |
|
| |
| Bei einigen Tools (ex, sed und ed) werden zwei Muster angegeben: Ein Suchmuster (links) und ein Ersatzmuster (rechts). Nur die folgenden Zeichen sind in einem Ersatzmuster gültig:
| |
|
| |
| {| class="wikitable sortable"
| |
| |-
| |
| | |
| |
| | | '''ex'''
| |
| | | '''sed'''
| |
| | | '''Ed'''
| |
| | |
| |
| |-
| |
| | | <tt>'''\'''</tt>
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | Sonderbedeutung des nächsten Zeichens aufhebe
| |
| |-
| |
| | | <tt>'''\n'''</tt>
| |
| | | X
| |
| | | X
| |
| | | X
| |
| | | Verwendet das in \( \) gespeicherte Muster erneut
| |
| |-
| |
| | | <tt>'''&'''</tt>
| |
| | | X
| |
| | | X
| |
| | |
| |
| | | Verwendet das vorherige Suchmuster erneut
| |
| |-
| |
| | | <tt>'''~'''</tt>
| |
| | | X
| |
| | |
| |
| | |
| |
| | | Verwendet das vorherige Ersatzmuster erneut
| |
| |-
| |
| | | <tt>'''\u'''</tt>
| |
| | | X
| |
| | |
| |
| | |
| |
| | | Ändert das erste Zeichen des Ersatzmusters auf Großschreibung
| |
| |-
| |
| | | <tt>'''\U'''</tt>
| |
| | | X
| |
| | |
| |
| | |
| |
| | | Ändert alle Zeichen des Ersatzmusters auf Großschreibung
| |
| |-
| |
| | | <tt>'''\l'''</tt>
| |
| | | X
| |
| | |
| |
| | |
| |
| | | Ändert das erste Zeichen des Ersatzmusters auf Kleinschreibung
| |
| |-
| |
| | | <tt>'''\L'''</tt>
| |
| | | X
| |
| | |
| |
| | |
| |
| | | Ändert alle Zeichen des Ersatzmusters auf Kleinschreibung
| |
| |-
| |
| | | <tt>'''\E'''</tt>
| |
| | | X
| |
| | |
| |
| | |
| |
| | | Hebt das vorangegangene \U oder \L auf
| |
| |-
| |
| | | <tt>'''\e'''</tt>
| |
| | | X
| |
| | |
| |
| | |
| |
| | | Hebt das vorangegangene \u oder \l auf
| |
|
| |
| |-
| |
| |}
| |
| == Verknüpfung regulärer Ausdrücken ==
| |
|
| |
| Mehrere reguläre Ausdrücke können durch Aneinanderfügen zusammengeführt werden. Ein solcher Ausdruck findet dann alle Zeichenketten, die aneinander gehängt zu dem jeweiligen Ausdruck passen.
| |
|
| |
| ====== Beispiel ======
| |
|
| |
| "[Aa]lpha"
| |
|
| |
| Es besteht aus den einzelnen Bausteinen * "<tt>[Aa]</tt>"
| |
| * "<tt>l</tt>"
| |
| * "<tt>p</tt>"
| |
| * "<tt>h</tt>"
| |
| * "<tt>a</tt>"
| |
|
| |
| === Verknüpfung durch "oder" ===
| |
|
| |
| Durch den Operator "<tt>|</tt>" lassen sich reguläre Ausdrücke mit einem "oder" verknüpfen.
| |
|
| |
| Der daraus entstehende Ausdruck findet Zeichenketten, die entweder auf den einen oder den anderen Ausdruck passen.
| |
|
| |
| ====== Beispiel ======
| |
|
| |
| "[Aa]lpha|[Bb]ravo" * findet alle Textstücke "Alpha", "alpha", "Bravo" und "bravo"
| |
| * <tt>grep -E</tt> oder <tt>egrep</tt>
| |
|
| |
| echo "--rot--gelb--" | sed 's/\(gelb\|rot\)/x/g'
| |
| echo "--rot--gelb--" | sed 's/gelb\|rot/x/g'
| |
| * die runden Klammern und das oder-Zeichen "|" müssen escaped werden
| |
| * die runden Klammern können weggelassen werden
| |
|
| |
| ==== Alternativen ====
| |
|
| |
| Man kann alternative Ausdrücke mit dem „<tt>'''|'''</tt>“-Symbol zulassen.
| |
|
| |
| „ABC|abc“ bedeutet „ABC“ oder „abc“, aber z. B. nicht „Abc“.
| |
|
| |
| ==== Beispiele ====
| |
|
| |
| a|b* * "a", "b", "bb", "bbb", …<br/>
| |
|
| |
| (a|b)* * beliebig viele „a“ und „b“, einschließlich einer leeren Zeichenkette
| |
| * „“, „a“, „b“, „aa“, „ab“, „ba“, „bb“, „aaa“, …<br/>
| |
|
| |
| ab*(c|ε) * ε = leer
| |
| * Zeichenketten beginnend mit „a“
| |
| * kein- oder mehrmals „b“
| |
| * optional a "c": {"a", "ac", "ab", "abc", "abb", "abbc", ...} <br/>
| |
|
| |
| (0|(1(01*0)*1))* * set of binary numbers that are multiples of 3: { ε, "0", "00", "11", "000", "011", "110", "0000", "0011", "0110", "1001", "1100", "1111", "00000", ... }
| |
|
| |
| === Rangfolge der Regeln ===
| |
|
| |
| Ähnlich wie bei mathematischen Ausdrücken (Punkt- vor Strichrechnung) unterliegen die Verknüpfungsoperatoren einer Rangfolge: * Wiederholungen kommen vor Verkettungen
| |
| * Verkettungen vor "oder"
| |
| * Diese Regeln lassen sich durch Klammern überschreiben
| |
|
| |
| == Übungen und Beispiele ==
| |
|
| |
| === Einfache Übungen ===
| |
|
| |
| {| class="wikitable sortable"
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''Haus'''</tt>
| |
| | | Die Zeichenfolge "Haus"
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''^Haus'''</tt>
| |
| | | "Haus" am Zeilenanfang
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''Haus$'''</tt>
| |
| | | "Haus" am Zeilenende
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''^Haus$'''</tt>
| |
| | | "Haus" als einziges Wort in einer Zeile
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''[Hh]aus'''</tt>
| |
| | | "Haus" oder "haus"
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''Ha[unl]s'''</tt>
| |
| | | "Haus", "Hals" oder "Hans"
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''[^HML]aus'''</tt>
| |
| | | Weder "Haus", noch "Maus", noch "Laus", dafür aber andere Zeichenfolgen, welche "aus" enthalten
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''Ha.s'''</tt>
| |
| | | Der dritte Buchstabe ist ein beliebiges Zeichen
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''^...$'''</tt>
| |
| | | Jede Zeile mit genau drei Zeichen
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''^\.'''</tt>
| |
| | | Jede Zeile, die mit einem Punkt beginnt
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''^\.[a-z][a-z]'''</tt>
| |
| | | Jede Zeile, die mit einem Punkt und zwei Kleinbuchstaben beginnt
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''^\.[a-z]\{2\}'''</tt>
| |
| | | Wie oben, jedoch nur in grep und sed zulässig
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''^[^.]'''</tt>
| |
| | | Jede Zeile, die nicht mit einem Punkt beginnt
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''Fehler*'''</tt>
| |
| | | "Fehle"(!), "Fehler", "Fehlers", etc
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''"Wort"'''</tt>
| |
| | | Ein Wort in Anführunszeichen
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''"*Wort"*'''</tt>
| |
| | | Ein Wort mit beliebig vielen (auch keinen) Anführungszeichen
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''[A-Z][A-Z]*'''</tt>
| |
| | | Ein oder mehrere Großbuchstaben.
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''[A-Z]+'''</tt>
| |
| | | Wie oben, jedoch nur in egrep und awk zulässig
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''[A-Z].*'''</tt>
| |
| | | Ein Großbuchstabe, gefolgt von keinem oder beliebig vielen Zeichen
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''[A-Z]*'''</tt>
| |
| | | Kein, ein oder mehrere Großbuchstaben
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''[a-zA-Z]'''</tt>
| |
| | | Ein Buchstabe
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''[^0-9a-zA-Z]'''</tt>
| |
| | | Symbole (weder Buchstaben noch Zahlen)
| |
| |-
| |
| | | #
| |
|
| |
| | | <tt>'''[0-9a-zA-Z]'''</tt>
| |
| | | Jedes alphanumerische Zeichen
| |
|
| |
| |-
| |
| |}
| |
| === Beispiele für egrep- oder awk-Muster ===
| |
|
| |
| [567] * Eine der Zahlen 5, 6 oder 7
| |
|
| |
| fuenf|sechs|sieben * Eines der Worte fünf, sechs oder sieben
| |
|
| |
| 80[234]?86> * "8086", "80286", "80386", "80486"
| |
|
| |
| F(ahr|lug)zeug * "Fahrzeug" oder "Flugzeug"
| |
|
| |
| === Beispiele für vi-Muster ===
| |
|
| |
| \<The * Wörter wie "Theater" oder "Thema"
| |
|
| |
| ung\> * Wörter wie "Teilung" oder "Endung"
| |
|
| |
| \<Wort\> * Das Wort "Wort"
| |
|
| |
| === Beispiele für sed- oder grep-Muster ===
| |
|
| |
| 0\{5,\}* Fünf oder mehr Nullen in Folge
| |
|
| |
| [0-9]-[0-9]\{3\}-[0-9]\{5\}-[0-9X]* ISBN-Nummern in der Form n-nnn-nnnnn-n, das letzte Zeichen kann auch ein X sein
| |
|
| |
| === VIM-Beispiele ===
| |
|
| |
| Leerzeichen wurden durch _ Tabulatoren durch TAB eretzt. Ex-Befehle werden mit Doppelpunkt eingeleitet.# <tt>'''s/.*/( & )/'''</tt>
| |
|
| |
| Wiederholt die ganze Zeile, fügt aber Klammern hinzu
| |
|
| |
| # <tt>'''s/.*/mv & &.old/'''</tt>
| |
|
| |
| Formt eine Wortliste (ein Wort pro Zeile) zu mv-Befehlen um
| |
|
| |
| # <tt>'''/^$/d'''</tt>
| |
|
| |
| Löscht Leerzeilen
| |
|
| |
| # <tt>'''/^[_TAB]*$/d'''</tt>
| |
|
| |
| Löscht Leerzeilen und Zeilen, die nur aus Leerzeichen oder Tabulatoren bestehen
| |
|
| |
| # <tt>'''/ */ /g'''</tt>
| |
|
| |
| Wandelt ein oder mehrere Leerzeichen in ein Leerzeichen um
| |
|
| |
| # <tt>''':s/[0-9]/Element &:/'''</tt>
| |
|
| |
| Wandelt (in der aktuellen Zeile) eine Zahl in ein Label für ein Element um
| |
|
| |
| # <tt>''':s'''</tt>
| |
|
| |
| Wiederholt die Substitution beim ersten Vorkommen
| |
|
| |
| # <tt>''':&'''</tt>
| |
|
| |
| Wie oben
| |
|
| |
| # <tt>''':sg'''</tt>
| |
|
| |
| Wie oben, aber für alle Vorkommen in einer Zeile
| |
|
| |
| # <tt>''':&g'''</tt>
| |
|
| |
| Wie oben
| |
|
| |
| # <tt>''':%&g'''</tt>
| |
|
| |
| Wiederholt die Substitution im ganzen Puffer
| |
|
| |
| # <tt>''':.,$s/Wort/\U&/g'''</tt>
| |
|
| |
| Wandelt von der aktuellen bis zur letzten Zeile das Wort Wort in Großschreibung um
| |
|
| |
| # <tt>''':%s/.*/\L&/'''</tt>
| |
|
| |
| Wandelt die gesamte Datei in Kleinschreibung um
| |
|
| |
| # <tt>''':s/\<./\u&/g'''</tt>
| |
|
| |
|
| Wandelt den ersten Buchstaben jedes Wortes in der aktuellen Zeile in Großschreibung um
| | Einige Programme, etwa der [http://de.wikipedia.org/wiki/Texteditor Texteditor] [http://de.wikipedia.org/wiki/Vim Vim], ermöglichen, zwischen verschiedenen Syntaxen zu wechseln. |
| | * siehe [http://de.wikipedia.org/wiki/Portable_Operating_System_Interface POSIX.2] |
|
| |
|
| # <tt>''':%s/ja/nein/g'''</tt>
| | <noinclude> |
|
| |
|
| Ersetzt das Wort ja durch nein
| | == Anhang == |
| | === Siehe auch === |
| | {{Special:PrefixIndex/{{BASEPAGENAME}}}} |
|
| |
|
| # <tt>''':%s/Ja/~/g'''</tt>
| | ==== Links ==== |
| | ===== Weblinks ===== |
|
| |
|
| Ersetzt global ein anderes Wort (Ja) durch nein (Wiederverwendung des vorherigen Ersatzmusters)
| | [[Kategorie:Regular Expression]] |
|
| |
|
| [[Category:Linux:Bash:Scripting]]
| | </noinclude> |
| [[Category:Programmierung]]
| |