RegExp.prototype[Symbol.replace]()

str

Ein String, der Ziel der Ersetzung ist.

replacement

Kann ein String oder eine Funktion sein.

• Wenn es ein String ist, wird es den Teilstring ersetzen, der durch den aktuellen regulären Ausdruck übereinstimmt. Eine Anzahl von speziellen Ersetzungsmustern wird unterstützt; siehe den Abschnitt Spezifizieren eines Strings als die Ersetzung in String.prototype.replace.
• Wenn es eine Funktion ist, wird sie für jedes Übereinstimmung aufgerufen und der Rückgabewert als Ersetzungstext verwendet. Die an diese Funktion übergebenen Argumente sind im Abschnitt Spezifizieren einer Funktion als die Ersetzung von String.prototype.replace beschrieben.

Ein neuer String, mit einer, einigen oder allen Übereinstimmungen des Musters, ersetzt durch die angegebene Ersetzung.

Diese Methode wird intern in String.prototype.replace() und String.prototype.replaceAll() aufgerufen, wenn das pattern-Argument ein RegExp Objekt ist. Zum Beispiel liefern die folgenden beiden Beispiele dasselbe Ergebnis.

"abc".replace(/a/, "A");

/a/[Symbol.replace]("abc", "A");

Wenn der Regex global ist (mit dem g-Flag), wird die Methode exec() des Regex wiederholt aufgerufen, bis exec() null zurückgibt. Andernfalls würde exec() nur einmal aufgerufen. Für jedes exec()-Ergebnis wird die Ersetzung basierend auf der Beschreibung in String.prototype.replace() vorbereitet.

Da [Symbol.replace]() exec() weiter aufrufen würde, bis es null zurückgibt, und exec() automatisch den lastIndex des Regex auf 0 zurücksetzt, wenn die letzte Übereinstimmung fehlschlägt, würde [Symbol.replace]() typischerweise keine Seiteneffekte haben, wenn es beendet wird. Wenn der Regex jedoch sticky ist, aber nicht global, wird lastIndex nicht zurückgesetzt. In diesem Fall könnte jeder Aufruf von replace() ein anderes Ergebnis liefern.

const re = /a/y;

for (let i = 0; i < 5; i++) {
  console.log("aaa".replace(re, "b"), re.lastIndex);
}

// baa 1
// aba 2
// aab 3
// aaa 0
// baa 1

Wenn der Regex sticky und global ist, würde er immer noch sticky Matches durchführen – d.h. er würde es nicht schaffen, Übereinstimmungen jenseits des lastIndex zu finden.

console.log("aa-a".replace(/a/gy, "b")); // "bb-a"

Wenn die aktuelle Übereinstimmung ein leerer String ist, würde der lastIndex dennoch voranschreiten – wenn der Regex Unicode-bewusst ist, würde er um einen Unicode-Codepunkt voranschreiten; andernfalls schreitet er um eine UTF-16-Codeeinheit voran.

console.log("😄".replace(/(?:)/g, " ")); // " \ud83d \ude04 "
console.log("😄".replace(/(?:)/gu, " ")); // " 😄 "

Diese Methode existiert, um das Ersetzungsverhalten in RegExp-Unterklassen anzupassen.

Diese Methode kann auf fast die gleiche Weise verwendet werden wie String.prototype.replace(), außer mit dem unterschiedlichen this und der unterschiedlichen Reihenfolge der Argumente.

const re = /-/g;
const str = "2016-01-01";
const newStr = re[Symbol.replace](str, ".");
console.log(newStr); // 2016.01.01

Unterklassen von RegExp können die Methode [Symbol.replace]() überschreiben, um das Standardverhalten zu ändern.

class MyRegExp extends RegExp {
  constructor(pattern, flags, count) {
    super(pattern, flags);
    this.count = count;
  }
  [Symbol.replace](str, replacement) {
    // Perform [Symbol.replace]() `count` times.
    let result = str;
    for (let i = 0; i < this.count; i++) {
      result = RegExp.prototype[Symbol.replace].call(this, result, replacement);
    }
    return result;
  }
}

const re = new MyRegExp("\\d", "", 3);
const str = "01234567";
const newStr = str.replace(re, "#"); // String.prototype.replace calls re[Symbol.replace]().
console.log(newStr); // ###34567

• Polyfill von RegExp.prototype[Symbol.replace] in core-js
• String.prototype.replace()
• String.prototype.replaceAll()
• RegExp.prototype[Symbol.match]()
• RegExp.prototype[Symbol.matchAll]()
• RegExp.prototype[Symbol.search]()
• RegExp.prototype[Symbol.split]()
• RegExp.prototype.exec()
• RegExp.prototype.test()
• Symbol.replace