Por que "asdf" .replace (/.*/g, "x") == "xx"?

Eu me deparei com um fato surpreendente (para mim).

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

Por que duas substituições? Parece que qualquer sequência não vazia sem novas linhas produzirá exatamente duas substituições para esse padrão. Usando uma função de substituição, posso ver que a primeira substituição é para toda a cadeia e a segunda é para uma cadeia vazia.

De acordo com o padrão ECMA-262 , String.prototype.replace chama RegExp.prototype [@@ replace] , que diz:

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

onde rxestá /.*/ge Sestá 'asdf'.

Ver 11.c.iii.2.b:

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

Portanto, na 'asdf'.replace(/.*/g, 'x')verdade é:

1. resultado (indefinido), resultados = [], lastIndex =0
2. resultado = 'asdf', resultados = [ 'asdf' ], lastIndex =4
3. resultado = '', = resultados [ 'asdf', '' ], lastIndex = 4, AdvanceStringIndex, ajustado para lastIndex5
4. resultado = null, resultados = [ 'asdf', '' ], retorno

Portanto, existem 2 correspondências.

Juntos, em um bate-papo offline com o yawkat , encontramos uma maneira intuitiva de ver por que "abcd".replace(/.*/g, "x")exatamente produz duas correspondências. Observe que não verificamos se é totalmente igual à semântica imposta pelo padrão ECMAScript, portanto, tome isso como uma regra geral.

Regras de ouro

• Considere as correspondências como uma lista de tuplas (matchStr, matchIndex)em ordem cronológica que indica quais partes e índices da string de entrada já foram consumidos.
• Essa lista é criada continuamente a partir da esquerda da sequência de entrada do regex.
• As peças já consumidas não podem mais ser correspondidas
• A substituição é feita nos índices fornecidos matchIndexsubstituindo a substring matchStrnessa posição. Se matchStr = "", então a "substituição" é efetivamente inserção.

Formalmente, o ato de correspondência e substituição é descrito como um loop, como visto na outra resposta .

Exemplos fáceis

1. "abcd".replace(/.*/g, "x")saídas "xx":

   • A lista de correspondências é [("abcd", 0), ("", 4)]

     Notavelmente, ele não inclui as seguintes correspondências pelas quais se poderia pensar pelas seguintes razões:

     • ("a", 0), ("ab", 0): o quantificador *é ganancioso
     • ("b", 1), ("bc", 1): devido à partida anterior ("abcd", 0), as cordas "b"e "bc"já estão comidas
     • ("", 4), ("", 4) (ou seja, duas vezes): a posição 4 do índice já foi consumida pela primeira correspondência aparente

   • Portanto, a cadeia de "x"substituição substitui as cadeias de correspondência encontradas exatamente nessas posições: na posição 0 substitui a cadeia "abcd"e na posição 4 substitui "".

     Aqui você pode ver que a substituição pode atuar como uma verdadeira substituição de uma string anterior ou apenas como a inserção de uma nova string.

2. "abcd".replace(/.*?/g, "x")com saídas de um quantificador preguiçoso*?"xaxbxcxdx"

   • A lista de correspondências é [("", 0), ("", 1), ("", 2), ("", 3), ("", 4)]

     Em contraste com o exemplo anterior, aqui ("a", 0), ("ab", 0), ("abc", 0), ou mesmo ("abcd", 0)não estão incluídos devido à preguiça do quantificador que estritamente limita-lo para encontrar a correspondência mais curta possível.

   • Como todas as seqüências de correspondência estão vazias, nenhuma substituição real ocorre, mas inserções xnas posições 0, 1, 2, 3 e 4.

3. "abcd".replace(/.+?/g, "x")com saídas de um quantificador preguiçoso+?"xxxx"

   • A lista de correspondências é [("a", 0), ("b", 1), ("c", 2), ("d", 3)]

4. "abcd".replace(/.{2,}?/g, "x")com saídas de um quantificador preguiçoso[2,}?"xx"

   • A lista de correspondências é [("ab", 0), ("cd", 2)]

5. "abcd".replace(/.{0}/g, "x")saídas "xaxbxcxdx"pela mesma lógica do exemplo 2.

Exemplos mais difíceis

Podemos explorar consistentemente a ideia de inserção em vez de substituição, se sempre correspondermos a uma string vazia e controlar a posição em que essas correspondências acontecem em nossa vantagem. Por exemplo, podemos criar expressões regulares correspondentes à string vazia em todas as posições pares para inserir um caractere:

1. "abcdefgh".replace(/(?<=^(..)*)/g, "_"))com um lookbehind positivos(?<=...) saídas "_ab_cd_ef_gh_"(somente suportadas em cromo até agora)

   • A lista de correspondências é [("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

2. "abcdefgh".replace(/(?=(..)*$)/g, "_"))com saídas positivas à frente(?=...)"_ab_cd_ef_gh_"

   • A lista de correspondências é [("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

A primeira partida é obviamente "asdf"(posição [0,4]). Como o sinalizador global ( g) está definido, ele continua pesquisando. Nesse ponto (posição 4), ele encontra uma segunda correspondência, uma string vazia (posição [4,4]).

Lembre-se de que *corresponde a zero ou mais elementos.

simplesmente, o primeiro xé para a substituição da correspondência asdf.

segundo xpara a sequência vazia depois asdf. A pesquisa termina quando vazia.