Une brève discussion sur l'utilisation d'objets et de supports regexp pour les expressions régulières JS

Création d'un objet regexp:

La création d'expressions régulières régulières peut être effectuée directement, c'est-à-dire des caractères enfermés par Slash "/". Cependant, dans un environnement où des changements de paramètres sont nécessaires, le constructeur regexp () est un meilleur choix:

var reg1 = / '/ w +' / g;

var reg2 = new regexp ('/' // w + / '', 'g');

En comparant les deux méthodes de création, le premier paramètre de Regexp est la chaîne régulière à créer. D'une part, ce n'est pas une représentation directe de la quantité, il n'est donc pas enfermé avec une barre oblique "/"; Au lieu de cela, la marque de citation "'" et le symbole d'échappement "/" doivent être quadratiques échappées dans la chaîne.

De plus, qu'il s'agisse de la quantité directe ou du constructeur regexp (), un nouvel objet regexp est généré et affecté à une variable.

Similitudes et différences entre Match () et Exec ():

Match et Exec sont des moyens courants de faire correspondre les chaînes pour les expressions régulières. Les fonctions implémentées par les deux sont similaires, avec quelques différences subtiles:

1. Comment utiliser

La correspondance est une méthode d'enveloppement des objets avec des chaînes, usage: String.match (regexp);

Exec est une méthode d'un objet d'expression régulière, usage: regexp.exec (string);

2. Résultats retournés

Lorsque Regexp ne définit pas l'indicateur global "G":

Les résultats de retour des deux sont les mêmes. Autrement dit, lorsqu'il n'y a pas de valeur de correspondance, il renvoie NULL, et lorsqu'il y a une valeur de correspondance, il renvoie un tableau (Array). Array [0] est une chaîne correspondante, array [1], array [2] ... correspond aux sous-chaînes correspondantes entre parenthèses dans des expressions régulières. Dans le même temps, le tableau a deux propriétés. Array.Index représente la position initiale de la chaîne de correspondance, et Array.Input représente la chaîne récupérée.

Lorsque Regexp a le jeu de drapeau mondial "G":

La correspondance renvoie un tableau de tableau lorsqu'il y a une valeur. Chaque élément du tableau représente toutes les chaînes qui correspondent, il n'y a donc plus de sous-chaînes correspondantes entre parenthèses. À l'heure actuelle, le tableau n'a pas d'attribut d'index et d'attribut d'entrée.

Exec n'est pas différent des performances sans l'étiquette mondiale "G". Le tableau de tableau renvoyé, le tableau [0] est la chaîne correspondante actuelle, array [1], array [2] ... est la chaîne de correspondance actuelle. À l'heure actuelle, faites attention à la propriété LastIndex de l'objet regexp, qui représente la dernière position à la fin de la chaîne correspondante dans la chaîne d'origine. Lorsqu'il n'y a pas d'autres résultats correspondants, la propriété LastIndex est définie sur 0. Par conséquent, vous pouvez utiliser la boucle LastIndex pour trouver toutes les chaînes correspondantes.

Prise en charge de plusieurs méthodes de correspondance:

Code JS

 var teststr = "maintenant test001 test002"; var re = / test (/ d +) / ig; var r = ""; while (r = re.exec (teststr)) {alert (r [0] + "" + r [1]); }

De plus, vous pouvez également utiliser Teststr.match (RE), mais de cette manière, il n'y a pas d'option pour G, et vous ne pouvez obtenir que le premier match.

1. Règles d'expression régulière

1.1 caractères normaux

Les lettres, les chiffres, les caractères chinois, les soulignements et les marques de ponctuation qui ne sont pas spécifiquement définis dans les chapitres suivants sont tous des "caractères ordinaires". Lorsqu'un caractère normal dans une expression correspond à une chaîne, il correspond au même caractère qu'il.

Exemple 1: Lorsque l'expression "C", lors de la correspondance de la chaîne "ABCDE", le résultat correspondant est: succès; Le contenu correspondant est: "C"; La position de correspondance est: commencez à 2 et se termine à 3. (Remarque: L'indice commence à partir de 0 ou 1, ce qui peut varier en fonction du langage de programmation actuel)

Exemple 2: Lorsque l'expression "BCD", lors de la correspondance de la chaîne "ABCDE", le résultat correspondant est: réussi; Le contenu correspondant est: "BCD"; La position correspondante est: commencez à 1 et se termine à 4.

1.2 Caractères d'échappement simples

Pour certains caractères qui ne sont pas pratiques à écrire, utilisez la méthode d'ajouter "/" à l'avant. Nous connaissons déjà ces personnages.

Il existe d'autres marques de ponctuation qui sont spéciales pour une utilisation dans les chapitres suivants. Après avoir ajouté "/" à l'avant, ils représentent le symbole lui-même. Par exemple: ^ et $ ont des significations spéciales. Si vous voulez faire correspondre les caractères "^" et "$" dans une chaîne, l'expression doit être écrite comme "/ ^" et "/ $".

La méthode de correspondance de ces caractères échappés est similaire aux "caractères normaux". Il correspond également au même personnage.

Exemple 1: Lorsque l'expression "/ $ d", lors de la correspondance de la chaîne "ABC $ DE", le résultat correspondant est: Success; Le contenu correspondant est: "$ d"; La position correspondante est: commencez à 3 et se termine à 5.

1.3 Expressions qui peuvent correspondre aux «plusieurs caractères»

Certaines méthodes de représentation dans des expressions régulières peuvent correspondre à l'un des «caractères multiples». Par exemple, l'expression "/ d" peut correspondre à n'importe quel nombre. Bien qu'il puisse correspondre à n'importe quel personnage, il ne peut en être un, pas multiple. C'est comme lors de la lecture de cartes de poker, les grands et les petits rois peuvent remplacer n'importe quelle carte, mais ils ne peuvent remplacer qu'une seule carte.

Exemple 1: Lorsque l'expression "/ d / d", lors de la correspondance "ABC123", le résultat du match est: Success; Le contenu correspondant est: "12"; La position appariée est: commencer à 3 et se terminer à 5.

Exemple 2: Lorsque l'expression "a./d", lors de la correspondance "AAA100", le résultat du match est: Succès; Le contenu correspondant est: "AA1"; La position appariée est: commencer à 1 et se terminer à 4.

1.4 Personnaliser les expressions qui peuvent correspondre aux «plusieurs caractères»

Utilisez des crochets [] pour contenir une série de caractères qui peuvent correspondre à l'une d'entre elles. Si vous utilisez [^] pour contenir une série de caractères, vous pouvez correspondre à n'importe quel personnage autre que les caractères. De même, bien qu'il puisse correspondre à n'importe lequel d'entre eux, il ne peut en être qu'un, pas multiple.

Exemple 1: Lorsque l'expression "[BCD] [BCD]" correspond "ABC123", le résultat du match est: Succès; Le contenu correspondant est: "BC"; La position appariée est: commencer à 1 et se terminer à 3.

Exemple 2: Lorsque l'expression "[^ ABC]" correspond "ABC123", le résultat du match est: Succès; Le contenu correspondant est: "1"; La position appariée est: commencer à 3 et se terminer à 4.

1.5 Symboles spéciaux qui modifient le nombre de correspondances

Les expressions mentionnées dans le chapitre précédent ne peuvent correspondre qu'un seul caractère ou l'un des multiples caractères. Si vous utilisez une expression plus un symbole spécial qui modifie le nombre de correspondances, vous pouvez répéter le match sans écrire à plusieurs reprises l'expression.

La méthode de l'utilisation est: "Nombre de modifications" est placée après "l'expression modifiée". Par exemple: "[BCD] [BCD]" peut être écrit comme "[BCD] {2}".

Exemple 1: Lorsque l'expression "/d+/.?/d*" est adaptée à "Il coûte 12,5 $", le résultat du match est: réussi; Le contenu correspondant est: "12,5"; La position appariée est: commencer à 10 et se terminer à 14.

Exemple 2: Lorsque l'expression "go {2,8} gle" est appariée avec "Ads by gooooogle", le résultat du match est: succès; Le contenu correspondant est: "gooooogle"; La position appariée est: commencer à 7 et se terminer à 17.

1.6 Quelques autres symboles spéciaux représentant une signification abstraite

Certains symboles représentent la signification particulière de l'abstraction dans les expressions:

D'autres descriptions de texte sont encore relativement abstraites, alors donnez des exemples pour aider tout le monde à comprendre.

Exemple 1: Lorsque l'expression "^ aaa" correspond "xxx aaa xxx", le résultat correspondant est: a échoué. Parce que "^" nécessite une correspondance là où commence la chaîne, "^ aaa" ne peut correspondre que lorsque "aaa" est au début de la chaîne, par exemple: "aaa xxx xxx".

Exemple 2: Lorsque l'expression "aaa $" est adaptée à "xxx aaa xxx", le résultat correspondant est: a échoué. Parce que "$" nécessite la correspondance de la fin de la chaîne, "aaa $" ne peut correspondre que lorsque "AAA" est à la fin de la chaîne, par exemple: "xxx xxx aaa".

Exemple 3: Lorsque l'expression "./b." est égalé à "@@@ ABC", le résultat correspondant est: réussi; Le contenu correspondant est: "@A"; La position de correspondance est: commencez à 2 et terminez à 4.

Explication supplémentaire: "/ b" est similaire à "^" et "$", qui ne correspond à aucun personnage lui-même, mais il faut qu'il soit sur les côtés gauche et droit de la position dans le résultat correspondant, un côté est la gamme "/ w" et l'autre côté est la gamme non - "/ w".

Exemple 4: Lorsque l'expression "/ b" Matchs "le week-end, endor, end", le résultat correspondant est: réussi; Le contenu correspondant est: "fin"; La position de correspondance est: commencer à 15 et se terminer à 18.

Certains symboles peuvent affecter la relation entre les sous-expressions à l'intérieur d'une expression:

Exemple 5: Lorsque l'expression "Tom | Jack" correspond à la chaîne "Je suis Tom, il est Jack", le résultat assorti est: réussi; Le contenu correspondant est: "Tom"; La position correspondante est: commencer à 4 et se terminer à 7. Lors de la correspondance du suivant, le résultat correspondant est: réussi; Le contenu correspondant est: "Jack"; En position de correspondance: commence à 15 et se termine à 19.

Exemple 6: Expression "(go / s *) +" Lors de la correspondance "Allons aller aller!", Le résultat correspondant est: réussi; Le contenu correspondant est: "Allez aller aller"; La position de correspondance est: commencer à 6 et se terminer à 14.

Exemple 7: Lorsque l'expression "￥ (/ d + /.? / D *)" est adaptée à "￥ 10.9, ￥ 20,5", le résultat de la correspondance est: réussi; Le contenu correspondant est: "￥ 20,5"; La position appariée est: commencer à 6 et se terminer à 10. Le contenu qui fait correspondre la plage de support séparément est: "20,5".

2. Quelques règles avancées dans les expressions régulières

2.1 Greate

Lorsque vous utilisez des symboles spéciaux qui modifient le nombre de correspondances, il existe plusieurs méthodes de représentation qui permettent à la même expression de correspondre à différents moments, tels que: "{m, n}", "{m,}", "?", "?", "*", "+". Le nombre spécifique de correspondances dépend de la chaîne correspondante. Cette expression avec un nombre incertain de correspondances répétées correspond toujours autant que possible pendant le processus de correspondance. Par exemple, pour le texte "dxxxdxxxd", ce qui suit est:

On peut voir que lorsque "/ w +" correspond, il correspond toujours à autant de personnages qui respectent ses règles que possible. Bien que dans le deuxième exemple, il ne correspond pas au dernier "D", il s'agit également de faire correspondre toute l'expression avec succès. De même, les expressions avec "*" et "{m, n}" correspondent autant que possible, et des expressions avec "?" sont également "appariés" autant que possible lorsqu'ils peuvent égaler ou décalé. Ce principe de correspondance est appelé le motif "cupidité".

Mode non incorrect:

Ajout d'un "?" Le signe après modification du symbole spécial du nombre de correspondances peut faire des expressions avec un nombre variable de matchs aussi peu possible, de sorte que les expressions qui peuvent correspondre ou l'inadéquation peuvent être "appariées" autant que possible. Ce principe de correspondance est appelé le modèle "non grisé", également appelé motif "Barb". S'il y a peu de correspondances, cela entraînera l'échec de l'expression entière. Semblable au mode gourmand, le mode non grincheux correspondra à la mesure minimale pour que l'expression entière correspond avec succès. Par exemple, pour le texte "dxxxdxxxd":

Pour plus de cas, veuillez vous référer à ce qui suit:

Exemple 1: Lorsque l'expression "<td> (. *) </td>" correspond à la chaîne "<td> <p> aa </p> </td> <td> <p> bb </p> </td>", le résultat correspondant est: succès; Le match est "<td> <p> aa </p> </td>" La chaîne entière, et le "</td>" dans l'expression correspondra au dernier "</td>" dans la chaîne.

Exemple 2: En revanche, lorsque l'expression "<td> (. *?) </td>" correspond à la même chaîne dans l'exemple 1, vous n'obtiendrez que "<td> <p> aa </p> </td>". Lorsque vous correspondez à nouveau à la suivante, vous obtiendrez le deuxième "<td> <p> bb </p> </td>".

2.2 Détalonnets / 1, / 2 ...

Lorsqu'une expression correspond, le moteur d'expression enregistre la chaîne correspondante par l'expression contenue dans le support "()". Lors de l'obtention du résultat correspondant, la chaîne correspondante par l'expression contenue dans les supports peut être obtenue séparément. Cela a été démontré à plusieurs reprises dans les exemples précédents. Dans les applications pratiques, lorsqu'une certaine limite est utilisée pour rechercher et que le contenu à récupérer ne contient pas de limites, les supports doivent être utilisés pour spécifier la plage souhaitée. Par exemple, le précédent "<td> (. *?) </td>".

En fait, "la chaîne correspondante par l'expression contenue entre parenthèses" peut non seulement être utilisée après la fin du match, mais aussi pendant le processus de correspondance. La partie après l'expression peut se référer à la "chaîne de sous-cost qui a été appariée" précédente "entre parenthèses. La méthode de référence consiste à ajouter un nombre "/". "/ 1" fait référence à la chaîne correspondante dans la première paire de supports "," / 2 "fait référence à la chaîne correspondante dans la deuxième paire de supports ... et ainsi de suite, si une paire de supports contient une autre paire de supports, les supports extérieurs sont triés en premier. En d'autres termes, si la paire a le support gauche "(" avant, la paire sera triée en premier.

Par exemple:

Exemple 1: L'expression "('|") (. *?) (/ 1) "Lors de la correspondance"' Hello ', "World" ", le résultat du match est: réussi; le contenu assorti est:"' Hello '". Lorsque vous correspondez à la suivante, vous pouvez égaler" "World" ".

Exemple 2: Lorsque l'expression "(/ w) / 1 {4,}" est appariée avec "AA BBBB ABCDEFG CCCCC 111121111 999999999999", le résultat du match est: réussi; Le contenu correspondant est "CCCCCC". Lorsque vous correspondez à nouveau à la suivante, vous obtiendrez 999999999. Cette expression nécessite des caractères dans la gamme "/ w" pour être répétés au moins 5 fois, en faisant attention à la différence par rapport à "/ w {5,}".

Exemple 3: L'expression "<(/ w +) / s * (/ w + (= ('|"). *? / 4)? / S *) *>. *? <// 1> "correspond" <td id =' td1 'style = "bgcolor: blanc"> </td> ". If" <td> réussi.

2.3 Pré-recherche, décalage; pré-recherche inversé, décalage

Dans le chapitre précédent, j'ai parlé de plusieurs symboles spéciaux représentant des significations abstraites: "^", "$", "/ b". Ils ont tous une chose en commun: ils ne correspondent eux-mêmes pas à aucun personnage, mais attachent uniquement une condition à "deux extrémités d'une chaîne" ou "fentes entre les caractères". Après avoir compris ce concept, cette section continuera d'introduire une autre méthode de représentation plus flexible qui ajoute des conditions à "deux extrémités" ou "fentes".

Avant la recherche: "(? = Xxxxx)", "(?! Xxxxx)"

Format: "(? = Xxxxx)", Dans la chaîne correspondante, la condition attachée au "fente" ou "deux extrémités" est que le côté droit de l'espace doit être capable de correspondre à l'expression de la pièce xxxxx. Parce que c'est juste une condition supplémentaire sur cet écart, cela n'affecte pas l'expression ultérieure pour vraiment correspondre aux personnages après cet écart. Ceci est similaire à "/ b", qui ne correspond à aucun personnage eux-mêmes. "/ B" prend les personnages avant et après l'écart et fait un jugement, et n'affectera pas les expressions derrière pour vraiment correspondre.

Exemple 1: Lorsque l'expression "Windows (? = Nt | xp)" est assortie à "Windows 98, Windows NT, Windows 2000", il ne correspondra qu'à "Windows" dans "Windows NT", et d'autres mots "Windows" ne sera pas assorti.

Exemple 2: Expression "(/ w) ((? = / 1/1/1) (/ 1)) +" Lors de la correspondance de la chaîne "AAA FFFFFF 999999999", il pourra correspondre aux 4 premiers de 6 "F" et les 7 premiers de 9 "9". Cette expression peut être lue et interprétée comme: répéter le nombre alphanumérique plus de 4 fois correspondra à la pièce avant les 2 derniers chiffres. Bien sûr, cette expression ne peut pas être écrite comme ceci, et le but ici est à des fins de démonstration.

Format: "(?! Xxxxx)", le côté droit de l'espace ne doit pas correspondre à l'expression xxxxx.

Exemple 3: Expression "((?! / Bstop / b).) +" Lors de la correspondance "fdjka ljfdl stop fjdsla fdj", il sera apparié du début à la position avant "Stop". S'il n'y a pas de "arrêt" dans la chaîne, la chaîne entière sera adaptée.

Exemple 4: L'expression "do (?! / W)" ne peut correspondre qu'à "faire" lors de la correspondance de la chaîne "terminée, do, chien". Dans cet article, l'effet de l'utilisation de "do" après "(?! / W)" Et de l'utilisation "/ b" est le même.

Pré-recherche inversée: "(? <= Xxxxx)", "(? <! Xxxxx)"

Les concepts de ces deux formats sont similaires à la pré-recherche directe. Les exigences de pré-recherche inverse sont: le "côté gauche" de l'espace. Les deux formats exigent qu'ils doivent être en mesure de correspondre et ne doivent pas pouvoir correspondre à l'expression spécifiée, plutôt que de juger le côté droit. Comme "avant-recherche": ils sont à la fois une condition supplémentaire à l'écart dans lequel ils sont situés et ne correspondent pas eux-mêmes à des personnages.

Exemple 5: L'expression "(? <= / D {4}) / d + (? = / D {4})" Lors de la correspondance "1234567890123456", les 8 nombres du milieu sauf les 4 premiers nombres et les 4 derniers nombres seront appariés. Étant donné que jscript.regexp ne prend pas en charge la pré-recherche inversée, cet article ne peut pas être démontré. De nombreux autres moteurs peuvent prendre en charge la pré-recherche inversée, tels que: java.util.regex au-dessus de Java 1.4, le système System.Text.RegulArExpressions dans .NET et le moteur régulier delx le plus simple et le plus facile recommandé par ce site.

3. Autres règles communes

Il existe également des règles qui sont plus courantes parmi les divers moteurs d'expression régulières, qui n'ont pas été mentionnées dans l'explication précédente.

3.1 Dans les expressions, "/ xxx" et "/ uxxxx" peut être utilisé pour représenter un caractère ("x" signifie un numéro hexadécimal)

3.2 Alors que les expressions "/ s", "/ d", "/ w", "/ b" représentent des significations spéciales, les lettres majuscules correspondantes représentent des significations opposées

3.3 Il y a une signification particulière dans l'expression, et il est nécessaire d'ajouter "/" pour faire correspondre le résumé des personnages du personnage lui-même.

3.4 sous-expression entre parenthèses "()". Si vous souhaitez que le résultat correspondant ne soit pas enregistré pour une utilisation future, vous pouvez utiliser le format "(?: xxxxx)"

Exemple 1: Lorsque l'expression "(?: (/ w) / 1) +" correspond "un BBCCDD EFG", le résultat est "BBCCDD". Le résultat correspondant du support "(? :)" La plage n'est pas enregistrée, donc "(/ w)" est utilisée pour le référencer.

3.5 Introduction aux paramètres d'attribut d'expression couramment utilisés: IgnoreCase, Singleline, Multiline, Global

4. Autres conseils

4.1 Si vous souhaitez comprendre que les moteurs réguliers avancés prennent également en charge la syntaxe régulière complexe, veuillez vous référer à la documentation du moteur régulier Deelx sur ce site.

4.2 Si vous souhaitez exiger que l'expression corresponde à la chaîne entière, au lieu de trouver une pièce de la chaîne, vous pouvez utiliser "^" et "$" au début et à la fin de l'expression, par exemple: "^ / d + $" exige que la chaîne entière ait uniquement des nombres.

4.3 Si le contenu requis pour correspondre est un mot complet et ne fait pas partie du mot, utilisez "/ b" au début et à la fin de l'expression, par exemple: utilisez "/b(if| while|ElSedseVoid|int...)/B" pour faire correspondre les mots clés dans le programme.

4.4 L'expression ne correspond pas à une chaîne vide. Sinon, le match réussira tout le temps, et rien ne sera égalé. Par exemple: lorsque vous vous préparez à écrire une expression qui correspond à "123", "123.", "123.5", ".5", etc., les entiers, les points décimaux et les nombres décimaux peuvent être omis, mais n'écrivez pas l'expression comme: "/d*/.?/d*", car s'il n'y a rien, cette expression ne peut également correspondre plus à plus. Une meilleure façon de l'écrire est: "/d+/.?/d*|/./d+".

4.5 Ne boucle pas à l'infini pour les sous-matchs qui peuvent correspondre aux chaînes vides. Si chaque partie de la sous-expression entre les supports peut correspondre 0 fois et que les supports dans leur ensemble peuvent correspondre aux temps infinis, la situation peut être plus grave que ce que l'article précédent a dit, et que le processus de correspondance peut être une boucle morte. Bien que certains moteurs d'expression réguliers aient maintenant évité la boucle morte dans cette situation, telles que les expressions régulières .NET, nous devrions toujours essayer d'éviter cette situation. Si nous rencontrons une boucle morte lors de la rédaction d'expressions, nous pouvons également commencer à ce point de vue et savoir si c'est la raison mentionnée dans cet article.

4.6 Choisissez raisonnablement le mode gourmand et le mode non incontournable, voir la discussion sur le sujet.

4.7 ou "|" Sur les côtés gauche et droit, il est préférable de correspondre à un seul côté d'un certain caractère, afin que les expressions des deux côtés de "|" ne diffère pas en raison de la position d'échange.

Article suivant ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1. Définir les expressions régulières

1) Il existe deux formes de définition d'expressions régulières, l'une est la méthode ordinaire et l'autre est la méthode du constructeur.

2) Méthode normale: var reg = / expression / paramètres supplémentaires

Expression: une chaîne représentant une certaine règle, où certains caractères spéciaux peuvent être utilisés pour représenter des règles spéciales, qui seront expliquées en détail plus tard.

Paramètres supplémentaires: utilisés pour étendre la signification de l'expression, il existe actuellement trois paramètres principaux:

G: signifie que l'appariement global peut être effectué.

I: Cela signifie une correspondance insensible au cas.

M: signifie que la correspondance de plusieurs lignes peut être effectuée.

Les trois paramètres ci-dessus peuvent être combinés arbitrairement pour représenter la signification composée, et bien sûr, aucun paramètre n'est ajouté.

exemple:

var reg = / a * b /;

var reg = / abc + f / g;

3) Méthode du constructeur: var reg = new regexp ("expression", "ajouter des paramètres");

La signification de "Expression" et "Paramètres supplémentaires" est la même que la méthode de définition ci-dessus.

exemple:

var reg = new regexp ("a * b");

var reg = new regexp ("abc + f", "g");

4) la différence entre les méthodes ordinaires et les méthodes du constructeur

Une expression de la manière normale doit être une chaîne constante, tandis que l'expression dans le constructeur peut être une chaîne constante ou une variable JS, comme un paramètre d'expression basé sur l'entrée de l'utilisateur, etc.:

var reg = new regexp (document.forms [0] .exprfiled.value, "g");

2. Modèle d'expression

1) Le modèle d'expression fait référence à la méthode d'expression et au style de l'expression, c'est-à-dire comment décrire «l'expression» dans var reg = / expression / paramètres supplémentaires?

2) Dans une perspective standardisée, les modèles d'expression sont divisés en modèles simples et modèles composites.

3) modèle simple: fait référence à un modèle exprimé par la combinaison de caractères ordinaires, par exemple

var reg = / abc0d /;

On peut voir que les modèles simples ne peuvent représenter que des correspondances spécifiques.

4) Modèle composé: fait référence à un modèle exprimé avec des caractères génériques, par exemple:

var reg = / a + b? / w /;

Le + ,? et / w sont tous des personnages génériques et représentent des significations spéciales. Par conséquent, le modèle composite peut exprimer une logique plus abstraite.

Concentrons-nous sur la signification et l'utilisation de chaque joker en mode composite.

5) Explication des caractères spéciaux en mode composé:

1> /: Il est utilisé comme caractère d'échappement dans de nombreux langages de programmation. En général

Si le / symbole est suivi du caractère ordinaire C, alors / c représente une signification particulière. Par exemple, N représente à l'origine le caractère n, mais / n représente une nouvelle ligne.

Si le / le symbole est suivi d'un caractère spécial c, alors / c représente le caractère ordinaire c. Par exemple, / est généralement utilisé comme caractère d'évasion, mais // est utilisé pour régler le caractère ordinaire /.

L'utilisation de / dans l'expression régulière de JavaScript est la même que celle ci-dessus, mais dans différents langages de programmation, les tables de caractères spéciales peuvent être différentes.

2> ^: Faites correspondre le début de la chaîne d'entrée. S'il s'agit d'une correspondance multi-lignes, c'est-à-dire que les paramètres supplémentaires de l'expression contiennent M, il sera également apparié après une nouvelle ligne.

exemple:

/ ^ B / faire correspondre le premier B dans "Bab BC"

Exemple 2:

/ ^ B / gm correspondant

«Badd B

CDAF

B dsfb ”

La première ligne du premier B, le premier B de la troisième ligne

3> $: Faites correspondre la fin de la création de caractères d'entrée. S'il s'agit d'une correspondance multi-lignes, c'est-à-dire que les paramètres supplémentaires de l'expression contiennent M, il sera également apparié avant une nouvelle ligne.

Contrairement à l'utilisation de ^.

Exemple: / t $ / matchs t dans "bat", mais ne correspond pas à "haine"

Exemple 2: / t $ / match

«Tag à

batte"

Le dernier T de la première ligne et le T de la deuxième ligne.

4> *: Faites correspondre le caractère précédent 0 ou plus.

Exemple: / ab * / correspond à "abbbb" dans "dddabbbbc", et correspond également à "un" dans "ddda"

5> +: Faites correspondre le caractère précédent 1 ou plus.

Exemple: / ab + / correspond à "abbbb" dans "dddabbbbc", mais ne correspond pas à "ddda"

Semblable à l'utilisation des {1,} (prototype: {n,})

6> ?: L'utilisation de? est assez spécial. D'une manière générale, il est utilisé pour correspondre au caractère précédent 0 fois ou 1 fois, mais il a deux autres utilisations spéciales:

Si cela a immédiatement suivi *, + ,? et {}, cela signifie le nombre minimum de correspondances de la correspondance d'origine, par exemple:

/ ba * / à l'origine "Baaaa" dans "bbbaaaa", mais / ba *? / correspondant "b" dans "bbbaaaa" (parce que * signifie 0 ou plus de correspondances, tandis que plus? devrait signifier le nombre minimum de matchs, c'est-à-dire 0 matchs).

De même: / ba +? / Correspond à "ba" dans "baaaa".

En tant que symbole de structure de syntaxe, il est utilisé en pré-assertique, c'est-à-dire x (? = Y) et x (?! = Y) à mentionner plus tard.

7>.: Le "." Connecter le point décimal correspond à n'importe quel caractère unique, à l'exception du caractère Newline.

Quels sont les personnages de la norme au total? Veuillez vous référer à: Ensemble de caractères

Par exemple: / AB / correspond à "ACB" dans "ACBAA", mais ne correspond pas à "ABBB".

8> (x): signifie correspondre x (ne pas spécifiquement se référer au caractère x ou se référant spécifiquement à un caractère, x représente une chaîne), et le match restera dans les mémoires. En syntaxe, ce type de () est appelé "capturer les parents", c'est-à-dire les supports utilisés pour la capture.

Les correspondances sont rappelées car dans les fonctions fournies par l'expression, certaines fonctions renvoient un tableau qui contient toutes les chaînes de correspondance, telles que la fonction exec ().

Notez également que la prémisse dont X in () est rappelée est de correspondre à x.

Exemple 1:

var regx = / a (b) c /;

var rs = regx.exec ("ABCDDD");

Comme on peut le voir à partir de ce qui précède, / a (b) c / correspond "ABC" dans "ABCDDD". En raison de (), B l'enregistrera également, donc le contenu numéro renvoyé par RS est:

{ABC, b}

Exemple 2:

var regx = / a (b) c /;

var rs = regx.exec ("acbcddd");

RS renvoie null, car / a (b) c / ne correspond pas à "acbcddd", donc b dans () ne sera pas enregistré (bien que la chaîne contient b)

9> (?: x): Faites correspondre x, mais ne vous souvenez pas x. () Dans ce format, est appelé "parents non capturés", c'est-à-dire des supports pour la non-capture.

exemple:

var regx = / a (?: b) c /;

var rs = regx.exec ("ABCDDD");

Comme on peut le voir à partir de ce qui précède, / a (?: b) C / correspond "ABC" dans "ABCDDD", en raison de (? :), B ne sera pas enregistré, donc le contenu numéro renvoyé par RS est:

{abc}

10> x (? = Y): Faites correspondre x, seulement si y est suivi immédiatement. Si le match correspond, seuls X restera dans les mémoires et que vous ne se souviendra pas.

exemple:

var regx = / user (? = name) /;

var rs = regx.exec ("le nom d'utilisateur est Mary");

Résultat: la correspondance est réussie et la valeur de RS est {utilisateur}

11> x (?! Y): Faites correspondre x, seulement si y n'est pas suivi immédiatement. Si le match correspond, seuls X restera dans les mémoires et que vous ne se souviendra pas.

exemple:

var regx = / user (?! name) /;

var rs = regx.exec ("Le nom d'utilisateur est Mary");

Résultat: la correspondance est réussie et la valeur de RS est {utilisateur}

Exemple 2:

var regx = // d + (?! /.) /;

var rs = regx.exec ("54.235");

Result: The matching result, the value of rs is {5}, and the mismatch is because 54 is followed by the "." signe. Of course, 235 also matches, but due to the behavior of the exec method, 235 will not be returned.

12>x|y：匹配x或y。注意如果x和y都匹配上了，那么只记住x。

exemple:

var regx=/beijing|shanghai/;

var rs=regx.exec(“I love beijing and shanghai”);

结果：匹配成功，rs的值为{beijing}，虽然shanghai也匹配，但不会被记住。

13>{n}：匹配前一个字符的n次出现。

n必须是一个非负数，当然如果是一个负数或小数也不会报语法错误。

exemple:

var regx=/ab{2}c/;

var rs=regx.exec(“abbcd”);

结果：匹配成功，rs的值为：{abbc}。

14>{n,}：匹配前一个字符的至少n次出现。

exemple:

var regx=/ab{2,}c/;

var rs=regx.exec(“abbcdabbbc”);

结果：匹配成功，rs的值为：{abbc}。注意为什么abbbc也符合条件为什么没有被记住，这与exec方法的行为有关，后面会统一讲解。

15>{n,m}：匹配前一个字符的至少n次最多m次的出现。

只要n与m为数字，而且m>=n就不会报语法错误。

exemple:

var regx=/ab{2,5}c/;

var rs=regx.exec(“abbbcd”);

结果：匹配成功，rs的值为：{abbbc}。

Exemple 2:

var regx=/ab{2,2}c/;

var rs=regx.exec(“abbcd”);

结果：匹配成功，rs的值为：{abbc}。

例子3：

var regx=/ab(2,5)/;

var rs=regx.exec(“abbbbbbbbbb”);

Result: The match is successful, and the value of rs is: {abbbbb}, which means that if the previous character appears more than m times, it will only match m times. en outre:

var regx=/ab(2,5)c/;

var rs=regx.exec(“abbbbbbbbbbc”);

结果：匹配失败，rs的值为：null，为什么匹配失败，因为b多于5个则b(2,5)会匹配前5个b，，而表达式/ab(2,5)c/中b后面是c，但字符串中5个b之后还是b所以会报错。

16>[xyz]：xyz表示一个字符串，该模式表示匹配[]中的一个字符，形式上[xyz]等同于[xz]。

exemple:

var regx=/a[bc]d/;

var rs=regx.exec(“abddgg”);

结果：匹配成功，rs的值为：{abd}

Exemple 2:

var regx=/a[bc]d/;

var rs=regx.exec(“abcd”);

结果：匹配失败，rs的值为：null，之所以失败，是因为[bc]表示匹配b或c中的一个，但不会同时匹配。

17>[^xyz]：该模式表示匹配非[]中的一个字符，形式上[^xyz]等同于[^xz]。

exemple:

var regx=/a[^bc]d/;

var rs=regx.exec(“afddgg”);

结果：匹配成功，rs的值为：{afd}

Exemple 2:

var regx=/a[^bc]d/;

var rs=regx.exec(“abd”);

结果：匹配失败，rs的值为：。

18>[/b]：匹配退格键。

19>/b：匹配一个词的边界符，例如空格和换行符等等，当然匹配换行符时，表达式应该附加参数m。

exemple:

var regx=//bc./;

var rs=regx.exec(“Beijing is a beautiful city”);

结果：匹配成功，rs的值为：{ci}，注意c前边的空格不会匹配到结果中，即{ ci}是不正确的。

20>/B：代表一个非单词边界。

exemple:

var regx=//Bi./;

var rs=regx.exec(“Beijing is a beautiful city”);

结果：匹配成功，rs的值为：{ij}，即匹配了Beijing中的ij。

21>/cX，匹配一个控制字符。例如， /cM 匹配一个Control-M 或

回车符。 x 的值必须为AZ 或az 之一。否则，将c 视为一

个原义的'c' 字符。（实际的例子还需补充）

21>/d：匹配一个数字字符，等同于[0-9]。

exemple:

var regx=/user/d/;

var rs=regx.exec(“user1”);

结果：匹配成功，rs的值为：{user1}

22>/D：匹配一个非数字字符，等同于[^0-9]。

exemple:

var regx=/user/D/;

var rs=regx.exec(“userA”);

结果：匹配成功，rs的值为：{userA}

23>/f：匹配一个换页符。

24>/n：匹配一个换行符。因为是换行符，所以在表达式中要加入m参数。

exemple:

var regx=/a/nbc/m;

var str=“a

bc”;

var rs=regx.exec(str);

结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。

25>/r：匹配一个回车符

26>/s：匹配一个空格符，等同于[ /f/n/r/t/v/u00A0/u2028/u2029].

exemple:

var regx=//si/;

var rs=regx.exec(“Beijing is a city”);

结果：匹配成功，rs的值为：{ i}

27>/S：匹配一个非空格符，等同于[ ^/f/n/r/t/v/u00A0/u2028/u2029].

exemple:

var regx=//Si/;

var rs=regx.exec(“Beijing is a city”);

结果：匹配成功，rs的值为：{ei}

28>/t：匹配一个tab

exemple:

var regx=/a/tb/;

var rs=regx.exec(“a bc”);

结果：匹配成功，rs的值为： {a bc}

29>/v：匹配一个竖向的tab

30>/w：匹配一个数字、_或字母表字符，即[A-Za-z0-9_ ]。

exemple:

var regx=//w/;

var rs=regx.exec(“$25.23”);

结果：匹配成功，rs的值为：{2}

31>/W：匹配一个非数字、_或字母表字符，即[^A-Za-z0-9_ ]。

exemple:

var regx=//w/;

var rs=regx.exec(“$25.23”);

结果：匹配成功，rs的值为：{$}

32>/n：注意不是/n，这里n是一个正整数，表示匹配第n个()中的字符。

exemple:

var regx=/user([,-])group/1role/;

var rs=regx.exec(“user-group-role”);

结果：匹配成功，rs的值为：{user-group-role,-}，同样对user,group,role的匹配也是成功的，但像user-group,role等就不对了。

33>/0：匹配一个NUL字符。

34>/xhh：匹配一个由两位16进制数字所表达的字符。

35>/uhhhh：匹配一个由四位16进制数字所表达的字符。

3，表达式操作

1）表达式操作，在这里是指和表达式相关的方法，我们将介绍六个方法。

2）表达式对象（RegExp）方法：

1>exec(str)，返回str中与表达式相匹配的第一个字符串，而且以数组的形式表现，当然如果表达式中含有捕捉用的小括号，则返回的数组中也可能含有()中的匹配字符串，例如：

var regx=//d+/;

var rs=regx.exec(“3432ddf53”);

返回的rs值为：{3432}

var regx2=new RegExp(“ab(/d+)c”);

var rs2=regx2.exec(“ab234c44”);

返回的rs值为：{ab234c,234}

In addition, if there are multiple suitable matches, exec is executed for the first time and exec is continued, the second and third matches are returned in turn. Par exemple:

var regx=/user/d/g;

var rs=regx.exec(“ddduser1dsfuser2dd”);

var rs1=regx.exec(“ddduser1dsfuser2dd”);

则rs的值为{user1}，rs的值为{rs2}，当然注意regx中的g参数是必须的，否则无论exec执行多少次，都返回第一个匹配。后面还有相关内容涉及到对此想象的解释。

2>test(str), determines whether the string str matches the expression, and returns a boolean value. Par exemple:

var regx=/user/d+/g;

var flag=regx.test(“user12dd”);

flag的值为true。

3）String对象方法

1>match(expr)，返回与expr相匹配的一个字符串数组，如果没有加参数g，则返回第一个匹配，加入参数g则返回所有的匹配

exemple:

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.match(regx);

rs的值为：{user1,user3}

2>search(expr)，返回字符串中与expr相匹配的第一个匹配的index值。

exemple:

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.search(regx);

rs的值为：0

3>replace(expr,str)，将字符串中匹配expr的部分替换为str。另外在replace方法中，str中可以含有一种变量符号$，格式为$n，代表匹配中被记住的第n的匹配字符串（注意小括号可以记忆匹配）。

exemple:

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.replace(regx,”00”);

rs的值为：003userddd0045

Exemple 2:

var regx=/u(se)r/d/g;

var str=“user13userddduser345”;

var rs=str.replace(regx,”$1”);

rs的值为：se3userdddse45

对于replace(expr,str)方法还要特别注意一点，如果expr是一个表达式对象则会进行全局替换（此时表达式必须附加参数g，否则也只是替换第一个匹配），如果expr是一个字符串对象，则只会替换第一个匹配的部分，例如：

var regx=“user”

var str=“user13userddduser345”;

var rs=str.replace(regx,”00”);

rs的值为： 0013userddduser345

4>split(expr)，将字符串以匹配expr的部分做分割，返回一个数组，而且表达式是否附加参数g都没有关系，结果是一样的。

exemple:

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.split(regx);

rs的值为：{3userddd,45}

4，表达式相关属性

1）表达式相关属性，是指和表达式相关的属性，如下面的形式：

var regx=/myexpr/;

var rs=regx.exec(str);

其中，和表达式自身regx相关的属性有两个，和表达式匹配结果rs相关的属性有三个，下面将逐一介绍。

2）和表达式自身相关的两个属性：

1>lastIndex，返回开始下一个匹配的位置，注意必须是全局匹配（表达式中带有g参数）时，lastIndex才会有不断返回下一个匹配值，否则该值为总是返回第一个下一个匹配位置，例如：

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var lastIndex1=regx.lastIndex;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var lastIndex2=regx.lastIndex;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var lastIndex3=regx.lastIndex;

上面lastIndex1为9，第二个lastIndex2也为9，第三个也是9；如果regx=/user/d/g，则第一个为9，第二个为18，第三个为0。

2>source, return the expression string itself. Par exemple:

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var source=regx.source;

source的值为user/d

3）和匹配结果相关的三个属性：

1>index, return the current matching position. Par exemple:

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var index1=rs.index;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var index2=rs.index;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var index3=rs.index;

index1为4，index2为4，index3为4，如果表达式加入参数g，则index1为4，index2为13，index3会报错（index为空或不是对象）。

2>input, used for matching strings. Par exemple:

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var input=rs.input;

input的值为sdsfuser1dfsfuser2。

3>[0]，返回匹配结果中的第一个匹配值，对于match而言可能返回一个多值的数字，则除了[0]外，还可以取[1]、[2]等等。例如：

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var value1=rs[0];

rs=regx.exec(“sdsfuser1dfsfuser2”);

var value2=rs[0];

value1的值为user1,value2的值为user2

5，实际应用

1）实际应用一

描述：有一表单，其中有一个“用户名”input域

要求：汉字，而且不能少于2个汉字，不能多于4个汉字。

accomplir:

 <script>function checkForm(obj){ var username=obj.username.value; var regx=/^[/u4e00-/u9fa5]{2,4}$/g if(!regx.test(username)){ alert("Invalid username!"); retourne false; } return true;}</script><form name="myForm" onSubmit="return checkForm(this)"> <input type="text" name="username"/> <input type="submit" vlaue="submit"/>

2）实际应用二

描述：给定一个含有html标记的字符串，要求将其中的html标记去掉。

accomplir:

 <script>function toPlainText(htmlStr){ var regx=/<[^>]*>|<//[^>]*>/gm; var str=htmlStr.replace(regx,""); return str;}</script><form name=“myForm”> <textarea id=“htmlInput”></textarea> <input type=“button” value=“submit” onclick=“toPlainText(document.getElementById('htmlInput').value”/></form>

三，小结

1，Javascript正则表达式，我想在一般的程序员之中，使用者应该不是很多，因为我们处理的页面一般都不是很复杂，而复杂的逻辑一般我们都在后台处理完成了。但是目前趋势已经出现了扭转，富客户端已经被越来越多的人接受，而Javascript就是其中的关键技术，对于复杂的客户端逻辑而言，正则表达式的作用也是很关键的，同时它也是Javascript高手必须要掌握的重要技术之一。

2，为了能够便于大家对前面讲述的内容有一个更为综合和深刻的认识，我将前面的一些关键点和容易犯糊涂的地方再系统总结一下，这部分很关键！

总结1：附件参数g的用法

表达式加上参数g之后，表明可以进行全局匹配，注意这里“可以”的含义。我们详细叙述：

1) For the exec method of the expression object, if g is not added, it will only return the first match, no matter how many times it is executed, if g is added, the first execution will also return the first match, and then the execution will return the second match, and so on. Par exemple

var regx=/user/d/;

var str=“user18dsdfuser2dsfsd”;

var rs=regx.exec(str);//此时rs的值为{user1}

var rs2=regx.exec(str);//此时rs的值依然为{user1}

如果regx=/user/d/g；则rs的值为{user1}，rs2的值为{user2}

通过这个例子说明：对于exec方法，表达式加入了g，并不是说执行exec方法就可以返回所有的匹配，而是说加入了g之后，我可以通过某种方式得到所有的匹配，这里的“方式”对于exec而言，就是依次执行这个方法即可。

2）对于表达式对象的test方法，加入g于不加上g没有什么区别。

3) For the match method of the String object, g is not added, and it only returns the first match. If the match method is executed all the time, it always returns the first match. If g is added, then all matches will be returned at once (note that this is different from the exec method of the expression object. For exec, even if g is added, all matches will not be returned at once). Par exemple:

var regx=/user/d/;

var str=“user1sdfsffuser2dfsdf”;

var rs=str.match(regx);//此时rs的值为{user1}

var rs2=str.match(regx);//此时rs的值依然为{user1}

如果regx=/user/d/g，则rs的值为{user1,user2}，rs2的值也为{user1,user2}

4）对于String对象的replace方法，表达式不加入g，则只替换第一个匹配，如果加入g，则替换所有匹配。（开头的三道测试题能很好的说明这一点）

5）对于String对象的split方法，加上g与不加g是一样的，即：

var sep=/user/d/;

var array=“user1dfsfuser2dfsf”.split(sep);

则array的值为{dfsf, dfsf}

此时sep=/user/d/g，返回值是一样的。

6）对于String对象的search方法，加不加g也是一样的。

总结2：附加参数m的用法

附加参数m，表明可以进行多行匹配，但是这个只有当使用^和$模式时才会起作用，在其他的模式中，加不加入m都可以进行多行匹配（其实说多行的字符串也是一个普通字符串），我们举例说明这一点

1）使用^的例子

var regx=/^b./g;var str=“bd76 dfsdf sdfsdfs dffs b76dsf sdfsdf”;var rs=str.match(regx);

此时加入g和不加入g，都只返回第一个匹配{bd}，如果regx=/^b./gm，则返回所有的匹配{bd,b7}，注意如果regx=/^b./m，则也只返回第一个匹配。所以，加入m表明可以进行多行匹配，加入g表明可以进行全局匹配，综合到一起就是可以进行多行全局匹配

2）使用其他模式的例子，例如

var regx=/user/d/;var str=“sdfsfsdfsdf sdfsuser3 dffs b76dsf user6”;var rs=str.match(regx);

此时不加参数g，则返回{user3}，加入参数g返回{user3,user6}，加不加入m对此没有影响。

3）因此对于m我们要清楚它的使用，记住它只对^和$模式起作用，在这两种模式中，m的作用为：如果不加入m，则只能在第一行进行匹配，如果加入m则可以在所有的行进行匹配。我们再看一个^的例子

var regx=/^b./;var str=“ret76 dfsdf bjfsdfs dffs b76dsf sdfsdf”;var rs=str.match(regx);

此时rs的值为null，如果加入g，rs的值仍然为null，如果加入m，则rs的值为{bj}（也就是说，在第一行没有找到匹配，因为有参数m，所以可以继续去下面的行去找是否有匹配），如果m和g都加上，则返回{bj,b7}（只加m不加g说明，可以去多行进行匹配，但是找到一个匹配后就返回，加入g表明将多行中所有的匹配返回，当然对于match方法是如此，对于exec呢，则需要执行多次才能依次返回）

总结3：

在HTML的textarea输入域中，按一个Enter键，对应的控制字符为“/r/n”，即“回车换行”，而不是“/n/r”，即“换行回车”，我们看一个前面我们举过的例子：

 var regx=/a/r/nbc/;var str=“a bc”;var rs=regx.exec(str);

结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。

The above article briefly discusses the use of RegExp objects and brackets for JS regular expressions is all the content I share with you. J'espère que cela pourra vous donner une référence et j'espère que vous pourrez soutenir Wulin.com plus.