Gibt es eine RegExp.escape-Funktion in Javascript?

Ich möchte nur einen regulären Ausdruck aus einer möglichen Zeichenfolge erstellen.

var usersString = "Hello?!*`~World()[]";
var expression = new RegExp(RegExp.escape(usersString))
var matches = "Hello".match(expression);

Gibt es dafür eine eingebaute Methode? Wenn nicht, was benutzen die Leute? Ruby hat RegExp.escape. Ich habe nicht das Gefühl, dass ich meine eigenen schreiben müsste, da draußen muss es etwas Standardisches geben. Vielen Dank!

Die oben verlinkte Funktion ist unzureichend. Es kann nicht entkommen ^oder $(Anfang und Ende der Zeichenfolge) oder -, das in einer Zeichengruppe für Bereiche verwendet wird.

Verwenden Sie diese Funktion:

function escapeRegex(string) {
    return string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
}

Während es auf den ersten Blick unnötig erscheint, macht das Escape -(sowie ^) die Funktion zum Escapezeichen für Zeichen, die in eine Zeichenklasse eingefügt werden sollen, sowie für den Hauptteil des regulären Ausdrucks.

Durch Escaping /eignet sich die Funktion zum Escapezeichen von Zeichen, die in einem JS-Regex-Literal für eine spätere Auswertung verwendet werden sollen.

Da es keinen Nachteil gibt, einem von beiden zu entkommen, ist es sinnvoll, zu entkommen, um breitere Anwendungsfälle abzudecken.

Und ja, es ist ein enttäuschender Fehler, dass dies nicht Teil von Standard-JavaScript ist.

Für alle, die lodash verwenden, ist seit v3.0.0 eine _.escapeRegExp- Funktion integriert:

_.escapeRegExp('[lodash](https://lodash.com/)');
// → '\[lodash\]\(https:\/\/lodash\.com\/\)'

Und für den Fall, dass Sie nicht die vollständige Lodash-Bibliothek benötigen , benötigen Sie möglicherweise genau diese Funktion !

Die meisten Ausdrücke hier lösen einzelne spezifische Anwendungsfälle.

Das ist okay, aber ich bevorzuge einen "immer funktionierenden" Ansatz.

function regExpEscape(literal_string) {
    return literal_string.replace(/[-[\]{}()*+!<=:?.\/\\^$|#\s,]/g, '\\$&');
}

Dadurch wird eine Literalzeichenfolge für eine der folgenden Verwendungen in regulären Ausdrücken "vollständig entzogen":

• Einfügen in einen regulären Ausdruck. Z.Bnew RegExp(regExpEscape(str))
• Einfügen in eine Zeichenklasse. Z.Bnew RegExp('[' + regExpEscape(str) + ']')
• Einfügen in den Integer Count Specifier. Z.Bnew RegExp('x{1,' + regExpEscape(str) + '}')
• Ausführung in Nicht-JavaScript-Engines für reguläre Ausdrücke.

Abgedeckte Sonderzeichen:

• -: Erstellt einen Zeichenbereich in einer Zeichenklasse.
• [/ ]: Startet / beendet eine Zeichenklasse.
• {/ }: Startet / beendet einen Nummerierungsspezifizierer.
• (/ ): Startet / beendet eine Gruppe.
• */ +/ ?: Gibt an Wiederholungstyp.
• .: Entspricht einem beliebigen Zeichen.
• \: Entkommt Zeichen und startet Entitäten.
• ^: Gibt den Beginn der Übereinstimmungszone an und negiert die Übereinstimmung in einer Zeichenklasse.
• $: Gibt das Ende der Übereinstimmungszone an.
• |: Gibt den Wechsel an.
• #: Gibt einen Kommentar im freien Abstand an.
• \s: Im Freiraummodus ignoriert.
• ,: Trennt Werte im Nummerierungsspezifizierer.
• /: Startet oder beendet den Ausdruck.
• :: Vervollständigt spezielle Gruppentypen und einen Teil der Zeichenklassen im Perl-Stil.
• !: Negiert die Gruppe mit der Breite Null.
• </ =: Teil der Gruppenspezifikationen mit der Breite Null.

Anmerkungen:

• /ist in keinem Geschmack des regulären Ausdrucks unbedingt erforderlich. Es schützt jedoch für den Fall, dass jemand (Schauder) dies tut eval("/" + pattern + "/");.
• , stellt sicher, dass die Zeichenfolge, wenn sie im numerischen Bezeichner eine Ganzzahl sein soll, ordnungsgemäß einen RegExp-Kompilierungsfehler verursacht, anstatt stillschweigend falsch zu kompilieren.
• #und \smüssen nicht in JavaScript maskiert werden, sondern in vielen anderen Varianten. Sie werden hier maskiert, falls der reguläre Ausdruck später an ein anderes Programm übergeben wird.

Wenn Sie den regulären Ausdruck auch gegen mögliche Ergänzungen der Funktionen der JavaScript-Regex-Engine zukunftssicher machen müssen, empfehle ich die Verwendung des paranoideren Ausdrucks:

function regExpEscapeFuture(literal_string) {
    return literal_string.replace(/[^A-Za-z0-9_]/g, '\\$&');
}

Diese Funktion entgeht jedem Zeichen mit Ausnahme derjenigen, die ausdrücklich garantiert nicht für die Syntax in zukünftigen Varianten regulärer Ausdrücke verwendet werden.

Betrachten Sie diesen Randfall für wirklich sanitäre Menschen:

var s = '';
new RegExp('(choice1|choice2|' + regExpEscape(s) + ')');

Dies sollte in JavaScript gut kompiliert werden können, in einigen anderen Varianten jedoch nicht. Wenn beabsichtigt wird, zu einem anderen Geschmack überzugehen, sollte der Nullfall von s === ''unabhängig überprüft werden, wie folgt:

var s = '';
new RegExp('(choice1|choice2' + (s ? '|' + regExpEscape(s) : '') + ')');

Das Mozilla Developer Network-Handbuch für reguläre Ausdrücke bietet diese Escape-Funktion:

function escapeRegExp(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
}

Im Autocomplete-Widget von jQueryUI (Version 1.9.1) wird ein etwas anderer regulärer Ausdruck verwendet (Zeile 6753). Hier ist der reguläre Ausdruck in Kombination mit dem @ bbince-Ansatz.

RegExp.escape = function( value ) {
     return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
}

Nichts sollte Sie davon abhalten, jedem nicht alphanumerischen Zeichen zu entkommen:

usersString.replace(/(?=\W)/g, '\\');

Sie verlieren dabei ein gewisses Maß an Lesbarkeit, gewinnen re.toString()aber viel Einfachheit (und Sicherheit).

Nach ECMA-262, auf der einen Seite, sind reguläre Ausdrücke „Syntaxzeichen“ immer nicht-alphanumerische Zeichen, so dass das Ergebnis ist sicher, und ein speziellen Escape - Sequenzen ( \d, \w, \n) sind immer alphanumerische , so dass keine falsche Steuer entweicht produziert werden .

Es gibt einen ES7-Vorschlag für RegExp.escape unter https://github.com/benjamingr/RexExp.escape/. Eine Polyfüllung finden Sie unter https://github.com/ljharb/regexp.escape .

Dies ist eine kürzere Version.

RegExp.escape = function(s) {
    return s.replace(/[$-\/?[-^{|}]/g, '\\$&');
}

Dazu gehört auch das Nicht-Meta - Zeichen %, &, ', und ,, aber die JavaScript RegExp - Spezifikation ermöglicht dies.

XRegExp hat eine Escape-Funktion:

XRegExp.escape('Escaped? <.>'); // -> 'Escaped\?\ <\.>'

Mehr unter: http://xregexp.com/api/#escape

Anstatt nur Zeichen zu maskieren, die Probleme in Ihrem regulären Ausdruck verursachen (z. B. eine schwarze Liste), sollten Sie stattdessen eine Whitelist verwenden. Auf diese Weise wird jedes Zeichen als verdorben betrachtet, sofern es nicht übereinstimmt.

Nehmen Sie für dieses Beispiel den folgenden Ausdruck an:

RegExp.escape('be || ! be');

Diese Whitelist enthält Buchstaben, Zahlen und Leerzeichen:

RegExp.escape = function (string) {
    return string.replace(/([^\w\d\s])/gi, '\\$1');
}

Kehrt zurück:

"be \|\| \! be"

Dies kann Zeichen entkommen, die nicht entkommen müssen, aber dies behindert Ihren Ausdruck nicht (möglicherweise einige geringfügige Zeitstrafen - aber es lohnt sich aus Sicherheitsgründen).

escapeRegExp = function(str) {
  if (str == null) return '';
  return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
};

Die Funktionen in den anderen Antworten sind übertrieben, um ganze reguläre Ausdrücke zu maskieren (sie können nützlich sein, um Teile regulärer Ausdrücke zu maskieren, die später zu größeren regulären Ausdrücken verkettet werden).

Wenn Sie eine ganze regexp zu entkommen und wird mit ihnen geschehen, die Metazeichen zitiert , die entweder eigenständig sind ( ., ?, +, *, ^, $, |, \) oder beginnt , etwas ( (, [, {) ist alles , was Sie brauchen:

String.prototype.regexEscape = function regexEscape() {
  return this.replace(/[.?+*^$|({[\\]/g, '\\$&');
};

Und ja, es ist enttäuschend, dass JavaScript keine solche Funktion hat.

Ein anderer (viel sicherer) Ansatz besteht darin, alle Zeichen (und nicht nur einige spezielle Zeichen, die wir derzeit kennen) mit dem Unicode-Escape-Format zu maskieren \u{code}:

function escapeRegExp(text) {
    return Array.from(text)
           .map(char => `\\u{${char.charCodeAt(0).toString(16)}}`)
           .join('');
}

console.log(escapeRegExp('a.b')); // '\u{61}\u{2e}\u{62}'

Bitte beachten Sie, dass Sie die bestehen müssen u Flag übergeben müssen, damit diese Methode funktioniert:

var expression = new RegExp(escapeRegExp(usersString), 'u');

Es gab und wird nur 12 Metazeichen geben, die maskiert werden müssen
, um als Literal betrachtet zu werden.

Es spielt keine Rolle, was mit der maskierten Zeichenfolge gemacht wird, die in einen ausgeglichenen
Regex-Wrapper eingefügt und angehängt wird.

Ersetzen Sie damit einen String

var escaped_string = oldstring.replace( /[\\^$.|?*+()[{]/g, '\\$&' );