Est-il une RegExp.s'échapper de la fonction en Javascript?

Je veux juste créer une expression régulière en dehors de toute chaîne possible.

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

Est-il une méthode intégrée pour qui? Si non, que les gens utilisent-ils? Ruby a RegExp.escape. Je ne me sens pas comme si j'avais besoin d'écrire ma propre, il doit bien y avoir quelque chose de standard là-bas. Merci!

Voulais juste vous mettre à jour amende folk RegExp.escape est actuellement travaillé sur et de toute personne qui pense qu'ils ont de précieux commentaires sont les bienvenus pour contribuer. core-js et d'autres polyfills l'offrir.
Selon le mise à jour récente de cette réponse cette proposition a été rejetée: Voir l'émission

InformationsquelleAutor Lance Pollard | 2010-08-24

javascript regex

529

La relation entre la fonction ci-dessus est insuffisante. Il ne parvient pas à échapper ^ ou $ (de début et de fin de chaîne), ou -, qui, dans un groupe de caractères est utilisé pour des gammes.

Utiliser cette fonction:
```
RegExp.escape= function(s) {
    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\$&');
};
```
Bien qu'il peut sembler inutile à première vue, échappant - (ainsi que ^) rend la fonction appropriée pour échapper les caractères à insérer dans une classe de caractères, ainsi que le corps de la regex.

Échapper / rend la fonction appropriée pour échapper les caractères à être utilisé dans un JS regex littéral pour plus tard eval.

Comme il n'y a aucun inconvénient à échapper à l'un ou l'autre, il fait sens pour échapper à couvrir un plus large éventail de cas d'utilisation.

Et oui, c'est un résultat décevant à défaut que ce n'est pas une partie de JavaScript standard.
- Ce qui ne l' $& faire?
- Il représente l'ensemble de la chaîne trouvée, comme le "groupe 0" dans beaucoup d'autres regex systèmes. doc
- Je crois que l'original de la réponse est bonne, avant de le modifier. Je suis assez sûr de s'échapper de la barre oblique à l'intérieur de la classe de personnage n'est pas nécessaire. Il semble ne pas faire de mal, mais n'est pas obligatoire.
- en fait, nous n'avons pas besoin d'échapper à / à tous
- Est-ce le comportement attendu: RegExp.escape('un\.b') === 'un\.b', je m'attendais à un"\\\.b " d'échappement "\" et de s'échapper ".") ?
- vous avez un littéral de chaîne de problème, 'a\.b'==='a.b' 🙂
- BTW, méfiez-vous des débogueur consoles: IE, Firefox et Chrome tous afficher la chaîne a\.b dans un pseudo-littéralement "a\.b", qui est trompeuse, car elle n'est pas valide d'un littéral de chaîne de valeur (ce qui devrait être "a\\.b". Merci pour l'inutile, de la confusion supplémentaire, les navigateurs.
- "c'est décevant, à défaut, cela ne fait pas partie de la norme JavaScript". Quelles langues avez quelque chose comme cela?
- Perl quotemeta (\Q), Python re.escape, PHP preg_quote, Ruby Regexp.quote...
- Si vous allez utiliser cette fonction dans une boucle, il est probablement préférable de faire l'objet RegExp c'est variable var e = /[\-\[\]\/\{\}\*\+\?\.\\\^\$\|]/g; et puis, votre fonction est return s.replace(e, '\\$&'); Cette façon, vous n'instancier la RegExp une fois.
- Vous n'avez pas besoin de s'échapper '-'. Lorsque vous échapper '[', le '-' n'est pas à l'intérieur d'une classe de caractères, et il n'a pas de signification particulière. Le " / " n'est pas nécessaire.
- Salut, cela peut-il être étendu à échapper à la double caractère de guillemet (")?
- il pourrait certainement être, mais je ne peux pas penser à un lieu où " est particulier dans la syntaxe regex donc je ne suis pas sûr de ce que le bénéfice pourrait être.
- vous parlez à propos de JavaScript littéral de chaîne de s'échapper. C'est une chose différente de la regex s'échapper. Ils utilisent tous les deux barres obliques inverses mais sinon, les règles sont assez différents. (Si vous avez une chaîne dans une regex à l'intérieur un littéral de chaîne alors que vous auriez à utiliser les deux types de s'échapper, l'un après l'autre.)
- Standard arguments contre augmentant les objets intégrés appliquer ici, non? Ce qui se passe si une future version de ECMAScript fournit un RegExp.escape dont la mise en œuvre diffère de la vôtre? Ne serait-il pas mieux pour cette fonction, de ne pas être attaché à quelque chose?
- En fait, vous ne sont pas tenus de s'échapper de la / dans les classes de personnage, même si c'est mieux de s'échapper afin de tenir compte de certains éditeurs. Voir ce question.
- Ce n'est pas de travail pour les points décimaux. RegExp("1.3") retour /1.3/ qui est totalement inacceptable. Pi Marillion réponse ci-dessous fonctionne bien lorsque nourris avec des nombres qui contiennent les points décimaux.
- vous semblez avoir appelé le RegExp constructeur au lieu de Regexp.escape...
- Dans un 'hostile' de la fonction générique, vous voudrez sans doute envisager de protéger vous-même à partir de javascript taper en faisant String(s).replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'); Cela aide quand votre chaîne est un nombre, par exemple.
- "Comme il n'y a aucun inconvénient à échapper à l'un d'eux..." Réduit la lisibilité.
- ESLint déclenche une erreur avec cette RegExp par défaut (no-useless-escape): Inutile caractère d'échappement: \/
- bobince ne se soucie pas pour eslint avis
- L'expression peut être réduit à ceci: /[$(-+.\/?[-^{|}]/ (permet d'économiser de 5 caractères). Vous n'avez pas besoin d'échapper à - parce que vous avez déjà échappé [ et ] et cela signifie qu'il ne sera pas groupes de caractères. Aussi, il y a deux séquences de caractères qui peut être écrite sous forme de fourchettes. Entre ( et + (40 à 43) et une autre entre les [ et ^ (91 à 94).
- Mais peut-être que vous voulez pour échapper les caractères à mettre à l'intérieur une plage de caractères. OMI mieux sans danger overescape que de underescape et provoquer des problèmes dans le créneau des cas. FWIW, personnellement, je préfère voir les personnages explicitement ici; nous ne jouons pas le code de golf.
- pourquoi ne sont pas inclus les [double]cite lui-même, je veux dire la conversion de " à \" et ' à \'? str.replace(/[\-\[\]\/\{\}\"\'\*\+\?\.\\\^\$\|]/g, "\\$&");
- ainsi, les citations n'ont aucune signification particulière à l'expression rationnelle (voir Shaggydog du commentaire ci-dessus).
- pour moi échapper les guillemets est important si vous utilisez cette fonction, par exemple comme un handlebarsjs helper ou tout autre moteur de rendu, par exemple si j'utilise handlebarsjs de rendre un fichier JS où j'ai var JSstr = '{{{myStr}}}'; où myStr = "I'm here". Si je ne suis pas d'échapper les guillemets-je obtenir var JSstr = 'I'm here'. Mais je suis conscient que c'est une très particulier et spécifique de la situation.
- ce n'est pas la regex s'échapper, c'est le JavaScript littéral de chaîne de s'échapper. Les règles pour ces syntaxes sont différents et ne sont pas compatibles; l'application d'une regex escaper à myStr ne rendrait pas le résultat correct, même si les citations ont été échappé. Si vous êtes à la rédaction d'une chaîne dans une regex à l'intérieur un littéral de chaîne, vous auriez besoin de regex échapper d'abord, et ensuite chaîne littérale échapper les résultats (afin par exemple d'une barre oblique inverse se termine comme une quadruple-barre oblique inverse).
- Parce que l'obtention de imbriquée échapper droit est délicate, et le résultat de se tromper est si grave (cross-site-scripting vulns), c'est généralement une mauvaise idée d'injecter des données dans le code JavaScript. Vous êtes généralement mieux d'écrire le contenu dans un attribut de données (par exemple <html data-jsstr="{{myStr}}">, à l'aide de guidon est normal HTML échapper), et puis en lisant le contenu de l'attribut statique JS.
- juste une petite question: comment peut-être une mauvaise idée d'injecter des données en Javascript avec un guidon si tout est fait côté serveur, par exemple inline avec la <script> balise à l'intérieur de l'html?
- si l'une des données que vous êtes l'injection provient de l'extérieur de l'application, alors celui qui fournit les données peuvent provoquer code de leur choix pour fonctionner sur les navigateurs de toute autre personne à l'aide de l'application est sortie, leur permettant de faire tout ce que l'utilisateur peut faire sur votre site. C'est Cross-Site Scripting et c'est l'un des pires, les plus répandues des problèmes de sécurité sur le web aujourd'hui.
- Et de le décevoir continue, soit d'années et beaucoup d'autres améliorations plus tard...
- J'ai un string.replaceAll(haystack, needle, replace) fonction. Il appelle haystack.replace( new RegExp( escape(needle), 'g' ), replace); mais je viens de trouver un cas limite où il se casse: 'string en paramètre' donc, si le replace param contient, par exemple, $' ma fonction renvoie des résultats bizarres. Une idée de comment résoudre ce problème? Voir developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
InformationsquelleAutor bobince
100

Pour toute personne utilisant les lodash, depuis la v3.0.0 un _.escapeRegExp fonction est intégrée:
```
_.escapeRegExp('[lodash](https://lodash.com/)');
//→ '\[lodash\]$https:\/\/lodash\.com\/$'
```
Et, dans le cas où vous ne voulez pas besoin de l'ensemble des lodash de la bibliothèque, vous pouvez avoir besoin de juste que la fonction!
- il y a même un mécanisme national de prévention paquet de seulement! npmjs.com/package/lodash.escaperegexp
- Sachez que le escapeRegExp fonction lodash ajoute également \x3 pour le début de la chaîne, pas vraiment sûr de savoir pourquoi.
- Cette importations des charges de code qui n'a pas vraiment besoin d'être là pour une chose si simple. Utilisation bobince de réponse... qui fonctionne pour moi et sa donc beaucoup moins d'octets à la charge de l'lodash version!
- ma réponse commence par "Pour toute personne utilisant les lodash", et j'ai même mentionner que vous pouvez avoir besoin que le escapeRegExp fonction.
- Désolé, j'aurais été un peu plus clair, j'ai inclus le module lié à la votre "juste que la fonction" et c'est ce que je commentais sur. Si vous prenez un coup d'oeil c'est beaucoup de code pour ce qui devrait effectivement être une fonction unique avec un seul regexp en elle. D'accord si vous utilisez déjà lodash alors il est logique de l'utiliser, mais sinon, utiliser l'autre réponse. Désolé pour le manque de clarté de commentaire.
- Je ne vois pas qu' \x3 vous avez mentionné: ma échappé chaînes sont à la recherche de bonnes, juste ce que j'attends
InformationsquelleAutor gustavohenke
38

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

C'est pas mal, mais je préfère une "marche toujours" approche.
```
function regExpEscape(literal_string) {
    return literal_string.replace(/[-[\]{}()*+!<=:?.\/\\^$|#\s,]/g, '\$&');
}
```
Ce sera "totalement échapper à" une chaîne de caractères pour toutes les utilisations suivantes des expressions régulières:
- Insertion dans une expression régulière. E. g. new RegExp(regExpEscape(str))
- Insertion dans une classe de caractères. E. g. new RegExp('[' + regExpEscape(str) + ']')
- Insertion dans nombre entier spécificateur. E. g. new RegExp('x{1,' + regExpEscape(str) + '}')
- Exécution dans la non-expression régulière en JavaScript moteurs.
Caractères Spéciaux Couverts:
- -: Crée un sous-ensemble de caractères dans une classe de caractères.
- [ /]: Commence ou se termine un caractère de classe.
- { /}: Commence ou se termine un spécificateur de la numération.
- ( /): Commence ou se termine un groupe.
- * /+ /?: Spécifie répétition.
- .: Correspond à tout caractère.
- \: Échappe les caractères, et commence à les entités.
- ^: Spécifie le début de la zone de correspondance, et nie correspondant dans une classe de caractères.
- $: Indique la fin de la zone de correspondance.
- |: Spécifie l'alternance.
- #: Spécifie commentaire en libre mode d'espacement.
- \s: Ignoré en libre mode d'espacement.
- ,: Sépare les valeurs dans la numération spécificateur.
- /: Commence ou se termine expression.
- :: Complète le groupe spécial des types, et une partie de Perl style des classes de caractères.
- !: Nie zéro-largeur groupe.
- < /=: Partie de zéro-largeur groupe de spécifications.
Notes:
- / n'est pas strictement nécessaire dans le goût de l'expression régulière. Toutefois, il protège au cas où quelqu'un (frisson) ne eval("/" + pattern + "/");.
- , assure que si la chaîne est destinée à être un nombre entier dans le numérique prescripteur, il va provoquer une RegExp erreur de compilation au lieu d'en silence de la compilation de mal.
- #, et \s n'ont pas besoin d'être échappés en JavaScript, mais dans beaucoup d'autres saveurs. Ils se sont échappés ici dans le cas où l'expression régulière sera ensuite transmise à un autre programme.
Si vous avez aussi besoin d'assurer la pérennité de l'expression régulière contre d'éventuels ajouts à la JavaScript moteur d'expressions régulières capacités, 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 la garantie de ne pas être utilisé pour la syntaxe à l'avenir expression régulière saveurs.

Pour la vraiment de l'assainissement-vif, d'envisager ce cas de bord:
```
var s = '';
new RegExp('(choice1|choice2|' + regExpEscape(s) + ')');
```
Ce devrait compiler fine en JavaScript, mais pas dans certains autres saveurs. Si l'intention de passer à une autre saveur, la valeur null de s === '' doit être vérifiée indépendamment, comme suit:
```
var s = '';
new RegExp('(choice1|choice2' + (s ? '|' + regExpEscape(s) : '') + ')');
```
- Le / n'a pas besoin d'être échappés dans la [...] classe de personnage.
- La plupart de ces n'a pas besoin d'être échappé. "Crée une plage de caractères dans une classe de caractères" - vous n'êtes jamais dans une classe de caractères à l'intérieur de la chaîne. ", Précise le commentaire en libre mode d'espacement, Ignoré en libre mode d'espacement" - non pris en charge javascript. "Sépare les valeurs dans la numération spécificateur" - vous n'êtes jamais numerarion spécificateur de l'intérieur de la chaîne. Aussi, vous ne pouvez pas écrire de texte arbitraire à l'intérieur de nameration spécification. "Commence ou se termine l'expression" - pas besoin de s'échapper. Eval est pas le cas, car il faudrait beaucoup plus s'échapper. [sera poursuivi dans le prochain commentaire]
- ", Complète le groupe spécial des types, et une partie de Perl-style de classes de caractères" - ne semble pas disponible en javascript. "la Négation de largeur nulle groupe, Partie de zéro-largeur groupe de caractéristiques" - vous n'avez jamais de groupes à l'intérieur de la chaîne.
- La raison de ces évasions est d'éliminer les cas limites qui pourraient causer des problèmes dans certains cas d'utilisation. Par exemple, l'utilisateur de cette fonction peut vouloir insérer échappé regex chaîne dans une autre expression régulière dans le cadre d'un groupe, ou même pour une utilisation dans une autre langue en plus de Javascript. La fonction n'est pas de faire des hypothèses comme "je ne serai jamais partie d'une classe de caractères", parce qu'il est destiné à être général. Pour plus de YAGNI approche, voir les autres réponses ici.
- Très bon. Pourquoi est _ pas échappé, si? Ce qui fait en sorte qu'il ne sera probablement pas devenir syntaxe regex plus tard?
- Dans les commentaires à bobince la réponse de l'utilisateur styfle suggéré pour une utilisation dans une boucle pour créer d'abord une RegExp-objet de l'escape-string: var e = /[\-\[\]\/\{\}\*\+\?\.\\\^\$\|]/g; et alors la fonction est comme return s.replace(e, '\\$&');. Pour éviter manuellement s'échapper de la chaîne d'échappement je veux d'abord utiliser la fonction d'origine regExpEscape échapper à votre chaîne d'échappement (see), puis utilisez e = new RegExp(ees,"g") et puis function regExpEscapeFast(literal_string) { return literal_string.replace(e, '\\$&');}. Je ne peux pas le faire fonctionner. Comment bien s'échapper de la chaîne d'échappement?
InformationsquelleAutor Pi Marillion
24

Mozilla Developer Network Guide pour les Expressions Régulières fournit échapper à cette fonction:
```
function escapeRegExp(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, '\$&'); //$& means the whole matched string
}
```
- Pourquoi font-ils échapper à la =? Autant que je sache, ce serait utile pour Perl anticipation des expressions régulières (?=), mais si vous échapper à la ?, vous êtes bon pour aller.
- Vous avez raison. Le MDN page a été mise à jour et = n'est plus inclus.
InformationsquelleAutor quietmint
21

Dans jQueryUI de la saisie semi-automatique widget (version 1.9.1) ils ont un peu différent regex (Ligne 6753), voici l'expression régulière combinée avec @bobince approche.
```
RegExp.escape = function( value ) {
     return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\$&");
}
```
- La seule différence est qu'ils échappent , (ce qui n'est pas un caractère de remplacement), et # et les espaces qui seule question en libre-mode d'espacement (ce qui n'est pas pris en charge par JavaScript). Cependant, ils ne l'obtenez droit de ne pas échapper à la barre oblique.
- Si vous souhaitez réutiliser jquery UI de mise en œuvre plutôt que de coller le code en local, aller avec $.ui.autocomplete.escapeRegex(myString).
- lodash a cela aussi, _. escapeRegExp et npmjs.com/package/lodash.escaperegexp
- v1.12 de même, ok!
InformationsquelleAutor Pierluc SS
12

Rien ne vous empêche de vous simplement échapper à tout caractère non alphanumérique:
```
usersString.replace(/(?=\W)/g, '\\');
```
Vous perdez un certain degré de lisibilité lors re.toString() mais vous gagnez beaucoup de simplicité (et la sécurité).

Selon l'ECMA-262, d'une part, de l'expression régulière "syntaxe de" personnages sont toujours non-alphanumériques, tels que la conséquence est sécuriser, et des séquences d'échappement (\d, \w, \n) sont toujours alphanumériques, tels que, sans fausse contrôle échappe seront produites.
- Simple et efficace. J'aime beaucoup mieux que ce l'on a accepté la réponse. Pour les (très) vieux navigateurs, .replace(/[^\w]/g, '\\$&') fonctionnerait de la même façon.
- Cela échoue en mode Unicode. Par exemple, new RegExp(''.replace(/(?=\W)/g, '\\'), 'u') throws exception parce que \W correspond à chaque unité de code d'une paire de substitution séparément, résultant non valides des codes d'échappement.
- alternative: .replace(/\W/g, "\\$&");
InformationsquelleAutor daluege
11

Il y a un ES7 proposition de RegExp.échapper à https://github.com/benjamingr/RexExp.escape/, avec un polyfill disponible à https://github.com/ljharb/regexp.escape.
- On dirait que cette ne pas le faire dans ES7. Aussi, il semble que c'était rejetée en faveur de la recherche d'un modèle de la balise.
InformationsquelleAutor
6

C'est une version plus courte.
```
RegExp.escape = function(s) {
    return s.replace(/[$-\/?[-^{|}]/g, '\$&');
}
```
Cela inclut la non-méta-caractères de %, &, ', et ,, mais le JavaScript RegExp spécification permet.
- Je ne voudrais pas utiliser ce "plus court" version, depuis les plages de caractères de cacher la liste des personnages, ce qui rend plus difficile de vérifier l'exactitude au premier coup d'œil.
- Je ne serais probablement pas non plus, mais il est posté ici pour plus d'informations.
- affichage "pour information" permet de moins que de l'affichage pour la compréhension. Ne seriez-vous pas d'accord que ma réponse c'est plus clair?
- Au moins, . est raté. Et (). Ou pas? [-^ est étrange. Je ne me souviens pas de ce qui est là.
- Ceux qui sont dans la plage spécifiée.
InformationsquelleAutor kzh
3

XRegExp a une fonction d'échappement:

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

Plus sur: http://xregexp.com/api/#escape

InformationsquelleAutor Antoine Dusséaux
3

Plutôt que de seulement s'échapper les caractères qui va causer 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 contaminé, sauf si elle correspond.

Pour cet exemple, supposons que l'expression suivante:
```
RegExp.escape('be || ! be');
```
Cette listes blanches des lettres, le nombre et les espaces:
```
RegExp.escape = function (string) {
    return string.replace(/([^\w\d\s])/gi, '\\\');
}
```
Retourne:
```
"be \|\| \! be"
```
Cela peut échapper à des personnages qui n'ont pas besoin d'être échappé, mais cela ne veut pas nuire à votre expression (peut-être quelques petites pénalités de temps - mais ça vaut le coup de la sécurité).

InformationsquelleAutor bashaus

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

InformationsquelleAutor Ravi Gadhia

0

Les fonctions dans les autres réponses sont overkill pour échapper à toute les expressions régulières (ils peuvent être utiles pour échapper à pièces des expressions régulières qui seront ensuite concaténés en plus les expressions régulières).

Si vous échapper toute une regexp et sont fait avec elle, citant les caractères de remplacement qui sont, soit de manière autonome (., ?, +, *, ^, $, |, \) ou de commencer quelque chose ((, [, {) est tout ce dont vous avez besoin:
```
String.prototype.regexEscape = function regexEscape() {
  return this.replace(/[.?+*^$|({[\\]/g, '\$&');
};
```
Et oui, c'est décevant que JavaScript n'est pas une fonction comme ceci intégré.
- Disons que vous échapper à la saisie de l'utilisateur (text)next et l'insérer dans: (?: + entrée + ). Votre méthode donnera la chaîne résultante (?:\(text)next) qui ne peut pas compiler. Notez que cela est tout à fait raisonnable d'insertion, et non comme un fou comme re\ + entrée + re (dans ce cas, le programmeur peut être blâmé pour faire quelque chose de stupide)
- ma réponse spécifiquement mentionné échapper ensemble d'expressions régulières et de "fait" avec eux, et non des parties (ou les parties) des expressions régulières. Veuillez annuler le downvote?
- C'est rarement le cas que vous fuyiez l'ensemble de l'expression - il y a opération de chaîne, qui sont beaucoup plus rapides par rapport aux regex, si vous souhaitez travailler avec une chaîne littérale.
- Ce n'est pas de mentionner qu'il est incorrect - \ devrait être échappé, depuis votre regex laissera \w intacte. Aussi, JavaScript ne semble pas permettre de fuite ), au moins c'est ce que Firefox déclenche une erreur pour.
- J'ai échappé à ` dans la réponse. Merci!
- Merci de l'adresse de la partie à propos de la fermeture )
- Il serait bon de s'échapper de la fermeture des accolades trop, même s'ils sont autorisés par certains dialecte. Comme je me souviens, c'est une extension, pas une règle.
InformationsquelleAutor Dan Dascalescu

Un autre (bien sûr) l'approche est d'échapper à tous les personnages (et pas juste un peu spéciale que nous connaissons actuellement) à l'aide de l'échappement unicode format \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 la u drapeau pour que cette méthode fonctionne:

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

InformationsquelleAutor soheilpro

0

Il n'y a jamais été et ne sera jamais 12 méta-caractères doivent être échappés

pour être considéré comme un littéral.

N'a pas d'importance ce qui est fait avec les échappé à la chaîne, inséré dans un équilibre

regex wrapper, en annexe, n'a pas d'importance.

Faire une chaîne de remplacer l'utilisation de ce
```
var escaped_string = oldstring.replace( /[\\^$.|?*+()[{]/g, '\$&' );
```
- qu'en est ]?
InformationsquelleAutor

Vous devez vous connecter pour publier un commentaire.