¿Por qué es "asdf" .replace (/.*/ g, "x") == "xx"?

Me topé con un hecho sorprendente (para mí).

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

¿Por qué dos reemplazos? Parece que cualquier cadena no vacía sin líneas nuevas producirá exactamente dos reemplazos para este patrón. Usando una función de reemplazo, puedo ver que el primer reemplazo es para toda la cadena, y el segundo es para una cadena vacía.

Según el estándar ECMA-262 , String.prototype.replace llama a RegExp.prototype [@@ replace] , que 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).

donde rxes /.*/gy Ses 'asdf'.

Ver 11.c.iii.2.b:

si. Deje que nextIndex sea AdvanceStringIndex (S, thisIndex, fullUnicode).

Por 'asdf'.replace(/.*/g, 'x')lo tanto, en realidad es:

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

Por lo tanto hay 2 partidos.

Juntos en un chat sin conexión con yawkat , encontramos una forma intuitiva de ver por qué "abcd".replace(/.*/g, "x")exactamente produce dos coincidencias. Tenga en cuenta que no hemos comprobado si es completamente igual a la semántica impuesta por el estándar ECMAScript, por lo tanto, solo tómelo como una regla general.

Reglas de juego

• Considere las coincidencias como una lista de tuplas (matchStr, matchIndex)en orden cronológico que indica qué partes e índices de la cadena de entrada ya se han comido.
• Esta lista se construye continuamente a partir de la izquierda de la cadena de entrada para la expresión regular.
• Las piezas ya consumidas ya no se pueden combinar
• El reemplazo se realiza en los índices dados matchIndexsobrescribiendo la subcadena matchStren esa posición. Si matchStr = "", entonces el "reemplazo" es efectivamente la inserción.

Formalmente, el acto de emparejamiento y reemplazo se describe como un ciclo como se ve en la otra respuesta .

Ejemplos fáciles

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

   • La lista de coincidencias es [("abcd", 0), ("", 4)]

     Notablemente, no incluye las siguientes coincidencias en las que uno podría haber pensado por las siguientes razones:

     • ("a", 0), ("ab", 0): el cuantificador *es codicioso
     • ("b", 1), ("bc", 1): debido al partido anterior ("abcd", 0), las cuerdas "b"y "bc"ya están carcomidas
     • ("", 4), ("", 4) (es decir, dos veces): la posición de índice 4 ya está carcomida por la primera coincidencia aparente

   • Por lo tanto, la cadena de reemplazo "x"reemplaza las cadenas de coincidencia encontradas exactamente en esas posiciones: en la posición 0 reemplaza la cadena "abcd"y en la posición 4 reemplaza "".

     Aquí puede ver que el reemplazo puede actuar como un reemplazo verdadero de una cadena anterior o simplemente como la inserción de una nueva cadena.

2. "abcd".replace(/.*?/g, "x")con salidas cuantificadoras diferidas*?"xaxbxcxdx"

   • La lista de coincidencias es [("", 0), ("", 1), ("", 2), ("", 3), ("", 4)]

     En contraste con el ejemplo anterior, aquí ("a", 0), ("ab", 0), ("abc", 0), o incluso ("abcd", 0)no se incluyen debido a la pereza del cuantificador que se limita estrictamente a encontrar la coincidencia más corta posible.

   • Como todas las cadenas de coincidencia están vacías, no se produce un reemplazo real, sino que se insertan xen las posiciones 0, 1, 2, 3 y 4.

3. "abcd".replace(/.+?/g, "x")con salidas cuantificadoras diferidas+?"xxxx"

   • La lista de coincidencias es [("a", 0), ("b", 1), ("c", 2), ("d", 3)]

4. "abcd".replace(/.{2,}?/g, "x")con salidas cuantificadoras diferidas[2,}?"xx"

   • La lista de coincidencias es [("ab", 0), ("cd", 2)]

5. "abcd".replace(/.{0}/g, "x")salidas "xaxbxcxdx"por la misma lógica que en el ejemplo 2.

Ejemplos más difíciles

Podemos explotar consistentemente la idea de inserción en lugar de reemplazo si solo hacemos coincidir una cadena vacía y controlamos la posición donde tales coincidencias suceden para nuestra ventaja. Por ejemplo, podemos crear expresiones regulares que coincidan con la cadena vacía en cada posición par para insertar un carácter allí:

1. "abcdefgh".replace(/(?<=^(..)*)/g, "_"))con una búsqueda hacia atrás positivos(?<=...) salidas "_ab_cd_ef_gh_"(sólo está soportado en Chrome hasta ahora)

   • La lista de coincidencias es [("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

2. "abcdefgh".replace(/(?=(..)*$)/g, "_"))con salidas positivas anticipadas(?=...)"_ab_cd_ef_gh_"

   • La lista de coincidencias es [("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

El primer partido es obviamente "asdf"(Posición [0,4]). Debido a que la bandera global ( g) está configurada, continúa buscando. En este punto (Posición 4), encuentra una segunda coincidencia, una cadena vacía (Posición [4,4]).

Recuerde que *coincide con cero o más elementos.

simplemente, el primero xes para reemplazar el emparejamiento asdf.

segundo xpara la cadena vacía después asdf. La búsqueda termina cuando está vacía.