随笔 of RegExp JavaScript RegExp Object

Aperçu

Le constructeur RegExp crée un objet expression régulière pour correspondre au texte en utilisant le modèle.

Pour en savoir plus sur les expressions régulières, lisez la section sur les expressions régulières du guide JavaScript.

Grammaire

Texte et symboles constructeurs sont possibles :
/pattern/flags new RegExp(pattern [, flags])

Paramètres

pattern
Texte de l'expression régulière
flags
Si spécifié, l'indicateur peut être une combinaison de valeurs suivantes :

g
Correspondance globale
i
Ignorer la casse
m
Multilignes; permet aux caractères de début et de fin (^ et $) de fonctionner en mode multilignes (par exemple, ^ et $ peuvent correspondre au début et à la fin de chaque ligne de la chaîne (les lignes sont séparées par \n ou \r), et non seulement au début et à la fin de l'entrée entière).
u
Unicode. Considérez le modèle comme une séquence de points de code (code points) Unicode.
y
Viscosité; dans la chaîne cible, ne commencez à correspondre qu'à partir de la position indiquée par la propriété lastIndex de l'expression régulière (et ne tentez pas de correspondre à partir de tout autre index).
Description
Il existe deux méthodes pour créer un objet régulier : la forme littérale et le constructeur. Pour représenter une chaîne de caractères, la forme littérale ne nécessite pas de guillemets, et les paramètres passés au constructeur utilisent des guillemets. L'expression suivante crée la même expression régulière :

/ab+c/i;
new RegExp('ab+c', 'i');
new RegExp(/ab+c/, 'i');

Lorsque l'expression est assignée, la forme littérale fournit l'état de compilation de l'expression régulière, et l'utilisation de la forme littérale est utilisée lorsque l'expression régulière est maintenue en tant que constante. Par exemple, lorsque vous utilisez une forme littérale pour construire une expression régulière dans une boucle, l'expression régulière n'est pas recompilée (recompiled) à chaque itération.
Tandis que le constructeur de l'objet expression régulière, comme new RegExp('ab}}+c') fournit la compilation à temps réel des expressions régulières (runtime compilation). Si vous savez que le modèle d'expression régulière va changer, ou si vous ne savez pas à l'avance quel modèle, mais que vous obtenez ce modèle d'une autre source, comme l'entrée de l'utilisateur, dans ces cas, vous pouvez utiliser le constructeur.
de ECMAScript 6Commence par, lorsque le premier paramètre est une expression régulière et que le second paramètre d'indicateur existe, new RegExp(/ab+c/, 'i') ne lance plus l'exception TypeError ("Le constructeur de RegExp ne prend pas en charge les indicateurs à partir d'autres expressions régulières") ; à la place, utilise ces paramètres pour créer une nouvelle expression régulière.

Lorsque l'on crée un objet RegExp à l'aide du constructeur, il est nécessaire de suivre les règles d'échappement des caractères habituels (ajouter un的反斜杠 \ en avant). Par exemple, voici l'équivalence :

var re = new RegExp("\\w+");
var re = /\w+/;

Définir l'expression régulière par littéral
var expression = /pattern/ flags;
pattern peut être n'importe quel modèle d'expression régulière simple ou complexe
flage indique le comportement de l'expression régulière 1.g：mode global, ne s'arrête pas après avoir trouvé le premier élément correspondant 2.i：mode sans distinction de cas 3.m：mode multiligne
Exemple :

var pattern1 = /at/g; //Correspondre à tous les "at" dans la chaîne
var pattern2 = /.valueOf());/i; //Correspondre au premier "bat" ou "cat", sans distinction de cas
var pattern3 = /.at/gi; //Recherche globale pour les trois caractères se terminant par '.at'. Sans distinction de cas

Tous les caractères de métacaractère utilisés dans le modèle doivent être échappés. Les caractères de métacaractère dans les expressions régulières incluent :([{\^$|?*+.}])
Exemple :

var pattern4 = /\[bc\]at/i; //Correspondre au premier "[bc]at", sans distinction de cas

Constructeur RegExp, accepte2un paramètre, paramètre1:modèle de chaîne à correspondre, paramètre2：indicateur optionnel
Exemple :

var pattern5 = new RegExp("[bc]at", "i");

Remarque : Comme les paramètres de modèle du constructeur RegExp sont tous des chaînes de caractères, dans certains cas, il est nécessaire de faire une double échappement des chaînes. Tous les caractères de métacaractère doivent être échappés en double

Exemple :
Littéral 　　　　　　 Chaine équivalente
/\[bc\]at/ 　　　　 "\\[bc\\]at"
/.at/ 　　　　　　 "\\.at"
/name/\age/ 　　 "name\\/age"
/\d.\d{1,2}/ 　　 "\\d.\\d{1,2"
/\w\\hello\\123/ \\w\\\\hello\\\\123"

"}}3Remarque : la création d'une expression régulière à l'aide de littéraux et d'instanciation n'est pas la même, les littéraux partageront toujours la même instance (ECMAScript

)。Chaque nouvelle instance créée par le constructeur RegExp est une nouvelle instance.

console.log(pattern5propriétés d'instance RegExp //.global);
console.log(pattern5false Si le drapeau g est configuré //.ignoreCase);
console.log(pattern5true Si le drapeau i est configuré //.multiline);
console.log(pattern5false Si le drapeau m est configuré //.lastIndex);
console.log(pattern50 Position de départ pour la recherche du prochain élément correspondant //.source);

[bc]at Représentation en chaîne d'une expression régulière

console.log(pattern5propriétés héritées // /.valueOf());/[bc]at Représentation en chaîne d'une expression régulière
console.log(pattern5.toString()); // /.valueOf());/[bc]at Représentation en chaîne d'une expression régulière
console.log(pattern5.toLocaleString()); // /.valueOf());/[bc]at Représentation en chaîne d'une expression régulière

i Représentation littérale d'une expression régulière
méthode d'instance RegExp

méthode une : exec(), accepte un paramètre, qui est une chaîne de modèle d'application. Retourne un tableau contenant des informations sur le premier élément correspondant, retourne null s'il n'y en a pas, l'instance du tableau retourné contient deux attributs index (emplacement du correspondant dans la chaîne) et input (chaîne appliquée à la regex).
var pattern6 var text = "huang jin liang shi ge hao ren";63= new RegExp("huang( jin liAng( shi ge hao ren)?)&#
;", "i");6var matches = pattern
.exec(text); 
//console.log(matches);
// [ 'huang jin liang shi ge hao ren',
// 'jin liang shi ge hao ren',
// 'shi ge hao ren',
// index: 0,
méthode deux : test(), accepte un paramètre, qui est une chaîne de modèle d'application. Le modèle correspond au paramètre, retourne true, sinon false1 input: 'huang jin liang shi ge hao ren' ]
var pattern7 = "cat, bat, sat";
sat1 var matches7= pattern1);
.exec(text1); //= new RegExp(".at", "gm");
var pattern8 = new RegExp(".at")
sat2 var matches8= pattern1);
.exec(text2); //= new RegExp(".at", "gm");
sat3 var matches8= pattern1);
.exec(text3); //cat
sat4 var matches8= pattern1);
.exec(text4); //bat
sat5 var matches8= pattern1);
.exec(text5); //console.log(matches

null

méthode deux : test(), accepte un paramètre, qui est une chaîne de modèle d'application. Le modèle correspond au paramètre, retourne true, sinon false2 = "000-00-0000";
var pattern9 = new RegExp("\\d{3}-2}-4}
console.log(pattern9.test(text2))
console.log(text2);
if (pattern9.test(text2)) {
console.log("Correspondance réussie");
} else {
console.log("Échec de la correspondance");
}

Attributs du constructeur (non supportés dans certains navigateurs)
Noms d'attributs longs 　　 Noms d'attributs courts 　Description
input 　　　　 $_ 　　 Dernière chaîne à correspondre
lastMatch 　　 $& 　　 Dernier élément de correspondance
lastParen 　　 $+ 　　 Dernier groupe de capture
leftContext 　　 $` 　　 Texte précédant le lastMatch dans la chaîne d'entrée
multiline 　　 $* 　　 Booléen, mode de ligne multiple
rightContext $' 　　 Texte suivant le lastMatch dans la chaîne d'entrée
　　　　　　　　$1~$9 Utilisé pour stocker le groupe de capture n

Dans les limites ECMAScript
1.Anchors \A et \Z pour le début et la fin de la chaîne
2.Recherche vers l'arrière
3.Classes d'union et d'intersection
4.Groupe atomique
5.Support Unicode (sauf les caractères individuels)
6.Groupe de capture nommé
7.Modèle de match s et x
8.Match conditionnel
9.Commentaire d'expression régulière

Juste découvert une méthode pour correspondre à plusieurs lignes dans js

<script>
var s = "Please yes\nmake my day!";
alert(s.match(/yes.*day/));
// Retourne null
alert(s.match(/yes[^]*day/));
// Retourne 'yes\nmake my day'
</script>

Malheureusement, editplus ne peut pas être utilisé, c'est souvent plus pratique d'utiliser dw.