Warum liefert ein RegExp mit globalem Flag falsche Ergebnisse?

Was ist das Problem mit diesem regulären Ausdruck, wenn ich das globale Flag und das Flag ohne Berücksichtigung der Groß- und Kleinschreibung verwende? Die Abfrage ist eine vom Benutzer generierte Eingabe. Das Ergebnis sollte [wahr, wahr] sein.

var query = 'Foo B';
var re = new RegExp(query, 'gi');
var result = [];
result.push(re.test('Foo Bar'));
result.push(re.test('Foo Bar'));
// result will be [true, false]

var reg = /^a$/g;
for(i = 0; i++ < 10;)
   console.log(reg.test("a"));

Das RegExpObjekt verfolgt, lastIndexwo eine Übereinstimmung stattgefunden hat. Bei nachfolgenden Übereinstimmungen beginnt es also mit dem zuletzt verwendeten Index anstelle von 0. Sehen Sie sich Folgendes an:

var query = 'Foo B';
var re = new RegExp(query, 'gi');
var result = [];
result.push(re.test('Foo Bar'));

alert(re.lastIndex);

result.push(re.test('Foo Bar'));

Wenn Sie nicht lastIndexnach jedem Test manuell auf 0 zurücksetzen möchten , entfernen Sie einfach das gFlag.

Hier ist der Algorithmus, den die Spezifikationen vorschreiben (Abschnitt 15.10.6.2):

RegExp.prototype.exec (Zeichenfolge)

Führt eine Übereinstimmung der Zeichenfolge mit regulären Ausdrücken mit dem regulären Ausdruck durch und gibt ein Array-Objekt zurück, das die Ergebnisse der Übereinstimmung enthält, oder null, wenn die Zeichenfolge nicht übereinstimmt. Die Zeichenfolge ToString (Zeichenfolge) wird wie folgt nach einem Vorkommen des Musters für reguläre Ausdrücke durchsucht:

1. Sei S der Wert von ToString (String).
2. Die Länge sei die Länge von S.
3. Sei lastIndex der Wert der lastIndex-Eigenschaft.
4. Sei i der Wert von ToInteger (lastIndex).
5. Wenn die globale Eigenschaft false ist, sei i = 0.
6. Wenn I <0 oder I> lang ist, setzen Sie lastIndex auf 0 und geben null zurück.
7. Rufen Sie [[Match]] auf und geben Sie ihm die Argumente S und i. Wenn [[Match]] einen Fehler zurückgegeben hat, fahren Sie mit Schritt 8 fort. Andernfalls sei r das Statusergebnis und gehe zu Schritt 10.
8. Sei i = i + 1.
9. Fahren Sie mit Schritt 6 fort.
10. Sei e der endIndex-Wert von r.
11. Wenn die globale Eigenschaft true ist, setzen Sie lastIndex auf e.
12. Sei n die Länge des Captures-Arrays von r. (Dies ist der gleiche Wert wie bei NCapturingParens vom 15.10.2.1.)
13. Geben Sie ein neues Array mit den folgenden Eigenschaften zurück:
    • Die index-Eigenschaft wird auf die Position des übereinstimmenden Teilstrings innerhalb des vollständigen Strings S gesetzt.
    • Die Eingabeeigenschaft wird auf S gesetzt.
    • Die Länge-Eigenschaft wird auf n + 1 gesetzt.
    • Die 0-Eigenschaft wird auf den übereinstimmenden Teilstring gesetzt (dh den Teil von S zwischen Offset i einschließlich und Offset e exklusiv).
    • Setzen Sie für jede ganze Zahl i, so dass I> 0 und I ≤ n ist, die Eigenschaft ToString (i) auf das i-te Element des Captures-Arrays von r.

Sie verwenden ein einzelnes RegExpObjekt und führen es mehrmals aus. Bei jeder aufeinanderfolgenden Ausführung wird ab dem letzten Übereinstimmungsindex fortgesetzt.

Sie müssen den regulären Ausdruck "zurücksetzen", um vor jeder Ausführung von vorne zu beginnen:

result.push(re.test('Foo Bar'));
re.lastIndex = 0;
result.push(re.test('Foo Bar'));
// result is now [true, true]

Allerdings ist es möglicherweise besser lesbar, jedes Mal ein neues RegExp-Objekt zu erstellen (der Overhead ist minimal, da RegExp ohnehin zwischengespeichert wird):

result.push((/Foo B/gi).test(stringA));
result.push((/Foo B/gi).test(stringB));

RegExp.prototype.testAktualisiert die lastIndexEigenschaft der regulären Ausdrücke, sodass jeder Test dort beginnt, wo der letzte gestoppt wurde. Ich würde vorschlagen, zu verwenden, String.prototype.matchda es die lastIndexEigenschaft nicht aktualisiert :

!!'Foo Bar'.match(re); // -> true
!!'Foo Bar'.match(re); // -> true

Hinweis: !!Konvertiert es in einen Booleschen Wert und invertiert dann den Booleschen Wert, sodass er das Ergebnis widerspiegelt.

Alternativ können Sie die lastIndexEigenschaft auch einfach zurücksetzen :

result.push(re.test('Foo Bar'));
re.lastIndex = 0;
result.push(re.test('Foo Bar'));

Durch Entfernen des globalen gFlags wird Ihr Problem behoben.

var re = new RegExp(query, 'gi');

Sollte sein

var re = new RegExp(query, 'i');

Sie müssen re.lastIndex = 0 setzen, da mit g flag regex die letzte aufgetretene Übereinstimmung verfolgt wird, sodass beim Test nicht dieselbe Zeichenfolge getestet wird. Dazu müssen Sie re.lastIndex = 0 ausführen

var query = 'Foo B';
var re = new RegExp(query, 'gi');
var result = [];
result.push(re.test('Foo Bar'));
re.lastIndex=0;
result.push(re.test('Foo Bar'));

console.log(result)

Wenn Sie das Flag / g verwenden, wird die Suche nach einem Treffer fortgesetzt.

Wenn die Übereinstimmung erfolgreich ist, gibt die exec () -Methode ein Array zurück und aktualisiert die Eigenschaften des Objekts mit regulären Ausdrücken.

Vor Ihrer ersten Suche:

myRegex.lastIndex
//is 0

Nach der ersten Suche

myRegex.lastIndex
//is 8

Entfernen Sie das g und es beendet die Suche nach jedem Aufruf von exec ().

Ich hatte die Funktion:

function parseDevName(name) {
  var re = /^([^-]+)-([^-]+)-([^-]+)$/g;
  var match = re.exec(name);
  return match.slice(1,4);
}

var rv = parseDevName("BR-H-01");
rv = parseDevName("BR-H-01");

Der erste Anruf funktioniert. Der zweite Anruf nicht. Die sliceOperation beschwert sich über einen Nullwert. Ich nehme an, das liegt an der re.lastIndex. Dies ist seltsam, da ich erwarten würde, dass RegExpbei jedem Aufruf der Funktion eine neue zugewiesen wird und nicht für mehrere Aufrufe meiner Funktion freigegeben wird.

Als ich es geändert habe zu:

var re = new RegExp('^([^-]+)-([^-]+)-([^-]+)$', 'g');

Dann bekomme ich den lastIndexHoldover-Effekt nicht. Es funktioniert so, wie ich es erwarten würde.