This page has been robot translated, sorry for typos if any. Original content here.

Expressions régulières et caractères spéciaux

Les expressions régulières en javascript ont une forme abrégée spéciale et une syntaxe PCRE standard.

Ils travaillent à travers un objet spécial RegExp .

De plus, les chaînes ont leurs propres méthodes de recherche , de correspondance , de remplacement , mais pour les comprendre, nous analyserons d'abord RegExp .

Un objet de type RegExp , ou plus brièvement une expression régulière, peut être créé de deux manières

/ pattern / drapeaux
nouveau RegExp ("pattern" [, flags])

pattern est une expression régulière pour la recherche (à propos du remplacement ultérieur), et les flags sont une chaîne de toute combinaison de caractères g (recherche globale), i (non significatif de la casse) et m (recherche multiligne).

La première méthode est fréquemment utilisée, la deuxième méthode parfois. Par exemple, deux de ces appels sont équivalents:

var reg = / ab + c / i
var reg = new RegExp ("ab + c", "i")

Au deuxième appel - parce que l'expression régulière entre guillemets, vous devez dupliquer \

// sont équivalents
re = new RegExp ("\\ w +")
re = / \ w + /

Lors de la recherche, vous pouvez utiliser la plupart des fonctionnalités de la syntaxe PCRE moderne.

Collapse / Expand Table

Symbole Signification
\ Pour les personnages ordinaires, les rend spéciaux. Par exemple, l'expression / s / recherche uniquement le caractère 's'. Et si vous mettez \ en face de s, alors \ \ s / indique déjà un caractère d'espacement, à l'inverse, si le caractère est spécial, par exemple *, alors \ fera simplement le caractère "astérisque" habituel. Par exemple, / a * / recherche 0 ou plusieurs caractères consécutifs «a». Pour trouver un avec l'astérisque 'a *' - mettez \ avant spets. par le symbole: / a \ * / .
^ Indique le début des données d'entrée. Si l'indicateur de recherche multiligne ("m") est défini , il fonctionnera également lorsqu'une nouvelle ligne commence. Par exemple, / ^ A / ne trouve pas "A" dans "un A", mais trouve le premier "A" dans "An A."
$ Indique la fin des données d'entrée. Si l'indicateur de recherche multiligne est défini, il fonctionnera également à la fin de la ligne.Par exemple, / t $ / ne trouvera pas «t» dans le «mangeur», mais le trouvera dans «manger».
* Indique une répétition de 0 fois ou plus. Par exemple, / bo * / trouvera "boooo" dans "Un fantôme booooed" et "b" dans "Un oiseau faussé", mais ne trouvera rien dans "Un bouc grogné".
+ Indique une répétition de 1 fois ou plus. C'est équivalent à {1,} . Par exemple, / a + / trouvera «a» dans «bonbon» et tout «a» dans «caaaaaaaandy».
? Indique que l'élément peut ou peut ne pas être présent. Par exemple, / e? Le? / Trouvera «el» dans «ange» et «le» dans «angle». Si utilisé immédiatement après l'un des quantificateurs * , + ,? , ou {} , spécifie une recherche "non gourmande" (la répétition est le nombre minimum possible, au prochain élément de modèle), par opposition au mode par défaut "gourmand", dans lequel le nombre de répétitions est maximum, même si ,? est utilisé dans l'aperçu, qui est décrit dans le tableau sous (? =) , (?!) et (? :) .
. (Point décimal) signifie n'importe quel caractère, sauf le saut de ligne: \ n \ r \ u2028 ou \ u2029. ( vous pouvez utiliser [\ s \ S] pour rechercher n'importe quel caractère, y compris les sauts de ligne). Par exemple, /.n/ trouvera "un" et "on" dans "non, une pomme est sur l'arbre", mais pas "non".
( x ) Trouve x et se souvient. Cela s'appelle "supports de mémoire". Par exemple, / (foo) / trouve et se souvient de «foo» dans «foo bar». La sous-chaîne trouvée est stockée dans le tableau de résultats de la recherche ou dans les propriétés prédéfinies de l'objet RegExp: $ 1, ..., $ 9. En outre, les parenthèses combinent ce qui est dedans, en un seul élément du motif. Par exemple, (abc) * est une répétition abc 0 ou plusieurs fois.
(?: x ) Trouve x , mais ne se souvient pas de ce qu'il a trouvé. C'est ce qu'on appelle des "parenthèses non mémorisables". La sous-chaîne trouvée n’est pas stockée dans le tableau de résultats et les propriétés RegExp. Comme tous les crochets, ils combinent celui qui se trouve en eux dans un seul sous-modèle.
x (? = y ) Trouver x seulement si x est suivi par y . Par exemple, / Jack (? = Sprat) / trouve 'Jack' uniquement s'il est suivi de 'Sprat'. / Jack (? = Sprat | Frost) / ne trouvera "Jack" que s'il est suivi par "Sprat" ou "Frost". Cependant, ni «Sprat» ni «Frost» ne seront inclus dans le résultat de la recherche.
x (?! y ) Trouver x seulement si x ne suit pas y . Par exemple, /\d+(?!\.)/ trouvera un numéro uniquement s'il n'est pas suivi par un point décimal. /\d+(?!\.)/.exec("3.141 ") trouvera 141, mais pas 3.141.
x | y Trouve x ou y . Par exemple, / green | red / trouvera «vert» dans la «pomme verte» et «rouge» dans la «pomme rouge».
{ n } Où n est un entier positif. Trouvez exactement n répétitions de l'élément précédent. Par exemple, / a {2} / ne trouvera pas "a" dans "candy", mais trouvera à la fois un "caandy" et les deux premiers un "caaandy".
{ n ,} Où n est un entier positif. Trouve n ou plusieurs répétitions de l'élément. Par exemple, / a {2,} ne trouve pas «a» dans «bonbons», mais trouve tout «a» dans «caandy» et dans «caaaaaaandy».
{ n , m } Où n et m sont des entiers positifs. Rechercher de n à m répétitions d'éléments.
[ xyz ] Jeu de caractères Trouve l'un des caractères répertoriés. Vous pouvez spécifier un espace en utilisant un tiret. Par exemple, [abcd] est identique à [ad] . Trouvez "b" dans la "poitrine", ainsi que "a" et "c" dans la "douleur".
[^ xyz ] Tout caractère autre que ceux spécifiés dans le jeu. Vous pouvez également spécifier un écart. Par exemple, [^ abc] est identique à [^ ac] . Trouvez 'r' dans 'poitrine' et 'h' dans «coupe».
[\ b] Trouve le caractère de retour arrière. (Ne pas confondre avec \ b .)
\ b Trouve la limite des mots (latin), par exemple un espace. (Ne pas confondre avec [\ b] ). Par exemple, / \ bn \ w / trouvera "non" dans "noonday"; / \ wy \ b / trouvera "ly" dans "peut-être hier".
\ B Indique pas la limite des mots. Par exemple, / \ w \ Bn / trouve "on" dans "noonday", et / y \ B \ w / trouve "ye" dans "probablement hier".
\ c X X est la lettre de A à Z. Indique le caractère de contrôle dans la ligne. Par exemple, / \ cM / indique le caractère Ctrl-M.
\ d trouve un nombre de n'importe quel alphabet (nous avons le même Unicode). Utilisez [0-9] pour trouver uniquement les chiffres normaux. Par exemple, / \ d / ou / [0-9] / trouvera "2" dans "B2 est le numéro de suite".
\ D Trouvez un caractère non numérique (tous les alphabets). [^ 0-9] est l'équivalent des chiffres ordinaires. Par exemple, / \ D / ou / [^ 0-9] / trouvera "B" dans "B2 est le numéro de suite".
\ f, \ r, \ n Les caractères spéciaux correspondants sont des flux de formulaire, des sauts de ligne et des sauts de ligne.
\ s Trouve tout caractère d'espacement, y compris un espace, un onglet, des sauts de ligne et d'autres caractères d'espacement unicode. Par exemple, / \ s \ w * / trouvera "bar" dans la barre des tâches.
\ S Trouve n'importe quel caractère sauf le caractère d'espace. Par exemple, / \ S \ w * / trouvera "foo" dans "foo bar".
\ t Le caractère de tabulation.
\ v Le symbole de la tabulation verticale.
\ w Trouvez n'importe quel caractère verbal (alphabet latin), y compris les lettres, les chiffres et un trait de soulignement. Équivalent à [A-Za-z0-9_] . Par exemple, / \ w / trouvera "a" dans "apple", "5" dans "$ 5.28" et "3" dans "3D".
\ W Trouvez n'importe quel symbole verbal non latin. Équivalent à [^ A-Za-z0-9_] . Par exemple, / \ W / et / [^ $ A-Za-z0-9 _] / trouveront également "%" dans "50%".
\ n n est un entier. Une référence en arrière à la nième sous-chaîne mémorisée. Par exemple, / apple (,) \ sorange \ 1 / trouvera "apple, orange" dans "apple, orange, cherry, peach". Il y a un exemple plus complet derrière la table.
\ 0 Trouvez le caractère NUL. N'ajoutez pas d'autres numéros à la fin.
\ x hh Trouvez le caractère avec le code hh (2 chiffres hexadécimaux)
\ u hhhh Trouvez le caractère avec le code hhhh (4 chiffres hexadécimaux).

Pour vérifier si une chaîne correspond à une expression régulière, utilisez la méthode de test :

if (/\s/.test ("line")) {
... Il y a des espaces dans la ligne! ...
}

La méthode exec renvoie un tableau et définit les propriétés de l'expression régulière.
S'il n'y a pas de correspondances, la valeur null est renvoyée.

Par exemple,

// Trouver un d, suivi de 1 ou plus b, suivi d'un d
// Rappelez-vous trouvé b et le prochain d
// Recherche indépendante du registre
var myRe = / d (b +) (d) / ig;
var myArray = myRe.exec ("cdbBdbsbz");

À la suite de l'exécution du script, il y aura de tels résultats:

Objet Propriété / Index Les descriptions Exemple:
myArray Contenu de myArray . ["dbBd", "bB", "d"]
index Index de match (à partir de 0) 1
entrée La chaîne source cdbBdbsbz
[0] Caractères correspondants récents dbbd
[1], ... [ n ] Correspondances entre parenthèses, le cas échéant. Le nombre de parenthèses imbriquées est illimité. [1] = bB
[2] = d
myRe dernier index L'index à partir duquel lancer la prochaine recherche. 5
ignoreCase Indique qu'une recherche insensible à la casse a été activée, l'indicateur " i ". vrai
global Indique que l'indicateur " g " de toutes les correspondances a été activé. vrai
multiligne Indique si l'indicateur de recherche multiligne " m " a été activé. faux
source Texte de modèle. d (b +) (d)

Si l'indicateur " g " est inclus dans l'expression régulière, vous pouvez appeler la méthode exec plusieurs fois pour trouver des correspondances successives sur la même ligne. Lorsque vous faites cela, la recherche commence sur la sous-chaîne str , avec l'index lastIndex . Par exemple, voici un script:

var myRe = / ab * / g;
var str = "abbcdefabh";
while ((myArray = myRe.exec (str))! = null) {
var msg = "Trouvé" + myArray [0] + ".";
msg + = "La prochaine correspondance commence à" + myRe.lastIndex;
imprimer (msg);
}

Ce script affichera le texte suivant:

Trouvé abb. Le match suivant commence à 3h
Trouvé ab. Le prochain match commence à 9h

Dans l'exemple suivant, la fonction recherche des entrées. Ensuite, parcourez le tableau pour voir s'il existe d'autres noms.

On suppose que tous les noms enregistrés sont dans le tableau A:

var A = [Frank, Emily, Jane, Harry, Nick, Beth, Rick,
Terrence, Carol, Ann, Terry, Frank, Alice, Rick,
"Bill", "Tom", "Fiona", "Jane", "William", "Joan", "Beth"];

recherche de fonction (entrée)
{
var firstName = / \ w + / i.exec (entrée);
si (! firstName)
{
imprimer (entrée + "n'est pas un nom!");
retour
}

var count = 0;
pour (var i = 0; i <A.length; i ++)
{
if (firstName [0] .toLowerCase () == A [i] .toLowerCase ())
compter ++;
}
var midstring = (compte == 1)? "autre a": "les autres ont";
print ("Merci" + count + midstring + "le même nom!")
}

Les méthodes suivantes fonctionnent avec des expressions régulières provenant de chaînes.

Toutes les méthodes, à l'exception de replace, peuvent être appelées à la fois avec des objets de type regexp dans des arguments et avec des chaînes qui sont automatiquement converties en objets RegExp.

Les appels sont donc équivalents:

var i = str.search (/ \ s /) var i = str.search ("\\ s")

Lorsque vous utilisez des guillemets, vous devez dupliquer \ et il n'y a aucune possibilité de spécifier des drapeaux, donc parfois la forme complète est également pratique

var i = str.search (nouveau RegExp ("\\ s", "g"))

Renvoie l'index de l'expression régulière dans une chaîne ou -1.

Si vous voulez savoir si une chaîne correspond à une expression régulière, utilisez la méthode de recherche (similaire aux méthodes de test RegExp). Pour obtenir plus d'informations, utilisez la méthode de correspondance plus lente (similaire à la méthode exec RegExp ).

Cet exemple affiche un message, selon que la chaîne correspond à l'expression régulière.

fonction testinput (re, str) {
if (str.search (re)! = -1)
midstring = "contient";
d'autre
midstring = "ne contient pas";
document.write (str + midstring + re.source);
}

Si regexp n'a pas le drapeau g , il renvoie le même résultat que regexp.exec (string) .

Si dans l'expression régulière, il y a un indicateur g , puis retourne un tableau avec toutes les correspondances.

Pour simplement savoir si une chaîne correspond à l' expression régulière regexp , utilisez regexp.test (string) .

Si vous voulez obtenir le premier résultat, essayez r egexp.exec (string) .

Dans l'exemple suivant, match est utilisé pour rechercher "Chapter", suivi d'un ou plusieurs chiffres, suivis par des chiffres séparés par un point. Dans l'expression régulière, il y a un drapeau i , donc le registre sera ignoré.

str = "Pour plus d'informations, voir le chapitre 3.4.5.1";
re = / chapter (\ d + (\. \ d) *) / i;
found = str.match (re);
alerte (trouvé);

Le script renverra un tableau de correspondances:

  • Chapitre 3.4.5.1 - Chaîne entièrement appariée
  • 3.4.5.1 Première parenthèse
  • .1 - support intérieur

L'exemple suivant illustre l'utilisation d'indicateurs de recherche globaux et insensibles à la casse avec correspondance . On trouvera toutes les lettres de A à E et de a à e, chacune - dans un élément distinct du tableau.

var str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
var regexp = / [AE] / gi;
var matches = str.match (regexp);
document.write (correspondances);
// correspond à = [A, B, C, D, E, A, B, C, D, e]

La méthode replace peut remplacer les occurrences d'une expression régulière non seulement par une chaîne, mais aussi par le résultat d'une fonction. Sa syntaxe complète est la suivante:

var newString = str.replace (regexp / substr, newSubStr / function)
expression rationnelle
L'objet RegExp Ses occurrences seront remplacées par une valeur qui retournera le paramètre numéro 2
substr
Une chaîne qui sera remplacée par newSubStr .
nouveauSubStr
Une chaîne qui remplace une sous-chaîne de l'argument numéro 1.
fonction
Une fonction qui peut être appelée pour générer une nouvelle sous-chaîne (pour la remplacer par la sous-chaîne obtenue à partir de l'argument 1).

La méthode replace ne change pas la ligne sur laquelle elle est appelée, mais renvoie simplement une nouvelle chaîne modifiée.

Pour implémenter un remplacement global, incluez l'indicateur "g" dans l'expression régulière.

Si le premier argument est une chaîne, il n'est pas converti en une expression régulière, par exemple,

var ab = "ab" .replace ("\\ s", "..") // = "ab"

L'appel à remplacer a laissé la chaîne inchangée, car je n'ai pas cherché l'expression régulière \ s , mais la chaîne "\ s".

Dans la ligne de remplacement, il peut y avoir de tels caractères spéciaux:

Modèle Inserts
$$ Insère "$".
$ & Insère la sous-chaîne trouvée.
$ ` Insère une partie de la chaîne qui précède l'occurrence de l'occurrence.
$ ' Insère une partie de la chaîne qui suit l'occurrence de l'occurrence.
$ n ou $ nn n ou nn sont des chiffres décimaux, insère une sous-chaîne d'occurrence stockée avec la nième parenthèse imbriquée, si le premier argument est un objet RegExp.

Si vous spécifiez une fonction comme second paramètre, elle est exécutée à chaque fois qu'elle correspond.

Dans une fonction, vous pouvez générer et renvoyer dynamiquement une chaîne de substitution.

Le premier paramètre de la fonction est la sous-chaîne trouvée. Si le premier argument à remplacer est un objet RegExp , les n paramètres suivants contiennent des correspondances provenant de parenthèses imbriquées. Les deux derniers paramètres sont la position dans la ligne sur laquelle la correspondance s'est produite et la chaîne elle-même.

Par exemple, le remplacement d' appels suivant renverra XXzzzz-XX, zzzz.

remplaçant de fonction (str, p1, p2, offset, s)
{
return str + "-" + p1 + "," + p2;
}
var newString = "XXzzzz" .replace (/ (X *) (z *) /, remplaçant)

Comme vous pouvez le voir, l'expression régulière contient deux parenthèses et il y a donc deux paramètres p1 , p2 dans la fonction.
S'il y avait trois parenthèses, la fonction devrait ajouter le paramètre p3 .

La fonction suivante remplace les mots borderTop par border-top :

function styleHyphenFormat (propertyName)
{
fonction upperToHyphenLower (match)
{
renvoyer '-' + match.toLowerCase ();
}
retourne propertyName.replace (/ [AZ] /, upperToHyphenLower);
}

Pour une compréhension commune des expressions régulières, vous pouvez lire l' article dans Wikipedia .

Ils sont décrits plus en détail dans le livre Beginning Regular Expressions .