Dlaczego „asdf” .replace (/.*/ g, „x”) == „xx”?

Natknąłem się na zaskakujący (dla mnie) fakt.

console.log("asdf".replace(/.*/g, "x"));

Dlaczego dwie zastępstwa? Wygląda na to, że jakikolwiek niepusty ciąg bez znaków nowej linii da dokładnie dwa zamienniki dla tego wzorca. Za pomocą funkcji zamiany widzę, że pierwsza zamiana dotyczy całego łańcucha, a druga pustego łańcucha.

Zgodnie ze standardem ECMA-262 String.prototype.replace wywołuje RegExp.prototype [@@ replace] , który mówi:

11. Repeat, while done is false
  a. Let result be ? RegExpExec(rx, S).
  b. If result is null, set done to true.
  c. Else result is not null,
    i. Append result to the end of results.
    ii. If global is false, set done to true.
    iii. Else,
      1. Let matchStr be ? ToString(? Get(result, "0")).
      2. If matchStr is the empty String, then
        a. Let thisIndex be ? ToLength(? Get(rx, "lastIndex")).
        b. Let nextIndex be AdvanceStringIndex(S, thisIndex, fullUnicode).
        c. Perform ? Set(rx, "lastIndex", nextIndex, true).

gdzie rxjest /.*/gi Sjest 'asdf'.

Patrz 11.c.iii.2.b:

b. Niech nextIndex będzie AdvanceStringIndex (S, thisIndex, fullUnicode).

Dlatego w 'asdf'.replace(/.*/g, 'x')rzeczywistości jest to:

1. wynik (niezdefiniowany), results = [], lastIndex =0
2. wynik = 'asdf', wyniki = [ 'asdf' ], lastIndex =4
3. Wynik = ''wyniki = [ 'asdf', '' ], = lastIndex 4, AdvanceStringIndexustaw lastIndex do5
4. wynik = null, wyniki = [ 'asdf', '' ], powrót

Dlatego są 2 mecze.

Wspólnie na czacie offline z yawkat znaleźliśmy intuicyjny sposób sprawdzenia, dlaczego "abcd".replace(/.*/g, "x")dokładnie produkuje dwa dopasowania. Zauważ, że nie sprawdziliśmy, czy całkowicie równa się semantyce narzuconej przez standard ECMAScript, dlatego po prostu weź to za ogólną zasadę.

Reguły kciuka

• Rozważ dopasowania jako listę krotek (matchStr, matchIndex)w kolejności chronologicznej, które wskazują, które części łańcucha i wskaźniki łańcucha wejściowego zostały już zjedzone.
• Ta lista jest stale budowana, zaczynając od lewej strony łańcucha wejściowego wyrażenia regularnego.
• Części już zjedzone nie mogą być już dopasowane
• Zastąpienie odbywa się według wskaźników podanych przez matchIndexzastąpienie podłańcucha matchStrw tej pozycji. Jeśli matchStr = "", to „zamiana” polega na wstawieniu.

Formalnie czynność dopasowywania i zastępowania jest opisana jako pętla, jak widać w drugiej odpowiedzi .

Proste przykłady

1. "abcd".replace(/.*/g, "x")wyjścia "xx":

   • Lista meczów to [("abcd", 0), ("", 4)]

     W szczególności nie obejmuje następujących dopasowań, o których można pomyśleć z następujących powodów:

     • ("a", 0), ("ab", 0): kwantyfikator *jest zachłanny
     • ("b", 1), ("bc", 1): ze względu na poprzedni mecz ("abcd", 0)struny "b"i "bc"są już zjedzone
     • ("", 4), ("", 4) (tj. dwa razy): pozycja indeksu 4 jest już pochłonięta przez pierwsze pozorne dopasowanie

   • Dlatego ciąg "x"zastępujący zastępuje znalezione pasujące ciągi dokładnie w tych pozycjach: w pozycji 0 zastępuje ciąg, "abcd"a w pozycji 4 zastępuje "".

     Tutaj widać, że zamiana może działać jak prawdziwe zastąpienie poprzedniego ciągu lub po prostu wstawienie nowego ciągu.

2. "abcd".replace(/.*?/g, "x")z leniwymi*? wyjściami kwantyfikatora"xaxbxcxdx"

   • Lista meczów to [("", 0), ("", 1), ("", 2), ("", 3), ("", 4)]

     W przeciwieństwie do poprzedniego przykładu, tutaj ("a", 0), ("ab", 0), ("abc", 0), lub nawet ("abcd", 0)nie są wliczone powodu lenistwa kwantyfikatora, że ściśle ogranicza to, aby znaleźć możliwie najkrótszy mecz.

   • Ponieważ wszystkie pasujące ciągi znaków są puste, nie występuje faktyczna zamiana, ale zamiast tego wstawienia xpozycji 0, 1, 2, 3 i 4.

3. "abcd".replace(/.+?/g, "x")z leniwymi+? wyjściami kwantyfikatora"xxxx"

   • Lista meczów to [("a", 0), ("b", 1), ("c", 2), ("d", 3)]

4. "abcd".replace(/.{2,}?/g, "x")z leniwymi[2,}? wyjściami kwantyfikatora"xx"

   • Lista meczów to [("ab", 0), ("cd", 2)]

5. "abcd".replace(/.{0}/g, "x")wyprowadza "xaxbxcxdx"tą samą logiką jak w przykładzie 2.

Trudniejsze przykłady

Możemy konsekwentnie wykorzystywać ideę wstawiania zamiast zamiany, jeśli zawsze dopasowujemy pusty ciąg i kontrolujemy pozycję, w której takie dopasowania przynoszą nam korzyść. Na przykład możemy utworzyć wyrażenia regularne pasujące do pustego łańcucha w każdej parzystej pozycji, aby wstawić tam znak:

1. "abcdefgh".replace(/(?<=^(..)*)/g, "_"))z pozytywnym wyglądem za(?<=...) wyjściem "_ab_cd_ef_gh_"(do tej pory obsługiwane tylko w Chrome)

   • Lista meczów to [("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

2. "abcdefgh".replace(/(?=(..)*$)/g, "_"))z A pozytywne lookAhead(?=...) wyjść"_ab_cd_ef_gh_"

   • Lista meczów to [("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

Pierwszy mecz to oczywiście "asdf"(pozycja [0,4]). Ponieważ ustawiono flagę globalną ( g), kontynuuje wyszukiwanie. W tym momencie (pozycja 4) znajduje drugie dopasowanie, pusty ciąg znaków (pozycja [4,4]).

Pamiętaj, że *pasuje do zera lub więcej elementów.