Warum ist "asdf" .replace (/.*/ g, "x") == "xx"?

Ich stolperte über eine überraschende (für mich) Tatsache.

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

Warum zwei Ersetzungen? Es scheint, dass jede nicht leere Zeichenfolge ohne Zeilenumbrüche genau zwei Ersetzungen für dieses Muster erzeugt. Mit einer Ersetzungsfunktion kann ich sehen, dass die erste Ersetzung für die gesamte Zeichenfolge und die zweite für eine leere Zeichenfolge gilt.

Gemäß dem ECMA-262- Standard ruft String.prototype.replace RegExp.prototype [@@ replace] auf , das besagt:

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

wo rxist /.*/gund Sist 'asdf'.

Siehe 11.c.iii.2.b:

b. Sei nextIndex AdvanceStringIndex (S, thisIndex, fullUnicode).

Deshalb 'asdf'.replace(/.*/g, 'x')ist darin eigentlich:

1. Ergebnis (undefiniert), Ergebnisse = [], lastIndex =0
2. Ergebnis = 'asdf', Ergebnisse = [ 'asdf' ], lastIndex =4
3. Ergebnis = ''ergibt = [ 'asdf', '' ], liest = 4, AdvanceStringIndexsetzen liest zu5
4. Ergebnis = null, Ergebnisse = [ 'asdf', '' ], Rückgabe

Daher gibt es 2 Übereinstimmungen.

Gemeinsam in einem Offline-Chat mit yawkat haben wir eine intuitive Methode gefunden , um zu verstehen, warum"abcd".replace(/.*/g, "x") genau zwei Übereinstimmungen erzeugt werden. Beachten Sie, dass wir nicht überprüft haben, ob es vollständig der vom ECMAScript-Standard auferlegten Semantik entspricht. Nehmen Sie dies daher als Faustregel.

Faustregeln

• Betrachten Sie die Übereinstimmungen als eine Liste von Tupeln (matchStr, matchIndex)in chronologischer Reihenfolge, die angeben, welche Zeichenfolgenteile und Indizes der Eingabezeichenfolge bereits aufgefressen wurden.
• Diese Liste wird fortlaufend beginnend links von der Eingabezeichenfolge für den regulären Ausdruck erstellt.
• Bereits aufgefressene Teile können nicht mehr abgeglichen werden
• Das Ersetzen erfolgt an Indizes, die durch matchIndexÜberschreiben des Teilstrings matchStran dieser Position angegeben werden. Wenn matchStr = "", dann ist der "Ersatz" effektiv Einfügen.

Formal wird der Vorgang des Abgleichs und Ersetzens als Schleife beschrieben, wie in der anderen Antwort zu sehen ist .

Einfache Beispiele

1. "abcd".replace(/.*/g, "x")Ausgänge "xx":

   • Die Matchliste ist [("abcd", 0), ("", 4)]

     Insbesondere enthält es nicht die folgenden Übereinstimmungen, an die man aus folgenden Gründen hätte denken können:

     • ("a", 0), ("ab", 0): Der Quantifizierer *ist gierig
     • ("b", 1), ("bc", 1): Aufgrund des vorherigen Spiels ("abcd", 0)sind die Saiten "b"und "bc"bereits aufgefressen
     • ("", 4), ("", 4) (dh zweimal): Die Indexposition 4 ist bereits beim ersten offensichtlichen Match aufgebraucht

   • Daher "x"ersetzt die Ersetzungszeichenfolge die gefundenen Übereinstimmungszeichenfolgen genau an diesen Positionen: An Position 0 ersetzt sie die Zeichenfolge "abcd"und an Position 4 ersetzt sie "".

     Hier können Sie sehen, dass das Ersetzen als echtes Ersetzen eines vorherigen Strings oder nur als Einfügen eines neuen Strings dienen kann.

2. "abcd".replace(/.*?/g, "x")mit einem Lazy Quantifier*? Ausgänge"xaxbxcxdx"

   • Die Matchliste ist [("", 0), ("", 1), ("", 2), ("", 3), ("", 4)]

     Im Gegensatz zum vorherigen Beispiel, hier ("a", 0), ("ab", 0), ("abc", 0), oder auch ("abcd", 0)nicht wegen der Trägheit des quantifier enthält , die es streng die kürzeste mögliche Übereinstimmung zu finden begrenzt.

   • Da alle Übereinstimmungszeichenfolgen leer sind, erfolgt keine tatsächliche Ersetzung, sondern das Einfügen xan den Positionen 0, 1, 2, 3 und 4.

3. "abcd".replace(/.+?/g, "x") mit einer Lazy Quantifier+? Ausgänge"xxxx"

   • Die Matchliste ist [("a", 0), ("b", 1), ("c", 2), ("d", 3)]

4. "abcd".replace(/.{2,}?/g, "x") mit einer Lazy Quantifier[2,}? Ausgänge"xx"

   • Die Matchliste ist [("ab", 0), ("cd", 2)]

5. "abcd".replace(/.{0}/g, "x")Ausgänge "xaxbxcxdx"nach der gleichen Logik wie in Beispiel 2.

Härtere Beispiele

Wir können die Idee des Einfügens anstelle des Ersetzens konsequent ausnutzen, wenn wir nur immer eine leere Zeichenfolge abgleichen und die Position steuern, an der solche Übereinstimmungen zu unserem Vorteil stattfinden. Zum Beispiel können wir reguläre Ausdrücke erstellen, die mit der leeren Zeichenfolge an jeder geraden Position übereinstimmen, um dort ein Zeichen einzufügen:

1. "abcdefgh".replace(/(?<=^(..)*)/g, "_"))mit einem positiven Lookbehind(?<=...) Ausgängen "_ab_cd_ef_gh_"(nur in Chrome so weit unterstützt)

   • Die Matchliste ist [("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

2. "abcdefgh".replace(/(?=(..)*$)/g, "_"))mit einem positiven Lookahead-(?=...) Ausgang"_ab_cd_ef_gh_"

   • Die Matchliste ist [("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

Das erste Match ist offensichtlich "asdf"(Position [0,4]). Da das globale Flag ( g) gesetzt ist, wird die Suche fortgesetzt. An diesem Punkt (Position 4) findet es eine zweite Übereinstimmung, eine leere Zeichenfolge (Position [4,4]).

Denken Sie daran, dass *null oder mehr Elemente übereinstimmen.

Der erste xist einfach für den Ersatz des Matchings asdf.

Sekunde xfür die leere Zeichenfolge nach asdf. Die Suche wird beendet, wenn sie leer ist.