Javascript • Reguläre Ausdrücke – Suchen und Ersetzen

Javascript Regex: Reguläre Ausdrücke Zeigt den Regulären Ausdruck für eine deutsche Telefonnummer: Darf nur mit (, 0 oder + beginnen, nur Ziffern und Blanks enthalten und muss mindestens 7 Zeichen lang sein.

Reguläre Ausdrücke suchen mit einem »Muster« nach Zeichenfolgen – z.B. »Suche nach allen Wörtern, die mit einem großen D anfangen und mehr als drei Buchstaben haben«.

Regex sind die Königsdiziplin der Textverarbeitung. Es gibt sie nicht nur in Javascript, sondern wir begegnen Regulären Ausdrücken in nahezu allen Programmiersprachen.

Reguläre Ausdrücke werden "Regex" abgekürzt oder auch "Grep" genannt. Sie wurden schon 1956 von Stephan Kleene entwickelt und 1968 von Ken Thompson für den Unix-Editor ED implementiert.

Um im Editor ED nach einem Textmuster zu suchen, gab man

g/Regular Expression/p
^          ^        ^ 
|          |        |
|  Das Suchmuster   Ende des regulären Ausdrucks
|       
Anfang des regulären Ausdrucks 

ein. Darum wird die Suche mit regulären Ausdrücken auch GREP genannt. Und da Henry Spenver 1968 eine C-Library für Regular Expressions schrieb, ist die Suche mit Regex oder Grep in allen Programmiersprachen bis auf subtile kleine Unterschiede konsistent.

Reguläre Ausdrücke – nicht nur in Javascript

Regex ist das Werkzeug für die Suche und das Ersetzen auf der Kommandozeile und in Programmiersprachen wie C, C++, Java, Perl, Python, Ruby, PHP und Javascript. Regex sind sozusagen eine eigene kleine Programmiersprache in einer anderen Programmiersprache und bestehen aus Kombinationen von Buchstaben, Ziffern, Wildcards und anderen Sonderzeichen. Sie sehen schnell aus, als hätte die Katze die Tastatur in Beschlag genommen.

Postleitzahlen und die ISBN-Nummern von Büchern lassen sich durch einfache Muster beschreiben, Emailadressen und HTML-Tags folgen einem komplexeren Muster.

Deutsche Postleitzahlen: D-27321 // D gefolgt von Bindestrich/Leerzeichen
                                    gefolgt von 5 Ziffern

ISBN-Nummer: 978-3-442-54631-2   // 3 Ziffern (entweder 978 oder 979)
                                    gefolgt von einem Bindestrich
                                    gefolgt von 1 bis 5 Ziffern …

Emailadresse: jemand@irgendwo.de // Zeichenfolge gefolgt von @
                                    gefolgt von Zeichenfolge 
                                    gefolgt von Punkt
                                    gefolgt von Zeichenfolge

Regulärer Ausdruck: Emailadresse

Die Emailadresse ist nicht ganz so einfach wie in der Kurzbeschreibung oben. k.h.schulze-delisch oder karl+petra.schulze, gefolgt von einem @-Zeichen. Der Domainname der Emailadresse muss einen Punkt enthalten gefolgt von 2 bis 6 Zeichen.

E-Mail-Adresse bei Wikipedia

\b[\w.+-]+@[\w.-]+\.[a-zA-Z]{2,6}\b
\b
Wortgrenze
[\w.+-]
Ein Wort aus Buchstaben oder Ziffern, aber keine Leerzeichen.
.+-
Liste von erlaubten Zeichen
+
Quantifier oder Zähler: Einmal oder beliebig oft. So gelten Wörter mit beliebig vielen Punkten, +-Zeichen, Bindestrichen.
@
@-Zeichen
[\w.-]
gefolgt von Wort aus Buchstaben oder Ziffern und . (Punkt) oder - (Bindestrich), aber keine Leerzeichen
+
Quantifier oder Zähler: Einmal oder beliebig oft.
\.
Genau ein Punkt. Der Schrägstrich "escaped" den Punkt, denn der Punkt ist das Wildcard-Zeichen im Regex und der Schrägstrich sagt: Nimm einfach das Zeichen, nicht das Wildcard.
[a-zA-Z]
Nur Buchstaben von a bis z und A bis Z (keine Umlaute)
{2,6}
Mindestens 2, höchstens 6

Regex für deutsche Telefonnummer

Das Prüfen von Telefonnummern ist zum Scheitern verdammt: Wir geben Telefonnummern mit Klammern für die Vorwahl an, mit Bindestrichen und Schrägstrichen, geben Vorwahlen mit und ohne führende Nullen ein. Manche setzen ein "+" vor die Ländervorwahl, andere nicht.

Das hier funktioniert im Großen und Ganzen recht zuverlässig: Eine Telefonnummer beginnt mit Null oder Klammer auf oder einem Pluszeichen, gefolgt von Ziffern, Punkten, Bindestrichen, runden Klammern, Schrägstrichen. Mindestens 7 Zeichen müssen es insgesamt sein. Telefonnummern ohne Vorwahl werden nicht akzeptiert.

^([0(+][0-9\.-\/ ()]{7,})$
^
Wortgrenze (wie das \b)
[0(+]
beginnt mit einem dieser drei Zeichen: 0, runde Klammer auf oder Pluszeichen
[0-9\.-\/ ()]
erlaubt sind Ziffern, Punkte, Bindestriche, Schrägstrich, runde Klammern
{7,}
mindestens 7 Zeichen müssen vorhanden sein
$
Wortgrenz

Metazeichen

Am einfachsten ist natürlich die literale (wörtliche) Suche: /auto/ findet auto und automatisch. /go/i findet go in Logo, Gocart und in »Kaffee-to-Go«.

Der Punkt "." ist das Wildcart-Zeichen in Regulären Ausdrücken. Ein Punkt trifft jedes Zeichen außer Newline. Darum setzt man in einem regulären Ausdruck immer besser einen Backshlash.

/lei.e/i findet Leiden, Leiter, leise, Schleife

Wenn hingegen ein Punkt gefunden werden soll, wird der Punkt durch einen Backslash »escapt«:

/media\.de/ findet http://www.media.de

Reguläre Ausdrücke werden mit speziellen Sonderzeichen gesucht. Die meisten regulären Ausdrücke starten mit ^ für den Anfang eines Strings und enden mit $ für das Ende des Strings.

                                                    /^Matrix$/
                                                    ||  |   ||
                     /: öffnende Begrenzung  <------+|  |   ||
                                                     |  |   ||
     ^: Sonderzeichen für Anfang des Strings  <------+  |   ||
                                                        |   ||
        Matrix: wörtlicher Teil des Suchmusters  <------+   ||
                                                            ||
              $: Sonderzeichen für Ende des Strings  <------+|
                                                             |
                         /: Schliessender Begrenzer   <------+   

Durch die Sonderzeichen für Anfang und Ende des Strings findet /^Matrix$/ »Matrix« in einem String, der genau »Matrix« und nicht mehr und nicht weniger enthält.

Suchmuster suchen häufig nach Zeichenfolgen, die am Anfang oder am Ende einer Worts oder eines Strings sitzen.

Das Metazeichen \b steht für Wortanfang und Wortende.

                                                     /\bFische\b/ 
                                                     ||   |   | |
                      /: öffnende Begrenzung  <------+|   |   | |
                                                      |   |   | |
                               \b: Wortgrenze  <------+   |   | |
                                                          |   | |
          Fische: wörtlicher Teil des Suchmusters  <------+   | |
                                                              | |
                                        \b: Wortgrenze <------+ |
                                                                |
                            /: Schliessender Begrenzer   <------+ 

findet Fische in "Fischers Fritz fischt frische Fische", nicht aber Fischers.

Ein senkrechter Strich (pipe) | trennt Alternativen voneinander.

                                               /°Häßler|Haessler$/ 
                                                |   |  |    |   |
 ^: Sonderzeichen für Anfang des Strings <------+   |  |    |   |
                                                    |  |    |   |
    Häßler: wörtlicher Teil des Suchmusters  <------+  |    |   |
                                                       |    |   |
                                       |: oder  <------+    |   |
                                                            |   |
          Haessler: wörtlicher Teil des Suchmusters  <------+   |
                                                                |
                                   $: Ende des Strings   <------+   

findet Häßler oder Haessler in einem String, der genau "Häßler" oder "Haessler" lautet.

Mit einem nachgestellten Fragezeichen darf das vorangehende Zeichen genau einmal oder gar nicht vorkommen kann.

var regex = /rgb\(\d+,\s\d+,\s\d+\)/;
                                                      /rgb\(\d+,\s\d+,\s\d+\)/
                                                       |   | | | |
                                    findet rgb  <------+   | | | |
                                                           | | | |
           die öffnende Klammer muss escapt werden  <------+ | | |
                                                             | | |
                            ein oder mehrere Ziffern  <------+ | |
                                                               | |
                                       das erste Komma  <------+ |
                                                                 |
                               ein oder kein Leerzeichen  <------+

findet rgb(139, 158, 167) in einer Zeichenkette

Modifier

Modifier sind der intuitivste Teil von regulären Ausdrücken. Modifier stehen am Ende des regulären Ausdrucks hinter dem schliessenden Begrenzer und legen globale Änderungen über den gesamten regulären Ausdruck.

In Javascript gibt es drei Modifier: g (global) veranlasst den Javascript-Interpreter, die Operation auf den gesamten String auszudehnen. Ansonsten sucht oder ersetzt der Interpreter nur erste Vorkommen des Suchmusters.

i (ignore case) schaltet die Unterscheidung zwischen Groß- und Kleinschreibung aus, die ansonsten der Standard ist.

m (multiline) findet Suchmuster am Anfang oder am Ende einer Zeichenkette. Der Modifier m wird ab Javascript 1.5 interpretiert.

Basiszeichen, Metazeichen, Zeichenklassen und Wiederholungen

Basiszeichen
\wBuchstabe, Ziffer oder Unterstrich
\WEin Sonderzeichen
\dEine Ziffer zwischen 0 bis 9
\DEin Zeichen, das keine Ziffer ist
\sEin Weißraum (Leerzeichen, Zeilenumbruch usw.)
\SJedes Zeichen außer Weißraum
\bWortgrenze
\Bkeine Wortgrenze
Metazeichen
. findet alle Zeichen außer Zeilenende
^ Anfang eines Strings
$ Ende eines Strings
| Alternativen
() Teile des Suchmusters abgrenzen
[] Zeichenklassen
{} Replikatoren
Zeichenklassen
[xyz] beliebiger Buchstabe x, y oder z
[^xyz] jeder Buchstabe außer x, y oder z
[0-9] jede Ziffer zwischen 0 bis 9
[a-z] jeder kleine Buchstabe von a bis z
[A-Za-z0-9] alle Buchstaben und Ziffern
[a-zß-ü] alle Kleinbuchstaben und Umlaute
Replikatoren
{n,m} mindestens n mal, höchstens m mal
{n,} mindestens n mal
{n} genau n mal
* 0 mal oder öfter, äquivalent zu {0,}
+ 1 mal oder öfter, äquivalent zu {1,}
? 0 oder 1 mal, äquivalent zu {0,1}

Kurzschreibweisen für Buchstaben, Ziffern und Leerzeichen

Die Basiszeichen suchen nach Buchstaben, Ziffern und Leerzeichen – teilweise sind sie eine Kurzschreibweise für Zeichenklassen. Groß- und Kleinschreibung unbedingt beachten!

\w
Findet alle Buchstaben, Zahlen und Unterstriche und kann auch durch die Zeichenklasse [a-zA-Z0-9_] dargestellt werden. Umlaute und ß hingegen zählen zu den Sonderzeichen.
Suche nach allen Strings, die mit Ha anfangen, gefolgt von zwei beliebigen Buchstaben, Zahlen oder Unterstrichen gefolgt von einem o:
/ Ha \w \w o / g
  ^  ^  ^
  |  |  |
  |  |  +------> gefolgt von einem kleinen o
  |  |
  |  +------> gefolgt von zwei Buchstaben, Zahlen oder Unterstrichen
  |
  +------> Suchmuster beginnt mit Ha

console.log (/Ha\w\wo/g.test('Hallo Hanno, hattest du Glück?'))
true
console.log ('Hallo Hanno! Hattest du Glück?'.match(/Ha\w\wo/g))
["Hallo", "Hanno"]
\W
Findet alle Zeichen außer Buchstaben, Zahlen oder Unterstriche.
Sucht nach allen Strings, die nicht mit einem Buchstaben, einer Zahl oder einem Unterstrich anfangen gefolgt von einem Leerzeichen.
/\W /g
  ^^
  ||
  |+------> gefolgt von einem Leerzeichen
  |
  +------> Erstes Zeichen ist weder Buchstabe, Zahl noch Unterstrich

console.log('Hallo Hanno! Hattest du Glück?'.match(/\W /g));
["! "]
\d
Findet alle Ziffern von 0 bis 9.
Sucht Dateinamen, die mit DSC anfangen, gefolgt von vier Ziffern, gefolgt von .tif oder TIF – ein Klassiker der Dateinamen aus Digitalkameras.
Muster: /dsc\d+.jpg/gi
String: <img src="DSC4608.jpg"><img src="DSC4610.JPG"><img src="dsc4700.JPG">

console.log(string.match(/dsc\d+.jpg/gi));
["DSC4608.jpg", "DSC4610.JPG", "dsc4700.JPG"]
  
Beispiel:                   if (/\d+[\.|,]?\d*/.test(string)) 
                                 ^   ^ ^^ ^ ^
                                 |   | || | |
\d+: mindestens eine Ziffer  <---+   | || | |
                                     | || | |
    \.: gefolgt von einem Punkt  <---+ || | |
                                       || | |
                           |: oder <---+| | |
                                        | | |
                    ,: einem Komma  <---+ | |
                                          | |
    ?: Punkt oder Komma dürfen einmal <---+ |
       oder keinmal auftreten               |
                                            |
    d*: gefolgt von 0 oder mehr Ziffern <---+
\D
Alle Zeichen, die keine Ziffern sind
Sucht ebenfalls Dateinamen, aber diese Namen von Bilddateien aus der Digitalkamera beginnen mit einem Unterstrich. Gesucht werden TIFF-Dateien:
Muster: /\D{4}\d{4}\.tif/gi

String: _DSC4608.tif oder _DSC4610.jpg oder _DSC4700.TIF oder _DSC4610.tif 
        und ein Defekt: _DSC4611?tif

Findet: _DSC4608.tif,_DSC4700.TIF,_DSC4610.tif
\b
Wortgrenze
Testet, ob das class-Attribut eines HTML-Tags die Klasse showImg enthält:
Muster: /\bshowImg\b/

String: showImg2 content showImg

Findet: liefert einen Treffer zurück
\B
Jede Position, die keine Wortgrenze ist
Muster: /\Bsee/gi
String: See, Wannseebad, Nordsee
Findet: See, Wannseebad, Nordsee
\s
Alle Whitespace-Zeichen – das sind alle Arten von Leerzeichen vom einfachen „Blank“ über Tabulatoren bis hin zum Zeilenumbruch.
Eliminiert den Weißraum (Leerzeichen, Zeilenumbrücke, Tabulatoren) zwischen HTML-Tags:
Muster: />\s*</g   // ersetzen durch ><
	
String: <dt id="jsregSS">\s </dt>
	   <dd>Alle Whitespace-Zeichen ….</dd>
	   <dd>Findet den Weißraum zwischen HTML-Tags: </dd>
	
Ersetzung: <dt id="jsregSS">\s </dt><dd>Alle Whitespace-Zeichen
…</dd><dd>Findet den Weißraum zwischen HTML-Tags: </dd>
\S
Alle einzelnen Zeichen, die kein Whitespace sind.
Muster: /\Sa/gi     
String: Wandern andere „an“
Findet: Wandern andere „an

Metazeichen

Metazeichen sind einfache Sonderzeichen wie ein Punkt und der senkrechte Strich, die in regulären Ausdrücken eine andere Bedeutung haben als in einem ganz normalen Suchstring.

Damit der reguläre Ausdruck ein Zeichen nicht als Sonderzeichen (hierzu zählen der Begrenzer / und auch der .), sondern als normales Zeichen auffasst, wird dem Zeichen ein umgekehrter Schrägstrich (Backslash) vorangestellt: /\// trifft das erste Vorkommen eines /-Zeichens und /\/\/www/ das erste Vorkommen von //www.

. (Punkt)
findet alle Zeichen. Der Punkt erinnert an den *-Joker bei der Suche nach Dateinamen unter Windows und Mac. Im Gegensatz zu regulären Ausdrücken in Perl oder Grep findet der Punkt kein Zeilenende!
Muster: /./ 
String: James Bond        Findet: J, a, m, e, s,  , B, o, n, d
String: \n\r              Findet: kein Treffer
^ (Caret)
steht für den Anfang eines Strings und darf nicht mit dem Caret-Zeichen verwechselt werden, das in eckigen Klammern eine Negierung bewirkt.
Muster: /^Von/
String: Von 3 bis 4, von 2 bis 5     Findet: Von 3 bis 4, von 2 bis 5
$ (Dollar)
kennzeichnet das Ende eines Strings und kann auch nur am Ende des regulären Ausdrucks vor dem schließenden Schrägstrich stehen.
Muster: /10$/
String: 10 vor 10                    Findet: 10 vor 10
Muster: /^Martha$/
String: Unsere Martha                Findet: kein Treffer
| (Senkrechter Strich)
Angabe von Alternativen
Muster: /H(ä|ae)(ß|ss)ler/g    // Sucht unterschiedliche Schreibweisen 
	
String: Ulrike Häßler
        Ulrike Haessler
        Ulrike Haeßler

Findet: Häßler,Haessler,Haeßler
() (runde Klammern)
Ein Ausdruck in runden Klammern fasst Teile des Suchmusters zusammen und grenzt es von anderen Suchmustern ab. Ausdrücke in runden Klammern bilden Unterausdrücke, die sich später durch sogenannte Rückverweise (Backreference) ansprechen lassen. Rückverweise in regulären Ausdrücken erlauben z.B. den Tausch der Position von Strings.
Muster: /Ann (H|M)/g    
String: Ann H., Ann M., Ann S.      Findet: Ann H., Ann M., Ann S.

Muster: /(a|b)(c|d)/
Findet: alle Zeichenketten ac, ad, bc oder bd

Muster /(A(b|c)|DEF)/
Findet: alle Zeichenketten Ab, Ac oder DEF
[ ] (eckige Klammern)
grenzt eine Liste von Zeichen an einer bestimmten Position der Zeichenkette weiter ein.
Muster: /S[abc]/g  
String: Sache, Sinn, Schaden
Findet: Sache, Sinn, Schaden

Zeichenklassen

Viereckige Klammern legen eine Zeichenklasse fest. Eine Zeichenklasse steht an ihrer Position im String für eine Gruppe von Zeichen – z.B. legt S[a-h] fest, dass an der Stelle hinter dem S ein Buchstabe von a bis h stehen muss.

Innerhalb der viereckigen Klammern verlieren alle Metazeichen außer dem Circumflex und dem Backslash ihre Bedeutung und müssen nicht maskiert werden. Der Circumflex am Anfang einer Zeichenklasse negiert die Zeichen – S[^a-e] legt fest, dass nach dem großen S kein Buchstabe aus dem Bereich a bis e stehen darf. Steht der Circumflex nicht am Anfang der Zeichenklasse – S[a-e^] – verliert er seine besondere Bedeutung und hier wird nach dem großen S gefolgt von einem Buchstaben von a bis e oder einem Circumflex gesucht.

[xyz]
Findet alle Zeichen innerhalb der eckigen Klammern.
Sucht nach Zeichenketten, die ein D oder ein R an der zweiten Stelle aufweisen
Muster:                                     /<[DR]\w/g
                                             |  |  |
             \w: Beliebiger Buchstabe <------+  |  |
                                                |  |
              [DR]: gefolgt von D oder R <------+  |
                                                   |
\w: gefolgt von einem beliebigen Buchstaben <------+ 

String: ARD, WDR, RTL, PRO7, MDR, BR

Findet: ARD,WDR,PRO,MDR
[^xyz]
Der Circumflex innerhalb einer Zeichenklasse grenzt eine Liste von Zeichen an einer bestimmten Position der Zeichenkette aus.
Sucht nach allen Zeichenketten, die mit S beginnen und an der zweiten Stelle kein a, b oder c enthalten:
Muster:                                           /S[^abc]\w*/g
                                                   |  |   | |
                             S: Buchstabe S <------+  |   | |
                                                      |   | |
        [^abc]: nicht gefolgt von a, b, oder c <------+   | |
                                                          | |
       \w: gefolgt von einem beliebigen Buchstaben <------+ |
                                                            |
*: vorangehendes Zeichen darf beliebig oft vorkommen <------+                                                   
	
String: Sinn, solche Sachen, so ein Schaden, Sonderfall, Sonne und Regen

Findet: Sinn,Sonderfall,Sonne
[a-z]
Alle Zeichen von a bis z.
Sucht alle Wörter, die mit T oder t anfangen und einen Bindestrich enthalten können:
Muster: /\bT[a-zß-ü-]*/gi

String: Tor T-Shirt Torbögen, der junge Törleß
        Torwart Torè Toraç Torø

Findet: Tor,T-Shirt,Torbögen,Törleß,Torwart,Torè,Toraç,Torø
[0-9]
Alle Ziffern von 0 bis 9
Sucht alle Zahlen am Anfang einer Zeile, die mit 5 anfangen
Muster:                                             /^5[0-9]*/gm
                                                     ||  |  | ||
                   ^: Anfang der Zeichenkette <------+|  |  | ||
                                                      |  |  | ||
                  5: Erstes Zeichen ist eine 5 <------+  |  | ||
                                                         |  | ||
      [0-9]: gefolgt von einer Ziffer von 0 bis 9 <------+  | ||
                                                            | ||
*: vorangehendes Zeichen darf beliebig oft vorkommen <------+ ||
                                                              ||
                                 g: im gesamten String <------+|
                                                               |
                                      m: in jeder Zeile <------+
String: 50074 Irgendwo
        2700 Zinnsoldaten
        59245 Leitzahl
        5 oder 5700

Findet: 50074,59245,5
[A-Za-z0-9]
alle Buchstaben und Ziffern, aber keine Umlaute
[a-zß-ü]
alle Kleinbuchstaben und kleinen Umlaute
[A-ZÀ-Ü] sucht nach allen Großbuchstaben und großen Umlauten und erwischt neben den Umlauten der deutschen Sprache auch die groß geschriebenen Ç, É und Õ.

Umlaute haben ein schweres Leben in regulären Ausdrücken. Wunderbarer Weise erwischt ß-ü das ß und alle Umlaute der deutschen Sprache sowie das Accent Egue der Franzosen, die Ligatur æ und ein Cedilla, äquivalent dazu liefert À-Ü die groß geschriebenen Umlaute der westeuropäischen Zeichen.

Replikatoren

Replikatoren legen minimale, maximale oder exakte Anzahlen für ein oder mehrere Zeichen fest. Ohne die Angabe von Replikatoren nimmt der Javascript-Interpreter an, dass ein Zeichen genau einmal vorkommen muss.

{n}
Das vorangestellte Zeichen muss genau n mal vorkommen
Muster: /20{3}/
Treffer: 2000 und 2004
{n,}
Steht für eine Anzahl von mindestens n Zeichen
Muster: /^[0-9]{5}$/ String: 57366 Findet: 57366
{n,m}
Steht für eine Anzahl von mindestens n, aber höchstens m Zeichen.
Muster: /_DSC\d{4}.TIF/i

String: _DSC4608.tif 
        _DSC4610.tif 
        _DSC4700.TIF

Findet: _DSC4608.tif,_DSC4610.tif,_DSC4700.TIF
?
Das vorangestellte Zeichen darf genau null mal oder einmal in der Zeichenkette vorkommen.
Muster: /\D?\d{6}/g findet in einem Nummerkreis aus sechs Ziffern, in dem Ziffern ein Buchstabe vorangestellt sein kann
Treffer: D100345, 2000, 234567, D18254, 1234
*
Das vorangestellte Zeichen kann 0 mal oder beliebig oft vorkommen. Mit großer Vorsicht zu verwenden: /a*/ trifft auf jeden String zu, denn ein a ist immer drin oder nicht drin.
Muster: /a*/
Treffer: Dunkelheit und Sonnenschein
+
Das vorangestellte Zeichen muss mindestens einmal, kann aber auch mehrmals vorkommen.
Sucht nach allen Tags und ersetzt sie durch einen Leerstring "":
Muster:                                                        /<[^<]+</g
                                                                |  | ||
                           <: Zeichenkette beginnt mit < <------+  | ||
                                                                   | ||
                                 [^<]: Alle Zeichen außer < <------+ ||
                                                                     ||
+: vorangestelltes Zeichen ([^<]) muss mind. einmal vorkommen <------+|
                                                                      |
                                    <: Zeichenkette ende mit < <------+
		
String: <dl>
            <dt id="jsregUmlaute">[a-zß-ü]</dt>
            <dd>alle Kleinbuchstaben und kleinen Umlaute</dd>
            <dd>[A-ZÀ-Ü] sucht nach allen Großbuchstaben und großen Umlauten</dd>
        </dl>	
        <p>Umlaute haben ein schweres Leben.</p>

Ersetzung: [a-zß-ü]
           alle Kleinbuchstaben und kleinen Umlaute
           [A-ZÀ-Ü] sucht nach allen Großbuchstaben und großen Umlauten
	
           Umlaute haben ein schweres Leben.
Auf diesselbe Weise werden Hochkommas gesucht: /"[^"]+"/g

Backtracking

Bei der Auswertung eines regulären Ausdrucks liest der Interpreter die Zeichenkette Zeichen für Zeichen ein und vergleicht jedes Zeichen mit der entsprechenden Stelle des regulären Ausdrucks. Dabei merkt sich der Interpreter die Stellen, an denen es mehr als eine Möglichkeit gibt und wenn der Interpreter beim Testen einer Variante feststellt, dass der Gesamtausdruck nicht mehr zutrifft, kehr er an diese Stelle zurück und prüft die Alternative.

Dieses „Backtracking“ erlaubt numerierte Rückbezüge auf geklammerte Ausdrücke. Alle Ausdrücke in runden Klammern bilden Gruppen, die von links nach rechts durchnummeriert werden.

(Meier)|(H(ä|ae)(ß|ss)ler)
0 -> Meier
1 -> Häßler
2 -> äß
3 -> äss
4 -> aeß
5 -> aess
/^([0(+][0-9\.-\/ ()-]{7,})$/ REGEX