Pourquoi «asdf» .replace (/.*/ g, «x») == «xx»?

Je suis tombé sur un fait surprenant (pour moi).

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

Pourquoi deux remplacements? Il semble que toute chaîne non vide sans retour à la ligne produira exactement deux remplacements pour ce modèle. En utilisant une fonction de remplacement, je peux voir que le premier remplacement est pour la chaîne entière et le second pour une chaîne vide.

Conformément à la norme ECMA-262 , String.prototype.replace appelle RegExp.prototype [@@ replace] , qui dit:

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

où rxest /.*/get Sest 'asdf'.

Voir 11.c.iii.2.b:

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

Par conséquent, 'asdf'.replace(/.*/g, 'x')c'est en fait:

1. result (non défini), results = [], lastIndex =0
2. result = 'asdf', results = [ 'asdf' ], lastIndex =4
3. résultat = '', = résultats [ 'asdf', '' ], lastIndex = 4, AdvanceStringIndex, mis à lastIndex5
4. résultat = null, résultats = [ 'asdf', '' ], retour

Il y a donc 2 correspondances.

Ensemble, dans une discussion hors ligne avec yawkat , nous avons trouvé un moyen intuitif de voir pourquoi "abcd".replace(/.*/g, "x")produit exactement deux correspondances. Notez que nous n'avons pas vérifié si elle est complètement égale à la sémantique imposée par la norme ECMAScript, il suffit donc de la prendre comme règle générale.

Règles de base

• Considérez les correspondances comme une liste de tuples (matchStr, matchIndex)dans un ordre chronologique qui indique quelles parties de chaîne et indices de la chaîne d'entrée ont déjà été consommés.
• Cette liste est continuellement constituée à partir de la gauche de la chaîne d'entrée pour l'expression régulière.
• Les pièces déjà consommées ne peuvent plus être appariées
• Le remplacement se fait aux indices donnés en matchIndexécrasant la sous-chaîne matchStrà cette position. Si matchStr = "", alors le "remplacement" est effectivement l'insertion.

Formellement, l'acte d'appariement et de remplacement est décrit comme une boucle comme on le voit dans l'autre réponse .

Exemples simples

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

   • La liste des correspondances est [("abcd", 0), ("", 4)]

     Notamment, il n'inclut pas les correspondances suivantes auxquelles on aurait pu penser pour les raisons suivantes:

     • ("a", 0), ("ab", 0): le quantificateur *est gourmand
     • ("b", 1), ("bc", 1): en raison du match précédent ("abcd", 0), les cordes "b"et "bc"sont déjà mangées
     • ("", 4), ("", 4) (ie deux fois): la position d'index 4 est déjà dévorée par la première correspondance apparente

   • Par conséquent, la chaîne de "x"remplacement remplace les chaînes de correspondance trouvées exactement à ces positions: à la position 0, elle remplace la chaîne "abcd"et à la position 4, elle remplace "".

     Ici, vous pouvez voir que le remplacement peut agir comme un véritable remplacement d'une chaîne précédente ou tout simplement comme l'insertion d'une nouvelle chaîne.

2. "abcd".replace(/.*?/g, "x")avec un quantificateur paresseux*? sorties"xaxbxcxdx"

   • La liste des correspondances est [("", 0), ("", 1), ("", 2), ("", 3), ("", 4)]

     Contrairement à l'exemple précédent, ici ("a", 0),("ab", 0) , ("abc", 0)ou même ("abcd", 0)ne sont pas inclus en raison de la paresse qui limite strictement à trouver le plus possible de la correspondance quantificateurs.

   • Étant donné que toutes les chaînes de correspondance sont vides, aucun remplacement réel ne se produit, mais des insertions de x aux positions 0, 1, 2, 3 et 4.

3. "abcd".replace(/.+?/g, "x") avec un quantificateur paresseux+? sorties"xxxx"

   • La liste des correspondances est [("a", 0), ("b", 1), ("c", 2), ("d", 3)]

4. "abcd".replace(/.{2,}?/g, "x") avec un quantificateur paresseux[2,}? sorties"xx"

   • La liste des correspondances est [("ab", 0), ("cd", 2)]

5. "abcd".replace(/.{0}/g, "x")sorties "xaxbxcxdx"par la même logique que dans l'exemple 2.

Exemples plus difficiles

Nous pouvons toujours exploiter l'idée d' insertion au lieu de remplacement si nous faisons toujours correspondre une chaîne vide et contrôlons la position où de telles correspondances se produisent à notre avantage. Par exemple, nous pouvons créer des expressions régulières correspondant à la chaîne vide à chaque position paire pour y insérer un caractère:

1. "abcdefgh".replace(/(?<=^(..)*)/g, "_"))avec un résultat positif derrière les(?<=...) sorties "_ab_cd_ef_gh_"(uniquement pris en charge dans Chrome jusqu'à présent)

   • La liste des correspondances est [("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

2. "abcdefgh".replace(/(?=(..)*$)/g, "_"))avec une sortie d' anticipation positive(?=...)"_ab_cd_ef_gh_"

   • La liste des correspondances est [("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

Le premier match est évidemment "asdf"(Position [0,4]). Parce que le drapeau mondial (g ) est défini, il continue la recherche. À ce stade (position 4), il trouve une deuxième correspondance, une chaîne vide (position [4,4]).

N'oubliez pas que cela *correspond à zéro ou plusieurs éléments.

simplement, le premier xest pour le remplacement de l'appariementasdf .

deuxième xpour la chaîne vide après asdf. La recherche se termine lorsqu'elle est vide.