Reguläre Ausdrücke (allgemein)

Hinweis auf regex101.com für das Experimentieren mit Regulären Ausdrücken .

Regulärere Ausdrücke (engl. regular expression, Abk. RegExp oder Regex) sind ein sind ein mächtiges Mittel, um Zeichenketten zu filtern (denkbaren Zeichenkombinationen zu finden, to match) und komplizierte Textersetzungen durchzuführen.
Historisches Ursprung regulärer Ausdrücke

Reguläre Ausdrücke wurden zu einem unverzichtbaren Bestandteil von zeichenverarbeitenden Sytemen (z.B. textbasierten Editoren, Suchtools, XSLT, usw). Reguläre Ausdrücke können für Transformationen von Zeichenfolgen in modifizierte Zeichenfolgen (z.B.Suchen-und-Ersetzen) verwendet werden.

Werden reguläre Ausdrücke von ECMAScript unterstützt? JavaScript ab 1.2 unterstützt reguläre Ausdrücke (und verwendet die Syntax wie Perl 5). Ein regulärer Ausdruck wird als eine Folge von Zeichen zwischen /.../ angegeben ( oder als ein ECMAScript-String ), der dem Konstruktor RegExp() übergeben wird.

Spezielle Literalzeichen (Beispiele) Meta-Character mit spezieller Bedeutung

Bei der Regulären Ausdrücken gibt es Zeichen, die besondere Bedeutungen haben und Meta-Character genannt werden.

Die folgenden Meta-Character (RegExpr-Literalzeichen) haben eine besondere Bedeutung:

 \    /    *    +    ?    |    {    [    (    )    ^    $    .    #    white space 

Beispiele:
Mit den Variablen
var s = "n91 nr82 nr73 nrNN", r = [];
liefert die Ausgabe alert( '[' + r.join(", ") + ']') die folgende Anzeige:

s.replace(/nr./g,     function(str){r.push(str);}) => [nr8, nr7, nrN]

s.replace(/nr[\s\S]/g,function(str){r.push(str);}) => [nr8, nr7, nrN]

s.replace(/nr?/g,     function(str){r.push(str);}) => [n, nr, nr, nr]

s.replace(/nr\d/g,    function(str){r.push(str);}) => [nr8, nr7]

s.replace(/nr[0-9]/g, function(str){r.push(str);}) => [nr8, nr7]
Welche Funktionen gibt es? .replace(), .split(), .match(), .test(), .exec()

Es gibt 2 Schreibweisen für reguläre Ausdrücke: /RegExpLiteral/glob für feste RegExpr und new RegExp("RegExpStr",glob) für dynamische RegExpr. Soweit möglich wird die Form /RegExpLiteral/glob bevorzugt. new RegExp("RegExpStr",glob) wird z.B. gebraucht, wenn aus einer Tastatureingabe ein RegExp erzeugt werden muß. Es gibt die beiden Schreibweisen:

Beispiel: Für 1. Methode: \r?\n     matches a new line
Beispiel: Für 2. Methode: \\r?\\n   matches a new line

  Muster Muster
1. var re = /RegExpLiteral/glob; Muster für regulären Ausdruck können mit /RegExpLiteral/ begrentzt werden.
Beispiel: var re = /\r?\n/g;
2. var re = new RegExp("RegExpStr","glob"); Muster für regulären Ausdruck können mit "..." begrentzt werden.
Beispiel: var re = new RegExp("\\r?\\n", "g");

Mögliche "Schalter" sind:

 var re = /RegExpLiteral/glob        // fester RegExp 
 var re = new RegExp(RegExpStr,glob) // verwende in RegExpStr "\\" anstelle "\"
 glob = "i";  // (ignoreCase, Groß-/Kleinschreibung ignorieren)
 glob = "g";  // (global,     globale Suche nach allen Treffern)
 glob = "gi"; // (            globale Suche, Groß/Klein ignorieren)
 glob = "m";  // (multiline,  globale Suche nach allen Treffern)
 lastIndex    // Index, an dem das nächste exec-Match beginnt
 source       // Quelltext des regulären Ausdruckes

Beispiele für typische Funktionen sind:

   var src = "mein text";
   var arr = src.split  (SplitRe);
   var b   = /re/.test("str"); // kein g Flag
   var s1  = src.match  ( re, "glob"); 
   var s2  = src.replace( re, "ReplStr");
   var s3  = src.replace( re, "$2,$1");
   var re  = new RegExp ("re", "glob");
   var Arr = re.exec(src);
Meta-Character maskieren Bsp.: \n \f \r \t \v \? \* \+ \. \| \{ \} \\ \[ \] \( \) \050 \x28 \u00A3

Sollen in einem String z.B. alle Punkte "." gesucht werden, so muß das Suchzeichen maskiert werden mit "\."

 \n       matches a new line                 \|      matches |  
 \f       matches a form feed                \{      matches {  
 \r       matches carriage return            \}      matches }  
 \t       matches horizontal tab             \\      matches \  
 \v       matches vertical tab               \[      matches [  
 \?       matches ?                          \]      matches ]  
 \*       matches *                          \(      matches (  
 \+       matches +                          \)      matches )  
 \.       matches .  
 \xxx     matches the ASCII character expressed by the octal number xxx.
 \050     matches " 
 \xdd     matches the ASCII character expressed by the hex number dd.
 \x28     matches "   
 \uxxxx   matches the unicode-character expressed by the UNICODE xxxx.
 \u00A3   matches £   
Klammer-Ausdrücke von RegExp "einfangende Ausdrücke"

Geklammerte (Unter-) Ausdrücke in RegExpr speichern gewöhnlich den geklammerten Ausdruck ("einfangende Ausdrücke").

Im folgenden Beispiel wird die erste geklammerte Zeichenfolgen (RegExp.$1) verwendet, um eine URL, wie "http://www.fh-giessen.de/~hg54/mmk/index.htm" zu untersuchen.

(\w+):\/\/([^/:]+)(:\d*)?([^# \r\n]*?)

Die geklammerten Unterausdrücke (von links nach rechts) entsprechen den RegExp.$1, RegExp.$2, RegExp.$3, usw. und liefern für "http://www.fh-giessen.de/~hg54/mmk/index.htm"

RegExp.$1=http
RegExp.$2=www.fh-giessen.de
RegExp.$3=/~hg54/mmk/index.htm
Beispiele mit var str_neu = str.replace(/find/glob, repl); Suchen und Ersetzen ...

Es wird Durch var str_neu = str.replace(/find/glob, repl);

Ersetze 'white char' durch 'X'

Code Snippet: Ersetze 'white char' durch 'X'
  1. var out1 = "Anzeige s1 =", out2 = "Anzeige s2 =";
  2. var s1 = "'white char' durch '-'".replace(/\s+/, "X");
  3. var s2 = "'white char' durch '-'".replace(/\s+/g, "X");
  4.  
  5. document.getElementById('OUT1').innerHTML = out1 + s1 + '<br />' + out2 + s2;


Vertausche 4-stellige und 5-stellige Zahlen

Code Snippet: Vertausche 4-stellige und 5-stellige Zahlen
  1. var s3 = "tel (54321) plz 4711".replace(/^.+\((\d{5})\).+(\d{4})$/g, "PLZ $1 TEL $2");
  2.  
  3. document.getElementById('OUT2').innerHTML = "Anzeige s3 =" + s3;


Verwende anstelle eines "replace-Strings" eine Funktion

Code Snippet: Verwende anstelle eines "replace-Strings" eine Funktion
  1. var s4 = "1 > 2 & x > y",
  2. o = { '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;' };
  3.  
  4. var s4 = s4.replace(/[<>&"]/g, function (c) { return o[c]; });
  5.  
  6. document.getElementById('OUT3').innerHTML = "Anzeige s4 =" + s4;



Dieses Beispiel verwendet anstelle eines Ersetzungstrings (Repl-String) eine Funktion, der die gefundenen Strings übergeben werden und deren Rückgabestring dann der Ersetzungsstring ist.

function func(s) {return s.toLowerCase();}

src = "AB Ab ÄB";

re  = new RegExp("AB","gi");
src = new String(src).replace(re, func);

document.write("src = "+src);
Beispiel: Browser-Identifizierungen Welcher Browser ist es?

Der folgende RegExpr kann zur Browser-Identifizierung dienen.

 ^Mozilla[^(]*\([C|c]ompatible;\s*MSIE (?'version'(?'major'\d+)(?'minor'\.\d+)(?'letters'\w*))(?'extra'[^)]*)
Bemerkungen zu PHP-RegExp Was ist anders?

Hinweis auf regex101.com für das Experimentieren mit Regulären Ausdrücken . PHP-Funktionen (Beispiele):

  mixed preg_replace(mixed $pattern, mixed $replacement, mixed $subject[,int $limit[,int &$count]] )
  mixed  str_replace(mixed $search,  mixed $replace,     mixed $subject[,int &$count] )

Spezielle Zeichen-Definitionen (Meta-Charakter):

\ Quote the next metacharacter
^ Match the beginning of the line
. Match any character (except newline)
$ Match the end of the line (or before newline at the end)
| Alternation
() Grouping
[] Character class
* Match 0 or more times
+ Match 1 or more times
? Match 1 or 0 times
{n} Match exactly n times
{n,} Match at least n times
{n,m} Match at least n but not more than m times
More Special Character Stuff
\t tab (HT, TAB)
\n newline (LF, NL)
\r return (CR)
\f form feed (FF)
\a alarm (bell) (BEL)
\e escape (think troff) (ESC)
\033 octal char (think of a PDP-11)
\x1B hex char
\c[ control char
\l lowercase next char (think vi)
\u uppercase next char (think vi)
\L lowercase till \E (think vi)
\U uppercase till \E (think vi)
\E end case modification (think vi)
\Q quote (disable) pattern metacharacters till \E
Even More Special Characters
\w Match a "word" character (alphanumeric plus "_")
\W Match a non-word character
\s Match a whitespace character
\S Match a non-whitespace character
\d Match a digit character
\D Match a non-digit character
\b Match a word boundary
\B Match a non-(word boundary)
\A Match only at beginning of string
\Z Match only at end of string, or before newline at the end
\z Match only at end of string
\G Match only where previous m//g left off (works only with /g)