Mengapa “asdf” .replace (/.*/g, “x”) == “xx”?

Saya menemukan fakta mengejutkan (bagi saya).

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

Mengapa dua penggantian? Tampaknya string yang tidak kosong tanpa baris baru akan menghasilkan dua penggantian tepat untuk pola ini. Menggunakan fungsi penggantian, saya bisa melihat bahwa penggantian pertama adalah untuk seluruh string, dan yang kedua adalah untuk string kosong.

Sesuai standar ECMA-262 , String.prototype.replace panggilan RegExp.prototype [@@ replace] , yang mengatakan:

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

dimana rx adalah /.*/gdan Sadalah 'asdf'.

Lihat 11.c.iii.2.b:

b. Biarkan nextIndex menjadi AdvanceStringIndex (S, thisIndex, fullUnicode).

Oleh karena itu dalam 'asdf'.replace(/.*/g, 'x') dalamnya sebenarnya:

1. hasil (tidak ditentukan), hasil = [] , lastIndex =0
2. hasil = 'asdf', hasil =[ 'asdf' ] , lastIndex =4
3. hasil = '', hasil = [ 'asdf', '' ], lastIndex = 4,AdvanceStringIndex , mengatur lastIndex ke5
4. hasil = null, hasil =[ 'asdf', '' ] , kembali

Karena itu ada 2 pertandingan.

Bersama dalam obrolan offline dengan yawkat , kami menemukan cara yang intuitif melihat mengapa "abcd".replace(/.*/g, "x")persis menghasilkan dua kecocokan. Perhatikan bahwa kami belum memeriksa apakah itu benar-benar sama dengan semantik yang dipaksakan oleh standar ECMAScript, maka anggap saja sebagai aturan praktis.

Aturan Jempol

• Pertimbangkan korek api sebagai daftar tupel (matchStr, matchIndex) dalam urutan kronologis yang menunjukkan bagian string mana dan indeks dari string input yang telah dimakan.
• Daftar ini terus dibangun mulai dari kiri string input untuk regex.
• Bagian yang sudah dimakan tidak dapat ditandingi lagi
• Penggantian dilakukan pada indeks yang diberikan dengan matchIndexmenimpa substring matchStrpada posisi itu. Jika matchStr = "", maka "penggantian" secara efektif dimasukkan.

Secara formal, tindakan pencocokan dan penggantian digambarkan sebagai lingkaran seperti yang terlihat pada jawaban lainnya .

Contoh mudah

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

   • Daftar pertandingan adalah [("abcd", 0), ("", 4)]

     Khususnya, itu tidak termasuk pertandingan berikut yang orang bisa pikirkan karena alasan berikut:

     • ("a", 0), ("ab", 0): quantifier *serakah
     • ("b", 1), ("bc", 1): karena pertandingan sebelumnya ("abcd", 0), senar "b"dan "bc"sudah dimakan
     • ("", 4), ("", 4) (Yaitu dua kali): posisi indeks 4 sudah dimakan oleh pertandingan nyata pertama

   • Oleh karena itu, string pengganti "x"menggantikan string yang ditemukan tepat pada posisi tersebut: pada posisi 0 itu menggantikan string "abcd"dan pada posisi 4 itu menggantikan"" .

     Di sini Anda dapat melihat bahwa penggantian dapat berfungsi sebagai penggantian yang benar dari string sebelumnya atau hanya sebagai penyisipan string baru.

2. "abcd".replace(/.*?/g, "x")dengan keluaran kuantifier malas*?"xaxbxcxdx"

   • Daftar pertandingan adalah [("", 0), ("", 1), ("", 2), ("", 3), ("", 4)]

     Berbeda dengan contoh sebelumnya, di sini ("a", 0), ("ab", 0), ("abc", 0), atau bahkan ("abcd", 0)tidak termasuk karena kemalasan quantifier yang ketat membatasi untuk menemukan pertandingan yang sesingkat mungkin.

   • Karena semua string kecocokan kosong, tidak ada penggantian yang sebenarnya terjadi, melainkan penempatan xpada posisi 0, 1, 2, 3, dan 4.

3. "abcd".replace(/.+?/g, "x")dengan keluaran kuantifier malas+?"xxxx"

   • Daftar pertandingan adalah [("a", 0), ("b", 1), ("c", 2), ("d", 3)]

4. "abcd".replace(/.{2,}?/g, "x")dengan keluaran kuantifier malas[2,}?"xx"

   • Daftar pertandingan adalah [("ab", 0), ("cd", 2)]

5. "abcd".replace(/.{0}/g, "x")output "xaxbxcxdx"dengan logika yang sama seperti pada contoh 2.

Contoh yang lebih sulit

Kami dapat secara konsisten mengeksploitasi gagasan penyisipan dan bukan penggantian jika kami hanya selalu mencocokkan string kosong dan mengontrol posisi di mana kecocokan tersebut terjadi untuk keuntungan kami. Sebagai contoh, kita dapat membuat ekspresi reguler yang cocok dengan string kosong di setiap posisi genap untuk menyisipkan karakter di sana:

1. "abcdefgh".replace(/(?<=^(..)*)/g, "_"))dengan lookbehind positif(?<=...) output "_ab_cd_ef_gh_"(hanya didukung di Chrome sejauh ini)

   • Daftar pertandingan adalah [("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

2. "abcdefgh".replace(/(?=(..)*$)/g, "_"))dengan output lookahead positif(?=...)"_ab_cd_ef_gh_"

   • Daftar pertandingan adalah [("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

Pertandingan pertama jelas "asdf"(Posisi [0,4]). Karena flag global ( g) diatur, ia melanjutkan pencarian. Pada titik ini (Posisi 4), ia menemukan kecocokan kedua, string kosong (Posisi [4,4]).

Ingat bahwa *cocok dengan nol atau lebih elemen.

sederhananya, yang pertama xadalah untuk penggantian yang cocok asdf.

kedua xuntuk string kosong sesudahnya asdf. Pencarian berakhir ketika kosong.