Existe-t-il une fonction RegExp.escape en Javascript?

Je veux juste créer une expression régulière à partir de n'importe quelle chaîne possible.

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

Existe-t-il une méthode intégrée pour cela? Sinon, qu'utilisent les gens? Ruby l'a fait RegExp.escape. Je n'ai pas l'impression d'avoir besoin d'écrire le mien, il doit y avoir quelque chose de standard. Merci!

La fonction liée ci-dessus est insuffisante. Il ne parvient pas à s'échapper ^ou $(début et fin de la chaîne), ou -, qui dans un groupe de caractères est utilisé pour les plages.

Utilisez cette fonction:

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

Bien que cela puisse sembler inutile à première vue, l'échappement -(ainsi que ^) rend la fonction appropriée pour les caractères d'échappement à insérer dans une classe de caractères ainsi que le corps de l'expression régulière.

L'échappement /rend la fonction appropriée pour les caractères d'échappement à utiliser dans un littéral d'expression régulière JS pour une évaluation ultérieure.

Comme il n'y a aucun inconvénient à échapper à l'un ou l'autre, il est logique de s'échapper pour couvrir des cas d'utilisation plus larges.

Et oui, c'est décevant à défaut que cela ne fasse pas partie du JavaScript standard.

Pour toute personne utilisant lodash, depuis la v3.0.0, une fonction _.escapeRegExp est intégrée:

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

Et, dans le cas où vous ne souhaitez pas avoir besoin de la bibliothèque lodash complète, vous pouvez avoir besoin de cette fonction !

La plupart des expressions ici résolvent des cas d'utilisation spécifiques uniques.

Ce n'est pas grave, mais je préfère une approche "toujours efficace".

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

Cela "échappera complètement" à une chaîne littérale pour l'une des utilisations suivantes dans les expressions régulières:

• Insertion dans une expression régulière. Par exemplenew RegExp(regExpEscape(str))
• Insertion dans une classe de caractères. Par exemplenew RegExp('[' + regExpEscape(str) + ']')
• Insertion dans le spécificateur de nombre entier. Par exemplenew RegExp('x{1,' + regExpEscape(str) + '}')
• Exécution dans des moteurs d'expression régulière non JavaScript.

Caractères spéciaux couverts:

• -: Crée une plage de caractères dans une classe de caractères.
• [/ ]: Démarre / termine une classe de caractères.
• {/ }: Démarre / termine un spécificateur de numérotation.
• (/ ): Démarre / termine un groupe.
• */ +/ ?: Spécifie le type de répétition.
• .: Correspond à n'importe quel caractère.
• \: Échappe les caractères et démarre les entités.
• ^: Spécifie le début de la zone de correspondance et annule la correspondance dans une classe de caractères.
• $: Spécifie la fin de la zone correspondante.
• |: Spécifie l'alternance.
• #: Spécifie le commentaire en mode d'espacement libre.
• \s: Ignoré en mode d'espacement libre.
• ,: Sépare les valeurs dans le spécificateur de numération.
• /: Démarre ou termine l'expression.
• :: Complète les types de groupes spéciaux et fait partie des classes de caractères de style Perl.
• !: Annule le groupe de largeur nulle.
• </ =: Fait partie des spécifications de groupe de largeur nulle.

Remarques:

• /n'est strictement nécessaire dans aucune saveur d'expression régulière. Cependant, il protège au cas où quelqu'un (frisson) fait eval("/" + pattern + "/");.
• , garantit que si la chaîne est censée être un entier dans le spécificateur numérique, elle provoquera correctement une erreur de compilation RegExp au lieu de se tromper silencieusement.
• #et \sn'ont pas besoin d'être échappés en JavaScript, mais dans de nombreuses autres versions. Ils sont échappés ici au cas où l'expression régulière serait transmise ultérieurement à un autre programme.

Si vous avez également besoin de pérenniser l'expression régulière contre les ajouts potentiels aux capacités du moteur regex JavaScript, je recommande d'utiliser le plus paranoïaque:

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

Cette fonction échappe à tous les caractères sauf ceux explicitement garantis de ne pas être utilisés pour la syntaxe dans les futures versions d'expressions régulières.

Pour les véritables amateurs d'assainissement, considérons ce cas de pointe:

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

Cela devrait compiler correctement en JavaScript, mais ne le sera pas dans d'autres versions. Si vous avez l'intention de passer à une autre saveur, le cas nul de s === ''devrait être vérifié indépendamment, comme ceci:

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

Le Guide des expressions régulières du Mozilla Developer Network fournit cette fonction d'échappement:

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

Dans le widget de saisie semi-automatique de jQueryUI (version 1.9.1), ils utilisent une expression régulière légèrement différente (ligne 6753), voici l'expression régulière combinée à l'approche @bobince.

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

Rien ne devrait vous empêcher de simplement échapper à chaque caractère non alphanumérique:

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

Vous perdez un certain degré de lisibilité en faisant re.toString() mais vous gagnez beaucoup de simplicité (et de sécurité).

Selon ECMA-262, d'une part, l' expression régulière « caractères de syntaxe » sont toujours non-alphanumériques, de sorte que le résultat est sécurisé, et des séquences d'échappement spéciales ( \d, \w, \n) sont toujours alphanumériques de telle sorte qu'aucun échappe de contrôle faux seront produits .

Il existe une proposition ES7 pour RegExp.escape sur https://github.com/benjamingr/RexExp.escape/ , avec un polyfill disponible sur https://github.com/ljharb/regexp.escape .

Il s'agit d'une version plus courte.

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

Cela inclut les caractères non-méta de %, &, 'et ,, mais la spécification RegExp JavaScript permet.

XRegExp a une fonction d'échappement:

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

Plus d'informations sur: http://xregexp.com/api/#escape

Plutôt que d'échapper uniquement aux caractères qui causeront des problèmes dans votre expression régulière (par exemple: une liste noire), pourquoi ne pas envisager d'utiliser une liste blanche à la place. De cette façon, chaque personnage est considéré comme corrompu, sauf s'il correspond.

Pour cet exemple, supposez l'expression suivante:

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

Cette liste blanche lettres, chiffres et espaces:

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

Retour:

"be \|\| \! be"

Cela peut échapper à des personnages qui n'ont pas besoin d'être échappés, mais cela n'entrave pas votre expression (peut-être quelques pénalités de temps mineures - mais cela en vaut la peine pour la sécurité).

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

Les fonctions des autres réponses sont excessives pour échapper des expressions régulières entières (elles peuvent être utiles pour échapper des parties d'expressions régulières qui seront ensuite concaténées dans des expressions rationnelles plus grandes).

Si vous échappez un regexp entier et fini avec elle, citant les métacaractères qui sont soit autonomes ( ., ?, +, *, ^, $, |, \) ou commencer quelque chose ( (, [, {) est tout ce dont vous avez besoin:

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

Et oui, il est décevant que JavaScript n'ait pas de fonction comme celle-ci intégrée.

Une autre approche (beaucoup plus sûre) consiste à échapper à tous les personnages (et pas seulement à quelques caractères spéciaux que nous connaissons actuellement) en utilisant le format d'échappement unicode \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}'

Veuillez noter que vous devez passer le udrapeau pour que cette méthode fonctionne:

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

Il n'y a jamais eu et il n'y aura jamais que 12 méta caractères à échapper
pour être considérés comme un littéral.

Peu importe ce qui est fait avec la chaîne d'échappement, insérée dans un
wrapper regex , ajoutée, n'a pas d'importance.

Remplacez une chaîne en utilisant ceci

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