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 RegExp spécial.

En outre, les lignes ont leurs propres méthodes de recherche , correspondance , remplacement , mais pour les comprendre, analysons d’abord RegExp .

Un objet de type RegExp ou, en bref, une expression régulière, peut être créé de deux manières.

/ pattern / flags
new RegExp ("pattern" [, flags])

motif est une expression régulière à rechercher (le remplacement est tardif) et les indicateurs sont une chaîne de n'importe quelle combinaison des caractères g (recherche globale), i (insensible à la casse) et m (recherche multiligne).

La première méthode est souvent utilisée, la seconde parfois. Par exemple, deux de ces appels sont équivalents:

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

Sur le deuxième appel - parce que l’expression régulière est entre guillemets, vous devez dupliquer \

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

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

Réduire / Développer le tableau

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 \ before s, alors \ \ s / désigne déjà un caractère d'espacement, et inversement, si un caractère est spécial, par exemple *, alors \ faites-en un astérisque ordinaire. Par exemple, / a * / recherche 0 ou plusieurs caractères "a" consécutifs. Pour trouver un astérisque 'a *' - mettez \ before spec. symbole: / a \ * / .
^ Indique le début des données d'entrée. Si l'indicateur de recherche multiligne est défini ("m") , cela fonctionnera également lors du lancement d'une nouvelle ligne. Par exemple, / ^ A / ne trouvera pas "A" dans "un A", mais trouvera le premier "A" dans un "A".
$ Indique la fin des données d'entrée. Si le drapeau de recherche multiligne est défini, cela fonctionnera également à la fin de la ligne: par exemple, / t $ / ne trouvera pas le "t" dans le "mangeur", mais le trouvera dans le "mange".
* Indique la répétition de 0 fois ou plus. Par exemple, / bo * / trouvera "boooo" dans "Un fantôme booooed" et "b" dans "Un oiseau déformé", mais ne trouvera rien dans "Une chèvre grognée".
+ Indique la répétition 1 fois ou plus. Équivalent à {1,} . Par exemple, / a + / trouvera "a" dans "bonbon" et tout "a" dans "caaaaaaandy".
? Indique que l'élément peut être ou ne pas être présent. Par exemple, / e? Le? / Trouvera 'el' dans "angel" et 'le' in "angle". S'il est utilisé immédiatement après l'un des quantificateurs * , + ,? ou {} , il définit une recherche non gourmande (répétant le nombre minimum de fois possible, jusqu'au prochain élément suivant du modèle), par opposition au mode gourmand par défaut, dans lequel le nombre de répétitions est maximal, même si l'élément suivant du modèle convient également. , utilisé dans l'aperçu, décrit dans le tableau sous (? =) , (?!) et (? :) .
. (Point décimal) signifie n’importe quel caractère sauf la nouvelle 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 "an" et "on" dans "non, une pomme est sur l'arbre", mais pas "non".
( x ) Trouve x et se souvient. C'est ce qu'on appelle les «supports de mémoire». Par exemple, / (foo) / trouvera et se souviendra de "foo" dans "foo bar". La sous-chaîne trouvée est stockée dans le tableau des résultats de la recherche ou dans les propriétés prédéfinies de l'objet RegExp: 1 $, ..., 9 $. De plus, les crochets combinent ce qu’ils contiennent en un seul élément du motif. Par exemple, (abc) * - répéter abc 0 ou plusieurs fois.
(?: x ) Trouve x , mais ne se souvient pas de ce qui a été trouvé. C'est ce qu'on appelle les «crochets non mémorisables». La sous-chaîne trouvée n'est pas stockée dans le tableau de résultats ni dans les propriétés RegExp. Comme tous les crochets, elles combinent celles-ci en un seul sous-motif.
x (? = y ) Trouve x seulement si x suit x . Par exemple, / Jack (? = Sprat) / ne trouvera "Jack" que s'il est suivi de "Sprat". / Jack (? = Sprat | Frost) / trouvera "Jack" uniquement s'il est suivi de "Sprat" ou "Frost". Toutefois, ni "Sprat" ni "Frost" ne seront entrés dans le résultat de la recherche.
x (?! y ) Trouve x uniquement si x n'est pas suivi de y . Par exemple, /\d+(?!\.)/ ne trouvera le numéro que s'il n'est pas suivi d'un point décimal. /\d+(?!\.)/.exec ("3.141") trouvera 141, mais pas 3.141.
x | y Trouvez x ou y . Par exemple, / green | red / trouvera "green" dans "pomme verte" et "rouge" dans "pomme rouge".
{ n } Où n est un entier positif. Trouve 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 a dans "caandy" et les deux premiers a dans "caaandy".
{ n ,} Où n est un entier positif. Trouve n ou plusieurs répétitions de l'élément. Par exemple, / a {2,} ne trouvera pas "a" dans "candy", mais trouvera tout "a" dans "caandy" et dans "caaaaaaandy".
{ n , m } Où n et m sont des entiers positifs. Trouver de n à m répétitions de l'élément.
[ xyz ] Jeu de caractères Trouve n'importe lequel des personnages listés. Vous pouvez spécifier un espace en utilisant un tiret. Par exemple, [abcd] est identique à [ad] . Trouve "b" dans la poitrine, ainsi que "a" et "c" dans le mal.
[^ xyz ] Tout caractère sauf ceux spécifiés dans le jeu. Vous pouvez également spécifier un espace. Par exemple, [^ abc] est identique à [^ ac] . Trouvera "r" dans "poitrine" et "h" dans "hacher".
[\ b] Trouve le caractère de retour arrière. (À ne pas confondre avec \ b .)
\ b Trouve la limite de mots (latin), par exemple un espace. (À ne pas confondre avec [\ b] ). Par exemple, / \ bn \ w / trouvera "no" dans "noonday"; / \ wy \ b / trouvera le 'ly' dans "éventuellement hier".
\ B Indique aucune limite de mot. Par exemple, / \ w \ Bn / trouvera "on" dans "noonday" et / y \ B \ w / trouvera "ye" dans "peut-être hier".
\ c X X est la lettre de A à Z. Indique le caractère de contrôle dans la chaîne. Par exemple, / \ cM / désigne le caractère Ctrl-M.
\ d trouve un chiffre de n'importe quel alphabet (nous avons le même unicode). Utilisez [0-9] pour ne trouver que des nombres réguliers. Par exemple, / \ d / ou / [0-9] / trouvera "2" dans "B2 est le numéro de suite".
\ D Recherche un caractère non numérique (tous les alphabets). [^ 0-9] - l'équivalent pour les nombres ordinaires. Par exemple, / \ D / ou / [^ 0-9] / trouvera le "B" dans "B2 est le numéro de suite".
\ f, \ r, \ n Les caractères spéciaux correspondants: saut de page, saut de ligne, saut de ligne.
\ s Il trouvera n'importe quel caractère d'espacement, y compris l'espace, la tabulation, les sauts de ligne et autres caractères d'espacement unicode. Par exemple, / \ s \ w * / trouvera "bar" dans "foo bar".
\ S Trouvez n'importe quel personnage sauf l'espace. Par exemple, / \ S \ w * / trouvera "foo" dans "foo bar".
\ t Caractère de tabulation.
\ v Caractère de tabulation verticale.
\ w Trouve tout caractère verbal (alphabet latin), y compris les lettres, les chiffres et le trait de soulignement. Équivalent à [A-Za-z0-9_] . Par exemple, / \ w / trouvera "a" dans "pomme", "5" dans "5,28 $" et "3" dans "3D".
\ W Trouver un symbole non-lat. Équivalent à [^ A-Za-z0-9_] . Par exemple, / \ W / et / [^ $ A-Za-z0-9 _] / trouveront également le "%" dans "50%".
\ n n est un entier. Référence en arrière à la sous-chaîne mémorisée de la nième parenthèse. Par exemple, / apple (,) \ sorange \ 1 / trouvera 'pomme, orange,' dans 'pomme, orange, cerise, pêche. ". Derrière la table se trouve un exemple plus complet.
\ 0 Trouvez le personnage NUL. Ne pas ajouter d'autres nombres à la fin.
\ x hh Trouver un caractère avec le code hh (2 chiffres hexadécimaux)
\ uhhhhh Recherche le caractère avec le code hhhh (4 chiffres hexadécimaux).

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

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

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

Par exemple

// Trouver un d, suivi d'un ou plusieurs b, suivi d'un d
// Souvenir trouvé b et d suivant
// recherche sensible à la casse
var myRe = / d (b +) (d) / ig;
var myArray = myRe.exec ("cdbBdbsbz");

À la suite du script sera les résultats suivants:

L'objet Propriété / Index Descriptions Exemple
mon tableau Le contenu de myArray . ["dbBd", "bB", "d"]
index Index de correspondance (à partir de 0) 1
entrée Chaîne source cdbBdbsbz
[0] Derniers caractères correspondants dbBd
[1], ... [ n ] Correspondances entre crochets imbriqués, le cas échéant. Le nombre de crochets imbriqués est illimité. [1] = bB
[2] = d
myRe lastIndex Index à partir duquel lancer la recherche suivante. 5
ignorer cas Indique qu'une recherche insensible à la casse a été activée, l'indicateur " i ". vrai
global Indique que l'indicateur de recherche de correspondance " g " a été activé. vrai
multiligne Indique si l'indicateur de recherche multiligne " m " a été activé. faux
source Le texte du motif. d (b +) (d)

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

var myRe = / ab * / g;
var str = "abbcdefabh";
while ((myArray = myRe.exec (str))! = null) {
var msg = "trouvé" + myArray [0] + ".";
msg + = "Le prochain match commence à" + myRe.lastIndex;
imprimer (msg);
}

Ce script affichera le texte suivant:

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

Dans l'exemple suivant, la fonction recherche une entrée. Il parcourt ensuite le tableau pour voir s’il existe d’autres noms.

Il est supposé 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 (! prénom)
{
print (input + "n'est pas un nom!");
retour
}

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

Les méthodes suivantes fonctionnent avec des expressions régulières issues 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 automatiquement converties en objets RegExp.

Donc, les appels sont équivalents:

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

Lorsque vous utilisez des guillemets, vous devez dupliquer \ et il n’existe aucun moyen de spécifier des indicateurs. C’est donc parfois pratique et complet.

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

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

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

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

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

Si l'expression rationnelle n'a pas l'indicateur g , elle renvoie le même résultat que regexp.exec (chaîne) .

Si l'expression rationnelle a le drapeau g , elle retourne un tableau avec toutes les correspondances.

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

Si vous voulez obtenir le premier résultat, essayez le fichier egexp.exec (chaîne) .

Dans l'exemple suivant, match est utilisé pour rechercher "Chapitre", suivi de 1 ou plusieurs chiffres, puis de chiffres séparés par un point. Dans une expression régulière, il existe un drapeau i , le registre sera donc ignoré.

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

Le script renverra un tableau de correspondances:

  • Chapitre 3.4.5.1 - ligne parfaitement appariée
  • 3.4.5.1 - la première tranche
  • .1 - support interne

L'exemple suivant illustre l'utilisation des indicateurs de recherche globale et respectant la casse avec correspondance . Toutes les lettres de A à E et de a à e seront trouvées, chacune dans un élément distinct du tableau.

var str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
var regexp = / [AE] / gi;
var matches = str.match (regexp);
document.write (correspond);
// allumettes = ['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 également par le résultat de l'exécution de la fonction. Sa syntaxe complète est la suivante:

var newString = str.replace (regexp / substr, newSubStr / function)
expression rationnelle
Objet RegExp. Ses entrées seront remplacées par la valeur renvoyée par le paramètre numéro 2
sous-sol
La chaîne à remplacer par newSubStr .
nouveauSubStr
La chaîne qui remplace la sous-chaîne dans l'argument numéro 1.
fonction
Fonction pouvant être appelée pour générer une nouvelle sous-chaîne (pour la remplacer à la place de la sous-chaîne obtenue à partir de l'argument 1).

La méthode replace ne modifie pas la ligne sur laquelle elle a été appelée, mais renvoie simplement une nouvelle ligne modifiée.

Pour effectuer 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 expression régulière. Par exemple,

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

L’appel à remplacer a laissé la chaîne inchangée, car elle ne recherchait pas une expression régulière, mais la chaîne "\ s".

La chaîne de remplacement peut contenir ces caractères spéciaux:

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

Si vous spécifiez une fonction en tant que second paramètre, elle est exécutée à chaque correspondance.

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 à partir des crochets imbriqués. Les deux derniers paramètres sont la position dans la ligne où la coïncidence est survenue et la ligne elle-même.

Par exemple, l'appel à remplacer suivant renverra XXzzzz - XX, zzzz.

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

Comme vous pouvez le constater, l’expression régulière contient deux crochets. Il existe donc deux paramètres p1 , p2 dans la fonction.
S'il y avait trois crochets, le paramètre p3 devrait alors être ajouté à la fonction.

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

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

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

Plus en détail, elles sont décrites dans le livre (eng.) Début des expressions régulières .