Perché "asdf" .replace (/.*/ g, "x") == "xx"?

Mi sono imbattuto in un fatto sorprendente (per me).

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

Perché due sostituzioni? Sembra che qualsiasi stringa non vuota senza newline produrrà esattamente due sostituzioni per questo modello. Usando una funzione di sostituzione, posso vedere che la prima sostituzione è per l'intera stringa e la seconda per una stringa vuota.

Secondo lo standard ECMA-262 , String.prototype.replace chiama RegExp.prototype [@@ sostituisci] , che dice:

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).

dove rxè /.*/ged Sè'asdf' .

Vedi 11.c.iii.2.b:

b. Lascia che nextIndex sia AdvanceStringIndex (S, thisIndex, fullUnicode).

Quindi in 'asdf'.replace(/.*/g, 'x')esso è in realtà:

1. risultato (non definito), results = [], lastIndex =0
2. risultato = 'asdf', risultati = [ 'asdf' ], lastIndex =4
3. risultato = ''risultati = [ 'asdf', '' ], lastIndex = 4, AdvanceStringIndex, impostare lastIndex5
4. risultato = null, risultati = [ 'asdf', '' ], ritorno

Pertanto ci sono 2 partite.

Insieme in una chat offline con yawkat , abbiamo trovato un modo intuitivo per capire il perché"abcd".replace(/.*/g, "x") produce esattamente due corrispondenze. Nota che non abbiamo verificato se è completamente uguale alla semantica imposta dallo standard ECMAScript, quindi prendila come regola pratica.

Regole empiriche

• Considera le corrispondenze come un elenco di tuple (matchStr, matchIndex)in ordine cronologico che indicano quali parti di stringa e indici della stringa di input sono già stati divorati.
• Questo elenco viene continuamente compilato a partire dalla sinistra della stringa di input per il regex.
• Le parti già consumate non possono più essere abbinate
• La sostituzione avviene agli indici dati matchIndexsovrascrivendo la sottostringa matchStrin quella posizione. Se matchStr = "", quindi la "sostituzione" è effettivamente l'inserimento.

Formalmente, l'atto di abbinamento e sostituzione è descritto come un ciclo come visto nell'altra risposta .

Semplici esempi

1. "abcd".replace(/.*/g, "x")uscite "xx":

   • L'elenco delle partite è [("abcd", 0), ("", 4)]

     In particolare, non include le seguenti corrispondenze che si potrebbero pensare per i seguenti motivi:

     • ("a", 0), ("ab", 0): il quantificatore *è avido
     • ("b", 1), ("bc", 1): a causa della partita precedente ("abcd", 0), le stringhe "b"e "bc"sono già state consumate
     • ("", 4), ("", 4) (cioè due volte): la posizione dell'indice 4 è già stata divorata dalla prima corrispondenza apparente

   • Pertanto, la stringa di sostituzione "x"sostituisce esattamente le stringhe di corrispondenza trovate in quelle posizioni: nella posizione 0 sostituisce la stringa "abcd"e nella posizione 4 sostituisce "".

     Qui puoi vedere che la sostituzione può agire come vera sostituzione di una stringa precedente o semplicemente come inserimento di una nuova stringa.

2. "abcd".replace(/.*?/g, "x")con un output quantificatore pigro*?"xaxbxcxdx"

   • L'elenco delle partite è [("", 0), ("", 1), ("", 2), ("", 3), ("", 4)]

     In contrasto con l'esempio precedente, qui ("a", 0), ("ab", 0), ("abc", 0), o addirittura ("abcd", 0)non sono inclusi per pigrizia del quantificatore che limita rigorosamente esso per trovare l'occorrenza più breve possibile.

   • Poiché tutte le stringhe di corrispondenza sono vuote, non si verifica alcuna sostituzione effettiva, ma invece inserimenti xnelle posizioni 0, 1, 2, 3 e 4.

3. "abcd".replace(/.+?/g, "x")con un output quantificatore pigro+?"xxxx"

   • L'elenco delle partite è [("a", 0), ("b", 1), ("c", 2), ("d", 3)]

4. "abcd".replace(/.{2,}?/g, "x")con un output quantificatore pigro[2,}?"xx"

   • L'elenco delle partite è [("ab", 0), ("cd", 2)]

5. "abcd".replace(/.{0}/g, "x")uscite "xaxbxcxdx"con la stessa logica dell'esempio 2.

Esempi più difficili

Possiamo sfruttare costantemente l'idea di inserimento anziché di sostituzione se abbiniamo sempre una stringa vuota e controlliamo la posizione in cui tali corrispondenze avvengono a nostro vantaggio. Ad esempio, possiamo creare espressioni regolari corrispondenti alla stringa vuota in ogni posizione pari per inserire un carattere lì:

1. "abcdefgh".replace(/(?<=^(..)*)/g, "_"))con output lookbehind positivi(?<=...)"_ab_cd_ef_gh_" (finora supportati solo in Chrome)

   • L'elenco delle partite è [("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

2. "abcdefgh".replace(/(?=(..)*$)/g, "_"))con uscite lookahead positive(?=...)"_ab_cd_ef_gh_"

   • L'elenco delle partite è [("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

La prima partita è ovviamente "asdf"(Posizione [0,4]). Poiché il flag globale ( g) è impostato, continua la ricerca. A questo punto (Posizione 4), trova una seconda corrispondenza, una stringa vuota (Posizione [4,4]).

Ricorda che *corrisponde a zero o più elementi.

semplicemente, il primo x è per la sostituzione della corrispondenza asdf.

secondo xper la stringa vuota dopo asdf. La ricerca termina quando è vuota.