Die Syntax für allgemeine Atome lautet wie folgt:

Die Syntax für Zeichenklassen lautet wie folgt:

Die folgenden Konstrukte sind alle Zeichen spezifikationen

Um die Verwendung von Zeichenklassen zu demonstrieren, analysiert dieses Beispiel ein Datum im ISO 8601-Format

function parseIsoDate(str) {
    var match = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(str);

    // Other ways of writing the regular expression:
    // /^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$/
    // /^(\d\d\d\d)-(\d\d)-(\d\d)$/

    if (!match) {
        throw new Error('Not an ISO date: '+str);
    }
    console.log('Year: '  + match[1]);
    console.log('Month: ' + match[2]);
    console.log('Day: '   + match[3]);
}

Und hier ist die Interaktion

> parseIsoDate('2001-12-24')
Year: 2001
Month: 12
Day: 24

Die Syntax für Gruppen lautet wie folgt:

\1, \2 und so weiter werden als *Rückverweise* bezeichnet; sie verweisen auf eine zuvor abgeglichene Gruppe. Die Zahl nach dem Backslash kann jede ganze Zahl größer oder gleich 1 sein, aber die erste Ziffer darf nicht 0 sein.

In diesem Beispiel garantiert ein Rückverweis die gleiche Menge an a's vor und nach dem Bindestrich

> /^(a+)-\1$/.test('a-a')
true
> /^(a+)-\1$/.test('aaa-aaa')
true
> /^(a+)-\1$/.test('aa-a')
false

Dieses Beispiel verwendet einen Rückverweis, um ein HTML-Tag abzugleichen (offensichtlich sollten Sie normalerweise einen richtigen Parser zur Verarbeitung von HTML verwenden)

> var tagName = /<([^>]+)>[^<]*<\/\1>/;
> tagName.exec('<b>bold</b>')[1]
'b'
> tagName.exec('<strong>text</strong>')[1]
'strong'
> tagName.exec('<strong>text</stron>')
null

Jedes Atom (einschließlich Zeichenklassen und Gruppen) kann von einem Quantifizierer gefolgt werden:

Standardmäßig sind Quantifizierer *gierig*; das heißt, sie passen so viel wie möglich. Sie können *zurückhaltendes* Abgleichen (so wenig wie möglich) erhalten, indem Sie jeden der vorherigen Quantifizierer (einschließlich der Bereiche in geschweiften Klammern) mit einem Fragezeichen (?) versehen. Zum Beispiel:

> '<a> <strong>'.match(/^<(.*)>/)[1]  // greedy
'a> <strong'
> '<a> <strong>'.match(/^<(.*?)>/)[1]  // reluctant
'a'

Daher ist .*? ein nützliches Muster, um alles bis zum nächsten Vorkommen des folgenden Atoms abzugleichen. Zum Beispiel ist das Folgende eine kompaktere Version des regulären Ausdrucks für HTML-Tags, der gerade gezeigt wurde (der [^<]* anstelle von .*? verwendete)

/<(.+?)>.*?<\/\1>/

Assertionen, die in der folgenden Liste aufgeführt sind, sind Prüfungen der aktuellen Position in der Eingabe:

Dieses Beispiel passt zu einer Wortgrenze mit \b

> /\bell\b/.test('hello')
false
> /\bell\b/.test('ello')
false
> /\bell\b/.test('ell')
true

Dieses Beispiel passt zum Inneren eines Wortes mit \B

> /\Bell\B/.test('ell')
false
> /\Bell\B/.test('hell')
false
> /\Bell\B/.test('hello')
true

Ein Disjunktionsoperator (|) trennt zwei Alternativen; entweder die Alternativen müssen übereinstimmen, damit die Disjunktion übereinstimmt. Die Alternativen sind Atome (optional einschließlich Quantifizierern).

Der Operator bindet sehr schwach, sodass Sie vorsichtig sein müssen, dass die Alternativen nicht zu weit reichen. Zum Beispiel passt der folgende reguläre Ausdruck zu allen Zeichenketten, die entweder mit aa beginnen oder mit bb enden

> /^aa|bb$/.test('aaxx')
true
> /^aa|bb$/.test('xxbb')
true

Mit anderen Worten, die Disjunktion bindet schwächer als sogar ^ und $, und die beiden Alternativen sind ^aa und bb$. Wenn Sie die beiden Zeichenketten 'aa' und 'bb' abgleichen möchten, benötigen Sie Klammern

/^(aa|bb)$/

Ebenso, wenn Sie die Zeichenketten 'aab' und 'abb' abgleichen möchten

/^a(a|b)b$/

Es gibt zwei Möglichkeiten, einen regulären Ausdruck zu erstellen: Sie können ein Literal oder den Konstruktor RegExp verwenden:

Ein Literal und ein Konstruktor unterscheiden sich darin, wann sie kompiliert werden

Daher sollten Sie normalerweise Literale verwenden, aber Sie benötigen den Konstruktor, wenn Sie einen regulären Ausdruck dynamisch zusammensetzen möchten.

Flags sind ein Suffix von regulären Ausdrucksliteralen und ein Parameter von regulären Ausdruckskonstruktoren; sie modifizieren das Abgleichverhalten von regulären Ausdrücken. Es gibt die folgenden Flags:

Der Kurzname wird für Literalpräfixe und Konstruktorparameter verwendet (siehe Beispiele im nächsten Abschnitt). Der Langname wird für Eigenschaften eines regulären Ausdrucks verwendet, die angeben, welche Flags während seiner Erstellung gesetzt wurden.

Reguläre Ausdrücke haben die folgenden Instanzeigenschaften:

Das Folgende ist ein Beispiel für den Zugriff auf die Instanzeigenschaften für Flags

> var regex = /abc/i;
> regex.ignoreCase
true
> regex.multiline
false

In diesem Beispiel erstellen wir denselben regulären Ausdruck zuerst mit einem Literal und dann mit einem Konstruktor und verwenden die test()-Methode, um festzustellen, ob er mit einer Zeichenkette übereinstimmt:

> /abc/.test('ABC')
false
> new RegExp('abc').test('ABC')
false

In diesem Beispiel erstellen wir einen regulären Ausdruck, der die Groß-/Kleinschreibung ignoriert (Flag /i)

> /abc/i.test('ABC')
true
> new RegExp('abc', 'i').test('ABC')
true

Wenn das Flag /g nicht gesetzt ist, wird nur die erste Übereinstimmung zurückgegeben

> var regex = /a(b+)/;
> regex.exec('_abbb_ab_')
[ 'abbb',
  'bbb',
  index: 1,
  input: '_abbb_ab_' ]
> regex.lastIndex
0

Wenn das Flag /g gesetzt ist, werden alle Übereinstimmungen zurückgegeben, wenn Sie exec() wiederholt aufrufen. Der Rückgabewert null signalisiert, dass keine weiteren Übereinstimmungen vorhanden sind. Die Eigenschaft lastIndex gibt an, wo die Übereinstimmung das nächste Mal fortgesetzt wird

> var regex = /a(b+)/g;
> var str = '_abbb_ab_';

> regex.exec(str)
[ 'abbb',
  'bbb',
  index: 1,
  input: '_abbb_ab_' ]
> regex.lastIndex
6

> regex.exec(str)
[ 'ab',
  'b',
  index: 7,
  input: '_abbb_ab_' ]
> regex.lastIndex
10

> regex.exec(str)
null

Hier schleifen wir über Übereinstimmungen

var regex = /a(b+)/g;
var str = '_abbb_ab_';
var match;
while (match = regex.exec(str)) {
    console.log(match[1]);
}

und wir erhalten die folgende Ausgabe

bbb
b

Wenn replacement eine Zeichenkette ist, wird ihr Inhalt wörtlich zum Ersetzen des Treffers verwendet. Die einzige Ausnahme ist das Sonderzeichen Dollarzeichen ($), das sogenannte *Ersetzungsdirektiven* einleitet:

Dieses Beispiel bezieht sich auf die übereinstimmende Teilzeichenkette und ihren Präfix und Suffix

> 'axb cxd'.replace(/x/g, "[$`,$&,$']")
'a[a,x,b cxd]b c[axb c,x,d]d'

Dieses Beispiel bezieht sich auf eine Gruppe

> '"foo" and "bar"'.replace(/"(.*?)"/g, '#$1#')
'#foo# and #bar#'

Wenn replacement eine Funktion ist, berechnet sie die Zeichenkette, die den Treffer ersetzen soll. Diese Funktion hat die folgende Signatur:

function (completeMatch, group_1, ..., group_n, offset, inputStr)

completeMatch ist dasselbe wie $& zuvor, offset gibt an, wo der Treffer gefunden wurde, und inputStr ist das, womit abgeglichen wird. Daher können Sie die spezielle Variable arguments verwenden, um Gruppen abzurufen (Gruppe 1 über arguments[1] und so weiter). Zum Beispiel

> function replaceFunc(match) { return 2 * match }
> '3 apples and 5 oranges'.replace(/[0-9]+/g, replaceFunc)
'6 apples and 10 oranges'

Manchmal, wenn Sie manuell einen regulären Ausdruck zusammensetzen, möchten Sie eine gegebene Zeichenkette wörtlich verwenden. Das bedeutet, dass keines der Sonderzeichen (z. B. *, [) als solches interpretiert werden sollte - alle müssen maskiert werden. JavaScript hat keine integrierten Mittel für diese Art von Zitieren, aber Sie können Ihre eigene Funktion, quoteText, programmieren, die wie folgt funktioniert:

> console.log(quoteText('*All* (most?) aspects.'))
\*All\* \(most\?\) aspects\.

Eine solche Funktion ist besonders nützlich, wenn Sie eine Suche und Ersetzung mit mehreren Vorkommen durchführen müssen. Dann muss der zu suchende Wert ein regulärer Ausdruck mit gesetztem global-Flag sein. Mit quoteText() können Sie beliebige Zeichenketten verwenden. Die Funktion sieht so aus

function quoteText(text) {
    return text.replace(/[\\^$.*+?()[\]{}|=!<>:-]/g, '\\$&');
}

Alle Sonderzeichen werden maskiert, da Sie möglicherweise mehrere Zeichen innerhalb von Klammern oder eckigen Klammern maskieren möchten.

Wenn Sie keine Assertionen wie ^ und $ verwenden, finden die meisten Methoden für reguläre Ausdrücke ein Muster überall. Zum Beispiel:

> /aa/.test('xaay')
true
> /^aa$/.test('xaay')
false

Es ist ein seltener Anwendungsfall, aber manchmal benötigen Sie einen regulären Ausdruck, der alles oder nichts abgleicht. Zum Beispiel kann eine Funktion einen Parameter mit einem regulären Ausdruck haben, der zum Filtern verwendet wird. Wenn dieser Parameter fehlt, geben Sie ihm einen Standardwert, einen regulären Ausdruck, der alles abgleicht.

> new RegExp('').test('dfadsfdsa')
true
> new RegExp('').test('')
true

> new RegExp('')
/(?:)/

> var never = /.^/;
> never.test('abc')
false
> never.test('')
false

Lookbehind ist eine Assertion. Ähnlich wie bei Lookahead wird ein Muster verwendet, um etwas über die aktuelle Position in der Eingabe zu prüfen, aber ansonsten ignoriert. Im Gegensatz zu Lookahead muss der Treffer des Musters *enden* an der aktuellen Position (nicht dort beginnen).

Die folgende Funktion ersetzt jedes Vorkommen der Zeichenkette 'NAME' durch den Wert des Parameters name, aber nur, wenn das Vorkommen nicht von einem Anführungszeichen preceded wird. Wir behandeln das Anführungszeichen, indem wir das Zeichen vor dem aktuellen Treffer "manuell" prüfen

function insertName(str, name) {
    return str.replace(
        /NAME/g,
        function (completeMatch, offset) {
            if (offset === 0 ||
                (offset > 0 && str[offset-1] !== '"')) {
                return name;
            } else {
                return completeMatch;
            }
        }
    );
}

> insertName('NAME "NAME"', 'Jane')
'Jane "NAME"'
> insertName('"NAME" NAME', 'Jane')
'"NAME" Jane'

Eine Alternative ist, die Zeichen einzuschließen, die maskieren können, in den regulären Ausdruck. Dann müssen Sie der Zeichenkette, in der Sie suchen, vorübergehend ein Präfix hinzufügen; andernfalls verpassen Sie Treffer am Anfang dieser Zeichenkette

function insertName(str, name) {
    var tmpPrefix = ' ';
    str = tmpPrefix + str;
    str = str.replace(
        /([^"])NAME/g,
        function (completeMatch, prefix) {
            return prefix + name;
        }
    );
    return str.slice(tmpPrefix.length); // remove tmpPrefix
}