Programmieren mit regulären Ausdrücken

Mithilfe von regulären Ausdrücken in JScript können Sie in einer Zeichenfolge nach Mustern suchen, Text ersetzen und Teilzeichenfolgen extrahieren.

Suchen

Im folgenden JScript-Beispiel werden alle Vorkommen eines Worts gesucht.

Der reguläre Ausdruck wird mit der folgenden Anweisung erstellt:

var re = /\w+/g;

Das Muster /\w+/ gibt an, dass eine Entsprechung für eines oder mehrere der folgenden Zeichen gefunden werden soll: A-Z, a-z, 0-9 und der Unterstrich. Das g-Flag (global), das dem Muster entspricht, gibt an, dass bei der Suche alle Vorkommen des Musters gesucht werden sollen, und nicht nur das erste.

Sie können auch folgende JScript-Syntax verwenden:

var re = new RegExp("\\w+", "g");

Um alle Entsprechungen zu finden, setzt exec-Methode die Suche beginnend bei lastIndex fort, bis NULL zurückgegeben wird.

function SearchGlobal()
{
    var src = "The quick brown fox jumps over the lazy dog.";

    // Create a regular expression pattern that has a global flag.
    var re = /\w+/g;

    var result;

    // Get the first match.
    result = re.exec(src);
    while (result != null)
    {
        print (result.index + "-" + result.lastIndex + "\t" + result[0]);

        // Get the next match.
        // Because the global flag is set, the search starts at the
        // position of lastIndex.
        result = re.exec(src);
    }

    // Output:
    //  0-3 The
    //  4-9 quick
    //  10-15 brown
    //  16-19 fox
    //  20-25 jumps
    //  26-30 over
    //  31-34 the
    //  35-39 lazy
    //  40-43 dog
}

Im folgenden Beispiel wird nur die erste Entsprechung gesucht. Da das globale Flag (g) nicht festgelegt wurde, startet die Suche am Anfang der Suchzeichenfolge.

function SearchNonGlobal()
{
    var src = "The quick brown fox jumps over the lazy dog.";

    // Create a regular expression that does not have
    // a global flag.
    var re = /\w+/;

    // Get the first match.
    // Because the global flag is not set, the search starts
    // from the beginning of the string.
    var result = re.exec(src);

    if (result == null)
        print ("not found");
    else
        {   
        print (result.index + "-" + result.lastIndex + "\t" + result[0]);
        }

    // Output:
    //  0-3 The
}

Ersetzen

Im folgenden Beispiel werden Vorkommen von "the" durch "a" ersetzt. Die Instanz von "The" wird jedoch nicht ersetzt, da das i-Flag (Groß-/Kleinschreibung ignorieren) nicht in den Flags für reguläre Ausdrücke enthalten ist.

Im Beispiel wird die Replace-Methode verwendet.

function ReplaceGlobal()
{
    var src = "The batter hit the ball with the bat ";
    src += "and the fielder caught the ball with the glove.";

    // Replace "the" with "a".
    var re = /the/g;
    var result = src.replace(re, "a");

    print(result);

    // Output:
    //  The batter hit a ball with a bat and a fielder caught a ball with a glove.
}

Extrahieren von Teilzeichenfolgen

Durch Verwenden von Klammern im Muster eines regulären Ausdrucks wird eine Teilübereinstimmung erstellt, die zur späteren Verwendung gespeichert werden kann.

Das Muster im folgenden Beispiel enthält drei Teilübereinstimmungen. Die Teilübereinstimmungszeichenfolgen werden zusammen mit jeder Entsprechung angezeigt.

Die exec-Methode gibt ein Array zurück. Das Element Null des Arrays enthält die vollständige Übereinstimmung, und die Elemente 1 bis n enthalten die Teilübereinstimmungen.

function SearchWithSubmatches()
{
    var result;

    var src = "Please send mail to george@contoso.com and someone@example.com. Thanks!";

    // Create a regular expression to search for an e-mail address.
    // Include the global flag.
    // (More sophisticated RegExp patterns are available for
    // matching an e-mail address.)
    var re = /(\w+)@(\w+)\.(\w+)/g;

    // Get the first match.
    result = re.exec(src);
    while (result != null)
    {
        print ("e-mail address: " + result[0]);

        // Get the submatched parts of the address.
        print ("user name: " + result[1]);
        print ("host name: " + result[2]);
        print ("top-level domain: " + result[3]);
        print ("");

        // Get the next match.
        result = re.exec(src);
    }

    // Output:
    //  e-mail address: george@contoso.com
    //  user name: george
    //  host name: contoso
    //  top-level domain: com

    //  e-mail address: someone@example.com
    //  user name: someone
    //  host name: example
    //  top-level domain: com
}

Flags

Im regulären JScript-Ausdruck /abc/gim gibt g das globale Flag an; i gibt das Flag zum Ignorieren der Groß- und Kleinschreibung an und m gibt das Flag für mehrere Zeilen an.

In der folgenden Tabelle werden die zulässigen Flags angezeigt.

Zusätzliche Features

Zusätzlich sind folgende Programmierfunktionen verfügbar:

Siehe auch

Referenz

Regular Expression-Objekt

Konzepte

Erstellen eines regulären Ausdrucks

Syntax regulärer Ausdrücke