Dlaczego RegExp z flagą globalną daje nieprawidłowe wyniki?

Na czym polega problem z tym wyrażeniem regularnym, gdy używam flagi globalnej i flagi bez rozróżniania wielkości liter? Zapytanie to dane wejściowe generowane przez użytkownika. Wynik powinien być [prawda, prawda].

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"));

RegExpObiekt śledzi lastIndexgdzie wystąpił mecz, więc w kolejnych meczach będzie zacząć od ostatniego indeksu używane zamiast 0. Spójrz:

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'));

Jeśli nie chcesz ręcznie resetować lastIndexdo 0 po każdym teście, po prostu usuń gflagę.

Oto algorytm, który dyktują specyfikacje (sekcja 15.10.6.2):

RegExp.prototype.exec (ciąg)

Wykonuje dopasowanie wyrażenia regularnego w stosunku do wyrażenia regularnego i zwraca obiekt Array zawierający wyniki dopasowania lub wartość NULL, jeśli ciąg nie jest zgodny. Ciąg ToString (ciąg) jest szukany pod kątem wystąpienia wzorca wyrażenia regularnego w następujący sposób:

1. Niech S będzie wartością ToString (string).
2. Niech długość będzie długością S.
3. Niech lastIndex będzie wartością właściwości lastIndex.
4. Niech będę wartością ToInteger (lastIndex).
5. Jeśli właściwość globalna ma wartość false, niech i = 0.
6. Jeśli I <0 lub I> długość, ustaw lastIndex na 0 i zwróć null.
7. Wywołaj [[Dopasuj]], podając argumenty S i i. Jeśli [[Dopasuj]] zwrócił błąd, przejdź do kroku 8; w przeciwnym razie niech będzie wynikiem stanu i przejdź do kroku 10.
8. Niech i = i + 1.
9. Przejdź do kroku 6.
10. Niech będzie końcową wartością indeksu.
11. Jeśli właściwość globalna ma wartość true, ustaw lastIndex na e.
12. Niech n będzie długością tablicy przechwytywania r. (Jest to ta sama wartość, co NCapturingParens z 15.10.2.1.)
13. Zwróć nową tablicę o następujących właściwościach:
    • Właściwość index jest ustawiona na pozycję dopasowanego podłańcucha w całym ciągu S.
    • Właściwość wejściowa jest ustawiona na S.
    • Właściwość length jest ustawiona na n + 1.
    • Właściwość 0 jest ustawiona na dopasowany podłańcuch (tj. Część S między przesunięciem i włącznie i przesunięciem e).
    • Dla każdej liczby całkowitej i takiej, że I> 0 i I ≤ n, ustaw właściwość ToString (i) na i-ty element tablicy r przechwytywania.

Używasz jednego RegExpobiektu i wykonujesz go wiele razy. Przy każdym kolejnym wykonaniu jest kontynuowany od indeksu ostatniego dopasowania.

Musisz „zresetować” wyrażenie regularne, aby rozpocząć od początku przed każdym wykonaniem:

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

Powiedziawszy, że może być bardziej czytelne tworzenie nowego obiektu RegExp za każdym razem (obciążenie jest minimalne, ponieważ RegExp jest buforowany i tak):

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

RegExp.prototype.testaktualizuje właściwość wyrażeń regularnych, lastIndexaby każdy test rozpoczął się w miejscu, w którym zatrzymał się ostatni. Sugeruję użycie, String.prototype.matchponieważ nie aktualizuje lastIndexwłaściwości:

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

Uwaga: !!konwertuje go na wartość logiczną, a następnie odwraca wartość logiczną, aby odzwierciedlała wynik.

Alternatywnie możesz po prostu zresetować lastIndexwłaściwość:

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

Usunięcie gflagi globalnej rozwiąże problem.

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

Powinien być

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

Musisz ustawić re.lastIndex = 0, ponieważ przy regexie flagi g śledź ostatnie wystąpienie dopasowania, więc test nie przejdzie do testowania tego samego ciągu, w tym celu musisz zrobić re.lastIndex = 0

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)

Użycie flagi / g nakazuje kontynuowanie wyszukiwania po trafieniu.

Jeśli dopasowanie się powiedzie, metoda exec () zwraca tablicę i aktualizuje właściwości obiektu wyrażenia regularnego.

Przed pierwszym wyszukiwaniem:

myRegex.lastIndex
//is 0

Po pierwszym wyszukiwaniu

myRegex.lastIndex
//is 8

Usuń g i wyjdzie z wyszukiwania po każdym wywołaniu exec ().

Miałem funkcję:

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");

Pierwsze połączenie działa. Drugie połączenie nie. sliceOperacja narzeka wartości zerowej. Zakładam, że dzieje się tak z powodu re.lastIndex. Jest to dziwne, ponieważ oczekiwałbym, że nowa RegExpbędzie przydzielana za każdym razem, gdy funkcja jest wywoływana, a nie współużytkowana przez wiele wywołań mojej funkcji.

Kiedy zmieniłem na:

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

Wtedy nie dostaję lastIndexefektu zatrzymania. Działa tak, jak bym tego oczekiwał.