Les mots précédents
La syntaxe de base des expressions régulières en JavaScript a été introduite plus tôt. La classe regexp de JavaScript représente des expressions régulières. La chaîne et le regexp définissent les méthodes. L'utilisation d'expressions régulières peut effectuer une puissante correspondance de motifs, une récupération de texte et un remplacement. Cet article présentera des objets regexp d'expressions régulières et des expressions régulières impliquées
Attributs et méthodes
Objet
Les expressions régulières dans JavaScript sont représentées par des objets regexp, et il y a deux façons de les écrire: l'une est la méthode littérale; L'autre est la méthode du constructeur
Méthode d'écriture Perl
Expression régulière Écriture littérale, également connue sous le nom d'écriture Perl, car les caractéristiques d'expression régulières de JavaScript sont empruntées à Perl
Expression régulière Les littéraux sont définis comme des caractères contenus entre une paire de barres obliques (/) et 3 drapeaux peuvent être définis
var expression = / motif / drapeaux;
Le modèle d'appariement des expressions régulières prend en charge les 3 drapeaux suivants:
G: signifie modèle global, c'est-à-dire que le modèle sera appliqué à toutes les chaînes, plutôt que de s'arrêter immédiatement lorsque le premier match sera trouvé
I: Indique le mode insensible à la cas, c'est-à-dire que le cas du motif et de la chaîne est ignoré lors de la détermination de la correspondance.
M: représente le motif multiligne, c'est-à-dire lorsque la fin d'une ligne de texte est atteinte, il continuera de chercher s'il y a un élément correspondant au motif dans la ligne suivante.
// correspond à toutes les instances de 'at' de la chaîne var p = / at / g; // test () renvoie une valeur booléenne pour indiquer si la correspondance peut être trouvée console.log (p.test ('ata')); // trueconsole.log (p.test ('aba')); // falseConstructeur regexp
Comme les objets intégrés ordinaires, les objets d'expression régulière regexp prennent également en charge la forme du constructeur nouveau + regexp ().
Le constructeur regexp reçoit deux paramètres: le modèle de chaîne à correspondre et la chaîne de file d'attente en option (drapeaux). Les trois drapeaux de la chaîne de drapeau et du littéral ont la même signification: «g», «i», «m»
Les deux paramètres du constructeur regexp sont des chaînes. Et toute expression définie à l'aide de la forme littérale peut utiliser des constructeurs
// correspond à toutes les instances de 'at' de la chaîne var p1 = / at / g; // identique à ci-dessus var p2 = new regexp ('at', 'g');[Remarque] La spécification ECMAScript3 stipule qu'une quantité directe d'expression régulière sera convertie en un objet regexp lorsqu'il y sera exécuté. Chaque opération de la quantité directe d'expression régulière représentée par le même code renvoie le même objet. La spécification ECMAScript5 fait les dispositions opposées, et l'expression régulière représentée par le même code est directement comptée à chaque fois.
Toutes les opérations renvoient de nouveaux objets. IE6-8 a toujours été mis en œuvre conformément à la spécification ECMAScript5, il n'y a donc pas de problème de compatibilité
Étant donné que les littéraux des expressions régulières ne prennent pas en charge les variables, si les variables apparaissent dans des expressions régulières, vous ne pouvez utiliser le constructeur regexp que pour épisser les variables dans les paramètres du constructeur regexp comme épissage de chaîne.
【Conseils】 Obtenez l'élément via ClassName
function gallyClass (obj, className) {var elements = obj.getElementsByTagName ('*'); var result = []; Var Pattern = new regexp ('(^ | // s)' + classname + '(// s | $)'); for (var i = 0; i <elements.length; i ++) {if (pattern.test (elements [i] .className)) {result.push (elements [i]); }} Retour Résultat;}Propriétés d'instance
Chaque objet d'instance regexp contient les 5 propriétés suivantes
Global: Booléen La valeur indique si l'indicateur G IgnoreCase: La valeur booléenne indique si l'indicateur I LastIndex: Integer indique la position de caractère du début de la recherche de la correspondance suivante. Il compte à partir de 0 multiline: la valeur booléenne indique si l'indicateur msource: représentation de chaîne de l'expression régulière, qui revient sous la forme littérale plutôt que le modèle de chaîne passé dans le constructeur
Var Pattern = new regexp ('// [bc //] at', 'i'); console.log (patte Console.log (Pattern.Multiline); // FalSeConSole.log (Pattern.LastIndex); // 0Console.log (Pattern.Source); // '/ [BC /] AT'Si vous utilisez la fonction exec () ou test () de regexp et définissez le modèle global «g», la correspondance de l'expression régulière commencera à partir de la position de LastIndex, et le LastIndex sera réinitialisé après le succès de chaque midi. De cette façon, vous pouvez itérer à plusieurs reprises dans la chaîne et trouver chaque résultat correspondant dans la séquence. Cependant, si vous devez appeler la même méthode regexp exec () ou test () pour différentes chaînes, cette variable peut également apporter des résultats correspondants inattendus. Par conséquent, lors du remplacement de la chaîne, vous devez explicitement définir le LastIndex de Regexp sur 0
// la méthode exec () renvoie la correspondance dans un tableau var p = // w / g; var s = 'ab'; console.log (p.lastindex); // 0console.log (p.exec (s)); // ['a'] console.log (p.lastindex); // 1Console.log ( p.exec (s)); // ['b'] console.log (p.lastidex); // 2Console.log (p.exec (s)); // nullconsole.log (p.lastindex); // 0
var p = // w / g; var s1 = 'ab'; var s2 = 'ba'; console.log (p.lastindex); // 0console.log (p.exec (s1)); // ['a'] console.log (p.lastindex); // 1Console.log (p.exec (s2)); // ['a'] console.log (p.Lastindex); // 2
Propriétés du constructeur
Les propriétés du constructeur regexp sont considérées comme des propriétés statiques qui varient en fonction de l'opération d'expression régulière la plus récente effectuée.
Il existe deux façons d'y accéder, à savoir les noms d'attributs longs et les noms d'attributs courts. La plupart des noms d'attribut courts ne sont pas des identificateurs ECMascript valides, ils doivent donc être accessibles via la syntaxe du support carré.
Nom d'attribut long court nom d'attribut court entrée $ _ la dernière chaîne à la correspondance lastmatch $ & le dernier match lastparen $ + le dernier match dernier correspondant à capturer le groupe LeftContex
En utilisant ces propriétés, des informations plus spécifiques peuvent être extraites des opérations effectuées par la méthode Exec () ou Test ()
// test () est utilisé pour tester si une chaîne correspond à une expression régulière et renvoie une valeur booléenne var text = 'Ceci a été un court été'; var modèle = / (.) hort / g; if (pattern.test (text)) {console.log (regexp.input); // 'Ceci a été un court été' console.log (regexp.rightContext); // 'Summer' console.log (regexp.lastmatch); // 'short' console.log (regexp.lastparen); // 'S' console.log (regexp.mulliline); // false.log (regexp ['$ _']); // ' console.log (regexp ['$ `']); // 'Ceci a été un' console 'console.log (regexp [' $ '"]; //' }JavaScript possède 9 propriétés constructeurs pour stocker les groupes de capture. Ces propriétés sont automatiquement remplies lors de l'appel exec () ou test ().
[Remarque] Théoriquement, le regexp. 0 $ qui doit être enregistré dans l'ensemble du texte de correspondance d'expression n'existe pas, la valeur n'est pas définie
//REGEXP.$1/REGEXP.$2/REGEXP.$3… To Regexp. console.log (regexp. 2 $); // t}
Exemple de méthode
Il existe 5 méthodes d'instance d'objets regexp, divisées en deux catégories. Y compris trois méthodes générales d'objet: toString (), tolocalstring (), valeurof () et méthodes de correspondance régulières de test () et exec ()
Méthode commune de l'objet
L'objet regexp hérite de trois méthodes: toString (), tolocalestring () et valueof () de l'objet objet.
【ToString ()】
La méthode toString () renvoie le littéral de l'expression régulière
【Tolocalestring ()】
La méthode tolocalestring () renvoie le littéral de l'expression régulière
【Valeur de ()】
La méthode de valeur de () renvoie l'objet d'expression régulière lui-même
[Remarque] Peu importe ce que l'expression régulière est créée, ces trois méthodes ne renvoient que leur forme littérale
Var Pattern = new regexp ('[bc] at', 'gi'); console.log (pattern.toString ()); // '/ [bc] at / gi'console.log (pattern.tolocalestring ()); // '/ [bc] at / gi'console.log (pattern.valueof ()); // / [bc] at / givar motif = / [bc] at / gi; console.log (pattern.toString ()); // '/ [bc] at / gi'console.log (pattern.tolocalestring ()); // '[bc] at / gi'console.log (pattern.valueof ()); // / [bc] at / giMéthode de correspondance régulière
Il n'y a que deux méthodes de correspondance régulières pour les objets regexp: EXEC () et TEST () respectivement.
【Exec ()】
La méthode exec () est conçue spécifiquement pour capturer des groupes et accepte un paramètre, à savoir la chaîne à laquelle le motif doit être appliqué. Renvoyez ensuite un tableau contenant des informations de correspondance et renvoyez NULL s'il n'y a pas de correspondance.
Dans le tableau de correspondance, le premier élément est une chaîne qui correspond à l'ensemble du modèle, et les autres éléments sont une chaîne qui correspond au groupe de capture dans le motif. S'il n'y a pas de groupe de capture dans le motif, le tableau n'en contient qu'un
Le tableau renvoyé contient deux propriétés supplémentaires: index et entrée. L'index signifie que la correspondance est en position de la chaîne, l'entrée signifie la chaîne où l'expression régulière est appliquée
var text = 'maman et papa et bébé et autres'; var patron = / maman (et papa (et bébé)?)? / gi; var matchses = pattern.exec (texte); console.log (modèle, matchs); // motif Baby '// Matches.Index: 0 // Matches.input: «Maman et papa et bébé et autres»
Pour la méthode Exec (), même si l'indicateur global (g) est défini dans le modèle, il ne renverra qu'une seule correspondance à la fois. Sans définir l'indicateur global, l'appel exec () plusieurs fois sur la même chaîne renvoie toujours les informations de la première correspondance; Alors que lors de la définition de l'indicateur global, chaque appel à Exec () continuera à rechercher un nouveau match dans la chaîne.
var text = 'cat, bat, sat, fat'; var pattern1 = /.at/;var matchses = pattern1.exec (text); console.log (pattern1, matchs); // pattern1.lasteindex: 0 // matchs [0]: 'cat' // matchs.index: 0 // matchs.input: 'cat, bat, bat, sat'var text =' cat, bat, fat ' motif1.exec (texte); Console.log (Pattern1, Matches); //pattern1.lastindex:0//matches[0
var text = 'cat, bat, sat, fat'; var pattern2 = /.at/g;var matchses = motive2.exec (text); console.log (patron2, correspond); //Pattern2.Lastindex:3//matches[0 //pattern2.Lastindex:7//matches[0
【Conseils】 Utilisez la méthode Exec () pour trouver toutes les positions correspondantes et toutes les valeurs
var string = 'j1h342jg24g234j 3g24j1'; var pathing = // d / g; var valisearray = []; // value var indexArray = []; // position var var temp; while ((temp = motive.exec (string))! = null) {valuearray.push (temp [0]); indexArray.push (temp.index); } // ["1", "3", "4", "2", "2", "4", "2", "3", "4", "3", "2", "4", "1"] [1, 3, 4, 5, 8, 9, 11, 12, 13, 16, 18, 19, 21] Console.log (ValueArray, INDEXArray);【test()】
La méthode test () est utilisée pour tester si l'expression régulière peut trouver du texte correspondant dans une chaîne, recevoir un paramètre de chaîne et renvoie vrai lors de la correspondance, sinon renvoie false
var text = '000-00-000'; var modèle = // d {3} - / d {2} - / d {4} /; if (pattern.test (text)) {console.log ('le modèle a été égalé');}De même, lorsque la méthode Test () est appelée, la propriété LastIndex de l'objet regexp sera modifiée. Si un modèle global est spécifié, chaque fois que la méthode Test () est exécutée, la valeur de décalage de LastIndex dans la chaîne sera tenue de correspondre. Par conséquent, différentes chaînes sont vérifiées plusieurs fois avec le même regexp. La valeur LastIndex doit être définie sur 0 après chaque appel.
Var Pattern = /^/d {4 }-/d {2 }-/d{2 }$$/g ;console.log(pattern.test('2016-06-23' )) ;//trueconsole.log(pattern.test('2016-06-23') '' /^/d {4 }-/d{2 }-/d{2 }$/g ;console.log(pattern.test('2016-06-23')) ;//truepattern.lastindex = 0; console.log (Pattern.test ('2016-06-23')); // truepattern.LastiNDEX = 0; console.log (Pattern.Test ('2016-06-23')); // truepattern.lastIndex = 0; Console.log (Pattern.Test ('2016-06-23'); // trueComme mentionné précédemment, JavaScript possède 9 propriétés de constructeur pour stocker les groupes de capture. Ces propriétés seront automatiquement remplies lors de l'appel de la méthode exec () ou test ().
[Remarque] Théoriquement, le regexp. 0 $ qui doit être enregistré dans l'ensemble du texte de correspondance d'expression n'existe pas, la valeur n'est pas définie
if (/ ^ (/ d {4}) - (/ d {2}) - (/ d {2}) $ /. test ('2016-06-23')) {console.log (regexp. $ 1); // '2016' console.log (regexp. 2); // '06' console.log (regexp. console.log (regexp. 0 $); // Undefined}Ce qui précède est le type javascript system_regex regexp type explication des détails. J'espère que tout le monde prend en charge wulin.com ~