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 courte 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 allons d'abord analyser RegExp .

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

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

pattern est une expression régulière pour la recherche (à propos du remplacement plus tard), et flags est une chaîne de n'importe quelle combinaison de caractères g (recherche globale), i (cas insignifiant) et m (recherche multiligne).

La première méthode est utilisée fréquemment, 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.

Réduire / Agrandir le tableau

Symbole Signification
\ Pour les caractères ordinaires - les rend spéciaux. Par exemple, l'expression / s / recherche uniquement le caractère 's'. Et si vous mettez \ devant s, alors \ \ s / indique déjà un caractère d'espace.Inversement, si le caractère est spécial, par exemple *, alors \ le rendra simplement le caractère "astérisque" habituel. Par exemple, / a * / recherche 0 caractères consécutifs ou plus 'a'. Pour trouver un avec l'astérisque 'a *' - mettre \ avant les spets. par le symbole: / a \ * / .
^ Indique le début des données d'entrée. Si le drapeau de recherche multiligne ("m") est défini , il fonctionnera également quand 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 le drapeau de recherche multiligne est positionné, 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 ou plusieurs fois. Par exemple, / bo * / trouvera "boooo" dans "Un fantôme booooed" et "b" dans "Un oiseau warbled", mais ne trouvera rien dans "Une chèvre grognée".
+ Indique une répétition de 1 ou plusieurs fois. C'est équivalent à {1,} . Par exemple, / a + / trouvera "a" dans "candy" et tout "a" dans "caaaaaaaandy".
? Indique que l'élément peut être présent ou non. Par exemple, / e? Le? / Va trouver 'el' dans 'angel' et 'le' dans "angle." Si utilisé immédiatement après l'un des quantificateurs * , + ,? ou {} , il spécifie une recherche "non gourmande" (la répétition est le nombre de fois le plus petit possible), contrairement au mode par défaut "gourmand", dans lequel le nombre de répétitions est maximum, même si l'élément suivant le suit. ,? est utilisé dans l'aperçu, qui est décrit dans le tableau sous (? =) , (?!) et (? :) .
. (Point décimal) signifie n'importe quel caractère, à l'exception du 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 « allumé » dans «non, une pomme est sur l'arbre», mais pas «non».
( x ) Trouve x et se souvient. C'est ce qu'on appelle des "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 des résultats de recherche ou dans les propriétés prédéfinies de l'objet RegExp: $ 1, ..., $ 9. De plus, les parenthèses combinent ce qui est en eux, 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 "supports 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 parenthèses, ils combinent celui qui se trouve dans eux dans un sous-masque unique.
x (? = y ) Trouvez x seulement si x est suivi de y . Par exemple, / Jack (? = Sprat) / trouve 'Jack' seulement s'il est suivi par 'Sprat'. / Jack (? = Sprat | Frost) / ne trouvera 'Jack' que s'il est suivi de 'Sprat' ou 'Frost'. Cependant, ni "Sprat" ni "Frost" ne seront inclus dans le résultat de la recherche.
x (?! y ) Trouvez x seulement si x ne suit pas y . Par exemple, /\d+(?!\.)/ ne trouvera un nombre que s'il n'est pas suivi d'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 nombre 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 a dans "caaandy".
{ n ,} Où n est un nombre entier positif. Trouve n ou plusieurs répétitions de l'élément. Par exemple, / a {2,} ne trouve pas 'a' dans "bonbon", mais trouve tout 'a' dans "caandy" et dans "caaaaaaandy".
{ n , m } Où n et m sont des entiers positifs. Trouver de n à m répétitions d'éléments.
[ xyz ] Jeu de caractères Trouve l'un des personnages listés. Vous pouvez spécifier un écart en utilisant un tiret. Par exemple, [abcd] est le même que [ad] . Trouvez «b» dans la «poitrine», ainsi que «a» et «c» dans le «mal».
[^ xyz ] Tout caractère autre que ceux spécifiés dans l'ensemble. Vous pouvez également spécifier un écart. Par exemple, [^ abc] est le même que [^ ac] . Trouvez «r» dans «poitrine» et «h» dans «côtelette».
[\ 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 "no" 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 "peut-être 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 rechercher uniquement les chiffres normaux. Par exemple, / \ d / ou / [0-9] / trouverez "2" dans "B2 est le numéro de la suite".
\ D Trouver un caractère non numérique (tous les alphabets). [^ 0-9] est l'équivalent pour les chiffres ordinaires. Par exemple, / \ D / ou / [^ 0-9] / trouverez "B" dans "B2 est le numéro de la suite".
\ f, \ r, \ n Les caractères spéciaux correspondants sont le saut de page, le saut de ligne et le saut de ligne.
\ s Trouve n'importe quel caractère d'espace, y compris un espace, une tabulation, des sauts de ligne et d'autres caractères blancs d'unicode. Par exemple, / \ s \ w * / trouvera «barre» dans la barre «foo».
\ S Trouve n'importe quel caractère sauf le caractère 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 tout 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 _] / trouverez également '%' dans "50%".
\ n n est un nombre entier. Une référence vers l'arrière à la nième sous-chaîne mémorisée. Par exemple, / apple (,) \ sorange \ 1 / trouvera "pomme, orange" dans "pomme, orange, cerise, pêche". Il y a un exemple plus complet derrière la table.
\ 0 Trouvez le personnage NUL. N'ajoutez pas d'autres nombres à la fin.
\ x hh Trouvez le caractère avec le code hh (2 chiffres hexadécimaux)
\ uhhhh Trouvez le caractère avec le code hhhh (4 chiffres hexadécimaux).

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

if (/\s/.test ("ligne")) {
... 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 correspondance, null est renvoyé.

Par exemple,

// Trouve 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 Descriptions Exemple:
myArray Contenu de myArray . ["dbBd", "bB", "d"]
indice Match Index (à partir de 0) 1
input La chaîne source cdbBdbsbz
[0] Caractères correspondants récents dbBd
[1], ... [ n ] Correspondances dans les crochets imbriqués, le cas échéant. Le nombre de parenthèses imbriquées est illimité. [1] = bB
[2] = d
myRe lastIndex L'index à partir duquel commencer la recherche suivante. 5
ignoreCase Indique qu'une recherche insensible à la casse a été activée, le drapeau " i ". true
global Indique que le drapeau " g " de tous les matchs a été activé. true
multiligne Indique si le drapeau de recherche multi-lignes " m " a été activé. false
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 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é" + monArray [0] + ".";
msg + = "La correspondance suivante 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. Parcourez 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);
if (! prénom)
{
print (entrée + "n'est pas un nom!");
retour;
}

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

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

Toutes les méthodes, à l'exception de replace, peuvent être appelées à la fois avec des objets de type regexp dans les arguments, et avec des chaînes qui sont 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'y a aucune possibilité de spécifier des drapeaux, donc parfois le formulaire complet est également pratique

var i = str.search (new 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 de RegExp ).

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

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

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

Si dans regexp il y a un drapeau g , alors retourne un tableau avec toutes les correspondances.

Pour découvrir simplement si une chaîne correspond à l' expression rationnelle 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 trouver "Chapter", suivi par 1 ou plusieurs chiffres, suivis de 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 = / chapitre (\ d + (\. \ d) *) / i;
trouvé = str.match (re);
alerte (trouvée);

Le script retournera 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 interne

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

var str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
var regexp = / [AE] / gi;
var correspond à = str.match (expression rationnelle);
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 avec une chaîne, mais avec le résultat d'une fonction. Sa syntaxe complète est la suivante:

var newString = str.replace (regexp / substr, newSubStr / fonction)
regexp
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 .
newSubStr
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 substituer à 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 recherché 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:

Motif 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 en tant que deuxième 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 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, l'appel suivant replace renvoie XXzzzz - XX, zzzz.

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

Comme vous pouvez le voir, il y a deux parenthèses dans l'expression régulière, et donc il y a 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)
{
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 .

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