82 votes

Liste de tous les caractères qui doivent être échappés avant d'être placés dans RegEx?

Est-ce que quelqu'un pourrait donner une liste complète des caractères spéciaux qui doivent être échappés?

Je crains de ne pas tous les connaître.

12 votes

Cette liste était étonnamment difficile à trouver.

75voto

Tatu Ulmanen Points 52098

La fonction preg_quote de PHP prend des chaînes arbitraires et "met un backslash devant chaque caractère qui fait partie de la syntaxe des expressions régulières" et échappe à ces caractères :

. \ + * ? [ ^ ] $ ( ) { } = ! < > | : -

Voici une version simplifiée de la réimplémentation en JavaScript de preg_quote de Locutus:

function escapeRegexChars(str) {
  return str.replace(new RegExp('[.\\\\+*?\\[\\^\\]$(){}=!<>|:\\-]', 'g'), '\\$&')
}

3 votes

Si vous échappez ces caractères avec str_replace, vous devez d'abord échapper \. Dans la liste ci-dessus, si un . est remplacé par \., \. sera ensuite remplacé par \\. , ce qui n'est pas ce qui est voulu.

0 votes

Le deux-points (c'est-à-dire :) ne devrait pas être ici, ce n'est pas un caractère spécial regex en JavaScript.

0 votes

MDN recommande une autre expression dans l'article developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/…

9voto

Andrea Points 7050

Selon ce site, la liste des caractères à échapper est la suivante :

[, le backslash \, le chapeau ^, le signe dollar \, le point ou point ., la barre verticale ou symbole de pipe |, le point d'interrogation ?, l'astérisque ou étoile *, le signe plus +, la parenthèse ouvrante ( et la parenthèse fermante ).

En plus de cela, vous devez échapper les caractères qui sont interprétés par l'interpréteur Javascript comme la fin de la chaîne, c'est-à-dire ' ou ".

0 votes

Je ne sais pas quoi penser de ce site. Il couvre de nombreux types d'expressions régulières et ne spécifie pas à quelles celles cette liste s'applique.

7voto

hngr18 Points 305

Basé sur la réponse de Tatu Ulmanen, ma solution en C# a pris la forme suivante :

private static List RegexSpecialCharacters = new List
{
    "\\",
    ".",
    "+",
    "*",
    "?",
    "[",
    "^",
    "]",
    "$",
    "(",
    ")",
    "{",
    "}",
    "=",
    "!",
    "<",
    ">",
    "|",
    ":",
    "-"
};

foreach (var rgxSpecialChar in RegexSpecialCharacters)
                rgxPattern = input.Replace(rgxSpecialChar, "\\" + rgxSpecialChar);

Notez que j'ai inversé les positions de '\\' et '.', l'échec de traiter les barres obliques en premier conduira à un doublement des '\'s

Modification

Voici une traduction en javascript

var regexSpecialCharacters = [
    "\\", ".", "+", "*", "?",
    "[", "^", "]", "$", "(",
    ")", "{", "}", "=", "!",
    "<", ">", "|", ":", "-"
];

regexSpecialCharacters.forEach(rgxSpecChar => 
    input = input.replace(new RegExp("\\" + rgxSpecChar,"gm"), "\\" + 
rgxSpecChar))

5voto

jj2005 Points 123

À l'intérieur d'un ensemble de caractères, pour faire correspondre un tiret littéral -, il doit être échappé lorsqu'il n'est pas placé au début ou à la fin. Par exemple, étant donné la position du dernier tiret dans le motif suivant, il doit être échappé:

[a-z0-9\-_]+

Mais il n'a pas besoin d'être échappé ici:

[a-z0-9_-]+

Si vous oubliez d'échapper un tiret, le moteur va essayer de l'interpréter comme une plage entre le caractère précédent et le caractère suivant (tout comme a-z correspond à n'importe quel caractère entre a et z).

De plus, les / ne doivent pas être échappés à l'intérieur d'un ensemble de caractères (bien qu'ils doivent l'être lorsque ce n'est pas à l'intérieur d'un ensemble de caractères). Ainsi, la syntaxe suivante est valide:

const pattern = /[/]/;

2voto

Kevin Ushey Points 3764

La réponse ici est devenue un peu plus compliquée avec l'introduction des expressions régulières Unicode en JavaScript (c'est-à-dire des expressions régulières construites avec le drapeau u). En particulier :

  • Les expressions régulières non Unicode prennent en charge les échappements "identité"; c'est-à-dire, si un caractère n'a pas d'interprétation spéciale dans le motif de l'expression régulière, l'échapper ne fait rien. Cela implique que /a/ et /\a/ correspondent de manière identique.

  • Les expressions régulières Unicode sont plus strictes - essayer d'échapper un caractère qui n'est pas considéré comme "spécial" est une erreur. Par exemple, /\a/u n'est pas une expression régulière valide.

L'ensemble des caractères spécialement interprétés peut être déduit de la norme ECMAScript; par exemple, avec ECMAScript 2021, https://262.ecma-international.org/12.0/#sec-patterns, nous voyons les caractères de "syntaxe" suivants :

CaractèreDeSyntaxe :: un parmi
    ^ $ \ . * + ? ( ) [ ] { } |

En particulier, contrairement à d'autres réponses, notez que les caractères !, <, >, : et - ne sont pas considérés comme des caractères de syntaxe. Au lieu de cela, ces caractères ne peuvent avoir une interprétation spéciale que dans des contextes spécifiques.

Par exemple, les caractères < et > n'ont une interprétation spéciale que lorsqu'ils sont utilisés comme nom de groupe de capture; par exemple dans

/(?\w+)/

Et comme les caractères < et > ne sont pas considérés comme des caractères de syntaxe, les échapper est une erreur dans les expressions régulières Unicode.

> /\ /\

`De plus, le caractère-` n'est interprété de manière spéciale que dans une classe de caractères, lorsqu'il est utilisé pour exprimer une plage de caractères, comme par exemple :

/[a-z]/

Il est valide d'échapper un - dans une classe de caractères, mais pas en dehors d'une classe de caractères, pour les expressions régulières Unicode.

> /\-/
/\-/

> /\-/u
Uncaught SyntaxError: Invalid regular expression: /\-/: Invalid escape

> /[-]/
/[-]/

> /[\-]/u
/[\-]/u

Pour une expression régulière construite en utilisant la syntaxe / / (par opposition à new RegExp()), les slashes internes (/) doivent être échappés, mais cela est nécessaire pour l'analyseur JavaScript plutôt que pour l'expression régulière elle-même, afin d'éviter l'ambiguïté entre un / agissant comme marqueur de fin pour un motif et un / littéral dans le motif.

> /\//.test("/")
true

> new RegExp("/").test("/")
true

En fin de compte, si votre objectif est d'échapper des caractères pour qu'ils ne soient pas interprétés de manière spéciale dans une expression régulière, il suffit d'échapper uniquement les caractères de syntaxe. Par exemple, si nous voulions faire correspondre la chaîne littérale (?:hello), nous pourrions utiliser :

> /\(\?:hello\)/.test("(?:hello)")
true

> /\(\?:hello\)/u.test("(?:hello)")
true

Remarquez que le caractère : n'est pas échappé. Il peut sembler nécessaire d'échapper le caractère : car il a une interprétation spéciale dans le motif (?:hello), mais comme il n'est pas considéré comme un caractère de syntaxe, l'échapper est inutile. (Échapper les caractères précédents ( et ? est suffisant pour assurer que : n'est pas interprété de manière spéciale.)


Les extraits de code ci-dessus ont été testés avec :

$ node -v
v16.14.0

$ node -p process.versions.v8
9.4.146.24-node.20``

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X