Ce qui suit est une brève discussion sur l'utilisation des objets RegExp et des crochets dans les expressions régulières JS. Le contenu est assez bon, je vais donc le partager avec vous maintenant et le donner comme référence.
Création d'un objet RegExp :
Des expressions régulières conventionnelles peuvent être créées avec des quantités directes, c'est-à-dire des caractères entourés de barres obliques "/" . Mais dans les environnements qui nécessitent des changements de paramètres, 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, faites attention, car ce n'est pas le cas. une représentation directe. Il n'est donc pas nécessaire de l'entourer de barres obliques "/" ; les guillemets " ' " et le symbole d'échappement " " doivent être échappés deux fois dans la chaîne.
De plus, qu'il s'agisse d'une variable directe ou du constructeur RegExp(), un nouvel objet RegExp est généré et affecté à une variable.
Similarités et différences entre match() et exec() :
Match et exec sont des méthodes courantes pour faire correspondre des chaînes avec des expressions régulières. Les fonctions implémentées par les deux sont similaires, avec quelques différences subtiles :
1. Utilisation
match est une méthode d'emballage de chaînes d'objets, utilisation : String.match(RegExp);
exec est une méthode d'objet d'expression régulière, utilisation : RegExp.exec(String);
Résultat renvoyé
2. 🎜>
Lorsque RegExp ne définit pas le drapeau global "g": Les résultats de retour des deux sont les mêmes. Autrement dit, null est renvoyé lorsqu'il n'y a pas de valeur correspondante et un tableau (let array) est renvoyé lorsqu'il y a une valeur correspondante. array[0] est la chaîne correspondante, array[1], array[2]... correspondent aux sous-chaînes $1, $2... mises en correspondance par parenthèses dans l'expression régulière. En même temps, le tableau a deux attributs, array.index représente la position initiale de la chaîne correspondante et array.input représente la chaîne en cours de récupération. Lorsque RegExp a l'indicateur global "g" défini :
match renvoie un tableau s'il y a une valeur. Chaque élément du tableau représente tour à tour toutes les chaînes correspondantes, il n'y a donc plus de sous-chaînes correspondant par parenthèses. À l'heure actuelle, le tableau n'a pas d'attribut d'index ni d'attribut d'entrée.
exec se comporte de la même manière que sans le drapeau global "g". Ce qui est renvoyé à ce moment est un tableau tableau, array[0] est la chaîne actuellement correspondante, array[1], array[2]... sont les chaînes correspondant aux parenthèses sous la correspondance actuelle. À ce stade, vous devez faire attention à l'attribut lastIndex de l'objet RegExp, qui représente la position après la fin de la chaîne correspondante dans la chaîne d'origine. Lorsqu’il n’y a aucun autre résultat correspondant, l’attribut lastIndex est défini sur 0. Par conséquent, vous pouvez utiliser la boucle lastIndex pour rechercher toutes les chaînes correspondantes.
Prend en charge plusieurs méthodes de correspondance :
code js
var testStr = "now 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 dans ce cas il n'y a pas d'option g, et vous ne pouvez obtenir que le premier match.
1. Règles d'expression régulière
1.1 Caractères ordinaires
Les lettres, chiffres, caractères chinois, traits de soulignement et signes de ponctuation non spécifiquement définis dans les chapitres suivants sont tous des « caractères ordinaires ». Les caractères ordinaires dans une expression, lorsqu'ils correspondent à une chaîne, correspondent au même caractère. Exemple 1 : Lorsque l'expression « c » correspond à la chaîne « abcde », le résultat correspondant est : succès ; le contenu correspondant est : « c » la position correspondante est : commençant à 2, terminé à 3 ; . (Remarque : Le fait que l'indice commence à 0 ou à 1 peut différer selon le langage de programmation actuel)
Exemple 2 : L'expression "bcd", lors de la correspondance avec la chaîne "abcde", le résultat de la correspondance est : Succès ; le contenu correspondant est : "bcd" ; la position correspondante est : commençant à 1 et se terminant à 4.
1.2 Caractères d'échappement simples
表达式 | 可匹配 |
/r, /n | 代表回车和换行符 |
/t | 制表符 |
// | 代表 "/" 本身 |
Expression<🎜> | Peut correspondre<🎜> |
/r, / n<🎜> | Représente les caractères de retour chariot et de saut de ligne<🎜> |
/t<🎜> | Tab<🎜> |
//<🎜> | Représente "/" lui-même<🎜> | < /tr>
Il existe d'autres signes de ponctuation qui ont des utilisations spéciales dans les chapitres suivants. L'ajout de "/" devant eux représente le symbole lui-même. Par exemple : ^ et $ ont des significations spéciales. Si vous souhaitez faire correspondre les caractères "^" et "$" dans la chaîne, l'expression doit être écrite sous la forme "/^" et "/$".
| peut correspondre | ||||||||||
| /^ | Correspond au symbole ^ lui-même | ||||||||||
| /$ | Correspond au symbole $ lui-même
| ||||||||||
/ . | Faire correspondre le point décimal (.) lui-même |
La méthode de correspondance de ces échappés. les caractères sont les mêmes que les « caractères ordinaires » sont similaires. Correspond également au même personnage. Exemple 1 : Lorsque l'expression "/$d" correspond à la chaîne "abc$de", le résultat correspondant est : succès ; le contenu correspondant est : "$d" la position correspondante est : Commence à 3 et se termine à 5 heures.
1.3 Expressions pouvant correspondre à « plusieurs caractères »表达式 | 可匹配 |
[ab5@] | 匹配 "a" 或 "b" 或 "5" 或 "@" |
[^abc] | 匹配 "a","b","c" 之外的任意一个字符 |
[f-k] | 匹配 "f"~"k" 之间的任意一个字母 |
[^A-F0-3] | 匹配 "A"~"F","0"~"3" 之外的任意一个字符 |
| <🎜>L'expression<🎜> | <🎜> peut correspondre < 🎜> |
| <🎜>/d<🎜> | <🎜>N'importe quel numéro, n'importe lequel de 0 à 9<🎜>< /td> |
| <🎜>/w<🎜> | <🎜>Toute lettre, chiffre ou trait de soulignement, c'est-à-dire A~Z,a~z,0 L'un des ~9,_<🎜> |
| <🎜>/s<🎜> | <🎜> comprend des espaces, des tabulations et des caractères de remplacement L'un des les caractères d'espacement tels que les sauts de page <🎜> |
| <🎜>.<🎜> | <🎜>Le point décimal peut correspondre sauf le caractère de nouvelle ligne ( /n) Tout caractère autre que <🎜> |
| <🎜>L'expression<🎜> | <🎜> peut correspondre < 🎜> |
| <🎜>[ab5@]<🎜> | <🎜>Match "a" ou "b" ou "5" ou " @"<🎜> |
| <🎜>[^abc]<🎜> | <🎜>Match "a", "b", "Tout" caractère autre que c" <🎜> |
| <🎜>[f-k]<🎜> | <🎜> correspond à "f"~" k" correspond toute lettre entre <🎜> |
| <🎜>[^A-F0-3]<🎜> | <🎜> Tout caractère autre que "A "~"F","0"~"3"<🎜> |
Exemple 1 : lorsque l'expression "[bcd][bcd]" correspond à "abc123", le résultat correspondant est : succès ; le contenu correspondant est : "bc" ; la position correspondante est : commençant à 1 et se terminant à 3. .
Exemple 2 : lorsque l'expression "[^abc]" correspond à "abc123", le résultat de la correspondance est : succès ; le contenu correspondant est : "1" ; la position correspondante est : commençant à 3, terminé à 4.
1.5 Symboles spéciaux qui modifient le nombre de correspondances
Les expressions mentionnées dans les chapitres précédents, qu'elles ne puissent correspondre qu'à un seul type de caractère, ou qu'elles puissent correspondre à plusieurs Une expression contenant l’un de ces caractères ne peut être trouvée qu’une seule fois. Si vous utilisez une expression plus un symbole spécial qui modifie le nombre de correspondances, vous pouvez effectuer des correspondances répétées sans réécrire l'expression.
La méthode d'utilisation est la suivante : mettre le "nombre de modifications" après "l'expression modifiée". Par exemple : "[bcd][bcd]" peut être écrit sous la forme "[bcd]{2}".
| Fonction | ||||||||||||||
| {n} | L'expression est répétée n fois, par exemple : "/w{2} " Équivalent à "/w/w" ; "a{5}" équivaut à "aaaaa" | ||||||||||||||
| {m,n}
| L'expression est répétée au moins m fois et au plus n fois. Par exemple : "ba{1,3}" peut correspondre à "ba" ou "baa" ou "baaa"<🎜. > | ||||||||||||||
| <🎜>L'expression est répétée au moins m fois, par exemple : "/w /d{2,}" peut correspondre à "a12", "_456", "M12344"...<🎜> | ||||||||||||||
| <🎜> ?<🎜> | <🎜>match L'expression est 0 ou 1 fois, équivalente à {0,1}, par exemple : "a[cd]?" peut correspondre à "a", "ac", "ad"<🎜> | <🎜>+<🎜> | <🎜>L'expression apparaît au moins une fois, équivalente à {1,}, par exemple : "a +b" peut correspondre à "ab", "aab", "aaab"...<🎜> | ||||||||||||
| <🎜>*<🎜> | <🎜>L'expression n'apparaît pas ou apparaît plusieurs fois de manière aléatoire, équivalent à {0,}, par exemple : "/^*b" peut correspondre à "b", "^^^b"...<🎜> |
| <🎜>Expression<🎜> | <🎜>Fonction<🎜> | < tr><🎜>^<🎜> | <🎜> correspond au début de la chaîne et ne correspond à aucun caractère <🎜> | ||||||||||||||||||||
| <🎜>$ <🎜> | <🎜> correspond à la fin de la chaîne et ne correspond à aucun caractère <🎜> | ||||||||||||||||||||||
| <🎜> /b<🎜> | <🎜>correspond à une limite de mot, c'est-à-dire la position entre un mot et un espace, et ne correspond à aucun caractère<🎜> |
| Fonction | ||||||
| | | La relation "OU" entre les expressions gauche et droite, correspondant au côté gauche ou droit | ||||||
| ( ) | (1) Lorsque le nombre de correspondances est modifié, l'expression entre parenthèses peut être modifiée dans son ensemble . (2). Lors de la récupération du résultat correspondant, le contenu correspondant à l'expression entre parenthèses peut être obtenu individuellement |
Exemple 5 : Expression lorsque " Tom|Jack" correspond à la chaîne "Je m'appelle Tom, il est Jack", le résultat correspondant est : succès ; le contenu correspondant est : "Tom" ; la position correspondante est : commençant à 4 et se terminant à 7 . Lors de la correspondance avec le suivant, le résultat de la correspondance est : succès ; le contenu correspondant est : « Jack » la position correspondante : commence à 15 et se termine à 19. Exemple 6 : Lorsque l'expression "(go/s*)+" correspond à "Allons-y, allez !", le résultat de la correspondance est : succès ; le contenu correspondant est : "go go go" ; les positions sont : commençant à 6 et se terminant à 14.
Exemple 7 : Lorsque l'expression "￥(/d+/.?/d*)" correspond à "＄10.9,￥20.5", le résultat de la correspondance est : succès ; le contenu correspondant est : "￥ 20.5" ; la position correspondante est : commençant à 6 et se terminant à 10. Le contenu correspondant en obtenant uniquement la plage de tranches est : "20,5".
表达式 | 匹配结果 |
(d)(/w+) | "/w+" 将匹配第一个 "d" 之后的所有字符 "xxxdxxxd" |
(d)(/w+)(d) | "/w+" 将匹配第一个 "d" 和最后一个 "d" 之间的所有字符 "xxxdxxx"。虽然 "/w+" 也能够匹配上最后一个 "d"，但是为了使整个表达式匹配成功，"/w+" 可以 "让出" 它本来能够匹配的最后一个 "d" |
| <🎜>Expression <🎜>< /td> | <🎜>Résultats correspondants<🎜> |
| <🎜>(d)(/w+)<🎜> | < td><🎜 >"/w+" correspondra à tous les caractères après le premier "d" "xxxdxxxd"<🎜>|
| <🎜>(d)(/w+)( d) <🎜> | <🎜>"/w+" fera correspondre tous les caractères "xxxdxxx" entre le premier "d" et le dernier "d". Bien que "/w+" puisse également correspondre au dernier "d", afin que l'expression entière corresponde avec succès, "/w+" peut "abandonner" le dernier "d" auquel il aurait pu correspondre <🎜> | < /tr>
On peut voir que "/w+" correspond toujours à autant de caractères que possible qui correspondent à ses règles lors de la correspondance. Bien que dans le deuxième exemple, il ne corresponde pas au dernier « d », c'est pour que l'expression entière puisse être mise en correspondance avec succès. De la même manière, les expressions avec "*" et "{m,n}" correspondent autant que possible, et les expressions avec "?" sont également "correspondantes" autant que possible lorsqu'elles peuvent correspondre ou non. Ce principe d'appariement est appelé mode « gourmand ».
Mode non gourmand :
Ajouter un signe "?" après le symbole spécial qui modifie le nombre de correspondances, pour que l'expression avec un nombre indéfini de correspondances peut être rendu aussi petit que possible Moins de correspondances, de sorte que les expressions qui peuvent correspondre ou non puissent être « sans correspondance » autant que possible. Ce principe d'appariement est appelé mode « non gourmand », encore appelé mode « réticent ». S'il y a moins de correspondances, l'expression entière ne parviendra pas à correspondre. Semblable au mode gourmand, le mode non gourmand correspondra au minimum à davantage pour que l'expression entière corresponde correctement. Par exemple, pour le texte "dxxxdxxxd" :
| <🎜>Résultats correspondants<🎜> | ||||||
| <🎜>(d)(/w+?)<🎜> | <🎜 > "/w+?" correspondra au moins de caractères possible après le premier "d". Le résultat est : "/w+ ?" ><🎜>(d)(/w+?)(d)<🎜> | <🎜>Pour que l'expression entière corresponde avec succès, "/w+ doit correspondre à "xxx" uniquement. alors le "d" suivant peut correspondre, de sorte que l'expression entière corresponde avec succès. Par conséquent, le résultat est : "/w+?" correspond à "xxx"<🎜> |
Plus de situations, les exemples sont les suivants :
Exemple 1 : Expression "
aa< ;/ p>
bb
bb
Exemple 2 : En revanche, lorsque l'expression "
aa
bb
2.2 Rétroréférence /1, /2...
Lors de la correspondance d'une expression, le moteur d'expression fera correspondre l'expression contenue entre parenthèses "( )" Enregistrez la chaîne correspond à la formule. Lors de l'obtention du résultat de correspondance, la chaîne correspondant à l'expression contenue entre parenthèses 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 la recherche et que le contenu à obtenir n'inclut pas la limite, des parenthèses doivent être utilisées pour spécifier la plage souhaitée. Par exemple, le précédent "
En fait, "la chaîne correspondant à l'expression contenue entre parenthèses" peut non seulement être utilisée une fois la correspondance terminée, mais peut également être utilisée pendant le processus de correspondance. La partie après l'expression peut faire référence à la "sous-correspondance entre parenthèses précédente qui correspond déjà à la chaîne". La méthode de référence est "/" plus un nombre. "/1" fait référence à la chaîne correspondant à la première paire de parenthèses, "/2" fait référence à la chaîne correspondant à la deuxième paire de parenthèses... et ainsi de suite. Si une paire de parenthèses contient une autre paire de parenthèses, alors. la paire externe Les parenthèses du calque sont triées en premier. En d'autres termes, quelle paire de crochets gauches "(" vient en premier, alors cette paire sera triée en premier.
Par exemple :
Exemple 1 : Expression "('|" )(. *?)(/1)" Lors de la correspondance avec " 'Bonjour', "Monde" ", le résultat correspondant est : succès ; le contenu correspondant est : " 'Bonjour' ". Lors de la correspondance à nouveau avec le suivant, il peut correspondre à " "Monde" ".
Exemple 2 : Lorsque l'expression "(/w)/1{4,}" correspond à "aa bbbb abcdefg ccccc 111121111 999999999", le résultat de la correspondance est : success; matched Le contenu est "ccccc". Une fois la correspondance effectuée, vous obtiendrez 999999999. Cette expression nécessite que les caractères de la plage "/w" soient répétés au moins 5 fois. Notez la différence avec "/w{5,}". Exemple 3 : Expression "<(/w+)/s*(/w+(=('|").*?/4)?/s*)*>.*?" Lors de la correspondance "
< 🎜. >Dans le chapitre précédent, j'ai parlé de plusieurs symboles spéciaux qui représentent des significations abstraites : "^", "$" et "/b". Ils ont tous une chose en commun, c'est-à-dire qu'ils ne correspondent à aucun caractère. Une condition est attachée aux « deux extrémités de la chaîne » ou à « l'espace entre les caractères ». Après avoir compris ce concept, cette section continuera à introduire une autre expression plus flexible qui attache des conditions aux « deux extrémités » ou à « l'espace ». Méthode
Pré-recherche avant : "(?=xxxxx)", "(?!xxxxx)" Format : "(?=xxxxx)", dans la chaîne correspondante, la La condition qu'il attache à "l'espace" ou aux "deux extrémités" est la suivante : le côté droit de l'espace doit pouvoir correspondre à l'expression de xxxxx car il n'est utilisé que comme condition supplémentaire sur cet espace. Cela n'affecte pas les expressions suivantes. pour faire correspondre les caractères après cet espace. Ceci est similaire à "/b", qui ne correspond à aucun caractère. Il prend simplement les caractères avant et après l'espace et porte un jugement, n'affectera pas les expressions suivantes pour obtenir la valeur true. correspondance. Exemple 1 : Lorsque l'expression "Windows (?=NT|XP)" correspond à "Windows 98, Windows NT, Windows 2000", elle correspondra uniquement à "Windows" dans "Windows NT". , et les autres mots « Windows » ne correspondent pas.Exemple 2 : L'expression "(/w)((?=/1/1/1)(/1))+" correspondra à 6 "f" lors de la correspondance avec la chaîne "aaa ffffff 999999999" Les 4 premiers de , peut correspondre aux 7 premiers des 9 "9". Cette expression peut être lue comme suit : si les lettres et les chiffres sont répétés plus de 4 fois, alors la partie située avant les 2 derniers chiffres correspond. Bien entendu, cette expression n’a pas besoin d’être écrite ainsi, mais elle n’est utilisée qu’à des fins de démonstration.
Format : "(?!xxxxx)", situé à droite du vide, ne doit pas correspondre à la partie xxxxx de l'expression.
Exemple 3 : Lorsque l'expression "((?!/bstop/b).)+" correspond à "fdjka ljfdl stop fjdsla fdj", elle correspondra du début à la position avant "stop". le caractère S'il n'y a pas de "stop" dans la chaîne, la chaîne entière est mise en correspondance.
Exemple 4 : Lorsque l'expression "do(?!/w)" correspond à la chaîne "done, do, dog", elle ne peut correspondre qu'à "do". Dans cet exemple, utiliser "(?!/w)" après "do" a le même effet que "/b".
Pré-recherche inversée : "(?<=xxxxx)", "(?
Les concepts de ces deux formats sont similaires à la pré-recherche directe. Les conditions requises pour la pré-recherche inversée sont : le "côté gauche" de l'écart. Les deux formats exigent respectivement qu'il doit pouvoir correspondre et ne doit pas pouvoir correspondre à l'expression spécifiée, au lieu de juger le côté droit. La même chose que la "pré-recherche avant" est qu'il s'agit de conditions supplémentaires pour l'écart et qu'elles ne correspondent à aucun caractère lui-même.
Exemple 5 : Lorsque l'expression "(?<=/d{4})/d+(?=/d{4})" correspond à "1234567890123456", elle correspondra à l'exception des 4 premiers nombres et Les 8 chiffres du milieu en plus des 4 derniers chiffres. Étant donné que JScript.RegExp ne prend pas en charge la pré-recherche inversée, cet exemple ne peut pas être démontré. De nombreux autres moteurs peuvent prendre en charge la pré-recherche inversée, tels que le package java.util.regex dans Java 1.4 et supérieur, l'espace de noms System.Text.RegularExpressions dans .NET et le moteur standard DEELX le plus simple et le plus facile à utiliser recommandé par ce site.
3. Autres règles générales
Il existe également des règles communes entre les différents moteurs d'expressions régulières Dans le processus d'explication précédent Non mentionné dans .
3.1 Dans les expressions, vous pouvez utiliser "/xXX" et "/uXXXX" pour représenter un caractère ("X" représente un nombre hexadécimal)
| Plage de caractères
| < /tr >||||||||||||||||
| <🎜>/xXX<🎜> | <🎜>Caractères numérotés dans la plage de 0 à 255, par exemple : les espaces peuvent utiliser "/x20" pour représenter <🎜> | ||||||||||||||||
| <🎜>/uXXXX<🎜> | <🎜>Tout caractère peut utiliser "/u" plus le nombre hexadécimal à 4 chiffres de son numéro Représentation du numéro de système, telle que : "/中"<🎜> |
| < 🎜>L'expression<🎜> | <🎜> peut correspondre à <🎜> | ||||||||||||||||||||||
| <🎜>/S<🎜> | <🎜>Correspond à tous les caractères autres que des espaces ("/s" correspond à tous les caractères d'espacement)<🎜> | ||||||||||||||||||||||
| <🎜>/D<🎜> | < td><🎜>correspond à tous les caractères non numériques<🎜>|||||||||||||||||||||||
| <🎜>/W<🎜> | <🎜>correspond à toutes les lettres, les caractères autres que les chiffres et les traits de soulignement <🎜> | ||||||||||||||||||||||
| <🎜>/B<🎜> | <🎜> correspondent aux limites autres que les mots, c'est-à-dire les côtés gauche et droit L'espace entre les caractères lorsque les deux sont dans la plage "/w" ou que les côtés gauche et droit ne sont pas dans la plage "/w" <🎜> |
| Description | ||||||||||||||||||||||
| ^ | Correspond au début de la chaîne d'entrée. Pour faire correspondre le caractère "^" lui-même, utilisez "/^" | ||||||||||||||||||||||
| $ | pour faire correspondre l'entrée La position de fin de la chaîne. Pour faire correspondre le caractère "$" lui-même, utilisez le "/$"
| ||||||||||||||||||||||
| <🎜>( )<🎜> | <🎜> balise Les positions de début et de fin d'une sous-expression. Pour faire correspondre les parenthèses, utilisez "/(" et "/)"<🎜> | ||||||||||||||||||||||
| <🎜>[ ]<🎜> | <🎜 >Utilisé pour personnaliser les expressions pouvant correspondre à « différents caractères ». Pour faire correspondre les parenthèses, utilisez "/[" et "/]"<🎜> | ||||||||||||||||||||||
| <🎜>{ }<🎜> | <🎜 >Symbole cela modifie le nombre de matchs. Pour faire correspondre les accolades, utilisez "/{" et "/}"<🎜> | ||||||||||||||||||||||
| <🎜>.<🎜> | <🎜> Correspond à n'importe quel caractère sauf la nouvelle ligne (/n). Pour faire correspondre le point décimal lui-même, utilisez "/."<🎜> | ||||||||||||||||||||||
| <🎜>?<🎜> | <🎜> pour modifier la correspondance comptez jusqu'à 0 fois ou 1 fois. Pour faire correspondre le caractère "?" lui-même, modifiez la correspondance avec "/?"<🎜> | ||||||||||||||||||||||
| <🎜>+<🎜> | <🎜 > Le nombre de fois est d'au moins 1 fois. Pour faire correspondre le caractère "+" lui-même, modifiez la correspondance avec "/+"<🎜> | ||||||||||||||||||||||
| <🎜>*<🎜> | <🎜 > Le nombre de fois est 0 fois ou n'importe quel nombre de fois. Pour faire correspondre le caractère "*" lui-même, utilisez "/*"<🎜> | ||||||||||||||||||||||
| <🎜>|<🎜> | <🎜>gauche et relation "OU" correcte entre les expressions. Pour faire correspondre "|" lui-même, veuillez utiliser "/|"<🎜> |
| <🎜>Attribut d'expression<🎜> | <🎜>Description<🎜> |
| <🎜>Ignorer la casse< 🎜 > | <🎜>Par défaut, les lettres des expressions sont sensibles à la casse. Configurez Ignorecase pour que la correspondance soit insensible à la casse. Certains moteurs d'expression étendent le concept de « casse » aux majuscules et aux minuscules dans la gamme UNICODE. <🎜> |
| <🎜>Singleline<🎜> | <🎜>Par défaut, le point décimal "." correspond à tout sauf aux nouvelles lignes (/n ) caractères autres que . La configuration en ligne unique permet au point décimal de correspondre à tous les caractères, y compris les nouvelles lignes. <🎜> |
| <🎜>Multiligne<🎜> | <🎜>Par défaut, les expressions "^" et "$" ne correspondent qu'aux caractères Le positions de début ① et de fin ④ de la chaîne. Tels que : ①xxxxxxxxx②/n ③xxxxxxxxx④ Le configurer comme Multiline peut faire correspondre "^" non seulement ①, mais aussi la position ③ après le caractère de nouvelle ligne et avant le début de la ligne suivante, et faire correspondre "$" ④, et il peut également correspondre à la position ② avant le caractère de nouvelle ligne et fin de ligne. <🎜> |
| <🎜>Global<🎜> | <🎜> fonctionne principalement lorsque des expressions sont utilisées pour le remplacement, configurées comme Représentation globale Remplacer toutes les correspondances . <🎜> |
4. Autres conseils
4.1 Si vous souhaitez en savoir plus sur le moteur régulier avancé qui prend également en charge la syntaxe régulière complexe, veuillez vous référer au moteur régulier DEELX. sur ce site Documentation.
4.2 Si vous souhaitez que l'expression corresponde à la chaîne entière au lieu de rechercher une partie de la chaîne, vous pouvez utiliser "^" et "$" au début et à la fin de l'expression, par exemple : "^" /d+$" nécessite que la chaîne entière ne contienne que des chiffres.
4.3 Si le contenu correspondant est un mot complet, et non une partie du mot, utilisez "/b" au début et à la fin de l'expression, par exemple : utilisez "/b(if|while| else| void|int……)/b" pour correspondre aux mots-clés du programme.
4.4 Les expressions ne correspondent pas aux chaînes vides. Sinon, vous obtiendrez toujours un succès correspondant, mais rien ne sera égalé en conséquence. Par exemple : lorsque vous préparez l'écriture d'une expression correspondant à "123", "123.", "123.5", ".5", l'entier, le point décimal et les chiffres décimaux peuvent être omis, mais n'écrivez pas l'expression comme : " /d*/.?/d*", car cette expression peut également correspondre avec succès s'il n'y a rien. Une meilleure façon de l'écrire est : "/d+/.?/d*|/./d+".
4.5 Ne faites pas de boucle infinie pour les sous-correspondances pouvant correspondre à des chaînes vides. Si chaque partie de la sous-expression entre parenthèses peut être mise en correspondance 0 fois et que les parenthèses dans leur ensemble peuvent correspondre un nombre infini de fois, alors la situation peut être plus grave que l'élément précédent et le processus de correspondance peut boucler sans fin. Bien que certains moteurs d'expressions régulières aient adopté des méthodes pour éviter cette situation, comme les expressions régulières .NET, nous devrions quand même essayer d'éviter cette situation. Si l’on rencontre une boucle infinie lors de l’écriture d’une expression, on peut aussi partir de là pour savoir si c’est la raison évoquée dans cet article.
4.6 Choisissez raisonnablement le mode gourmand et le mode non gourmand, voir discussion du sujet.
4.7 Ou les côtés gauche et droit de "|", il est préférable de ne faire correspondre qu'un seul côté d'un certain caractère, afin que les expressions des deux côtés de "|" ne soient pas différentes en raison de l'échange de postes.
Article suivant---------------------------------- -- --------
1, définir l'expression régulière
1) Définition Il existe deux formes des expressions régulières, l’une est la manière ordinaire et l’autre est la manière constructeur.
2) Manière ordinaire : var reg=/expression/paramètres supplémentaires
Expression : une chaîne représentant une certaine règle, dans laquelle certains caractères spéciaux peuvent être utilisés pour représenter des caractères spéciaux. Les règles seront expliquées en détail plus tard.
Paramètres supplémentaires : utilisés pour élargir le sens de l'expression. Actuellement, il existe trois paramètres principaux :
g : représente la correspondance globale.
i : signifie correspondance insensible à la casse.
m : Indique que plusieurs lignes peuvent correspondre.
Les trois paramètres ci-dessus peuvent être combinés de quelque manière que ce soit pour représenter une signification composite. Bien entendu, aucun paramètre ne peut être ajouté.
Exemple :
var reg=/a*b/;
var reg=/abc+f/g;
3) Méthode du constructeur : var reg=new RegExp ( "expression", "paramètres supplémentaires");
où "expression" et "paramètres supplémentaires" ont la même signification que dans la définition ci-dessus.
Exemple :
var reg=new RegExp("a*b");
var reg=new RegExp("abc+f","g");
4) Normal La différence entre la méthode et la méthode constructeur
L'expression dans la méthode ordinaire doit être une chaîne constante, tandis que l'expression dans le constructeur peut être une chaîne constante ou une variable js, par exemple, basée sur les paramètres d'expression de l'utilisateur. , etc. :
var reg=new RegExp(document.forms[0].exprfiled.value,"g");
2, mode d'expression
1) Le mode d'expression fait référence à la méthode d'expression et au style d'expression, c'est-à-dire comment décrire « l'expression » dans var reg=/expression/additional settings ?
2) Canoniquement parlant, les modes d'expression sont divisés en modes simples et modes composés.
3) Mode simple : fait référence à un modèle exprimé à travers une combinaison de caractères ordinaires, tels que
var reg=/abc0d/;
On peut voir que le mode simple ne peut représenter que des correspondances spécifiques.
4) Modèle composé : fait référence à un modèle exprimé par des caractères génériques, par exemple :
var reg=/a+b?/w/;
où +, ? et /w appartiennent tous aux caractères génériques représentent des significations spéciales. Par conséquent, les modèles composites peuvent exprimer une logique plus abstraite.
Concentrons-nous sur la signification et l'utilisation de chaque caractère générique dans le modèle composite.
5) Explication des caractères spéciaux en mode composé :
1>/ : utilisé comme caractère d'échappement dans de nombreux langages de programmation De manière générale, si le symbole
/ est suivi de It. est le 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 symbole
/ est suivi du 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'échappement, mais // représente le caractère ordinaire /.
L'utilisation de / dans les expressions régulières en Javascript est la même que ci-dessus, sauf que les tables de caractères spéciaux peuvent être différentes selon les langages de programmation.
2>^：匹配输入字符串的起始端，如果是多行匹配，即表达式的附加参数中含有m，则也在一个换行符后匹配。
例子：
/^B/匹配 “Bab Bc ”中的第一个B
例子2：
/^B/gm匹配
“Badd B
cdaf
B dsfB”
中的第一行第一个B，第三行中的第一个B
3>$：匹配输入字符创的尾端，如果是多行匹配，即表达式的附加参数中含有m，则也在一个换行符前匹配。
与^的用法相反。
例子：/t$/匹配“bat”中的t，但是不匹配“hate”中的t
例子2：/t$/匹配
“tag at
bat”
中第一行的最后一个t和第二行的t。
4>*：匹配前一个字符0次或多次。
例子：/ab*/匹配“dddabbbbc”中的“abbbb”，也匹配“ddda”中的“a”
5>+：匹配前一个字符1次或多次。
例子：/ab+/匹配“dddabbbbc”中的“abbbb”，但不匹配“ddda”
与后面的{1,}（原型：{n,}）的用法类似
6>?：?的用法比较特殊，一般来说它用来对前一个字符做0次或1次匹配，但是它有另外两种特殊的用法：
如果紧跟在*、+、?和{ }之后，则表示原始匹配的最小次数匹配，例如：
/ba*/本来匹配“bbbaaaa”中的“baaaa”，但是/ba*?/则匹配“bbbaaaa”中的“b”（因为*表示0次或多次匹配，而加?应该表示最少次数匹配，即0次匹配）。
同理：/ba+?/则匹配“baaaa”中的“ba”。
作为语法结构符号，使用于前置断言中，即后面要说到的x(?=y)和x(?!=y)
7>.：小数点中的“.”号，匹配任何一个单独的字符，但是换行符除外。
标准中总共有哪些字符？请参考：字符集
例如：/a.b/匹配“acbaa”中的“acb”，但是不匹配“abbb”。
8>(x)：表示匹配x(并非特指字符x或者特指一个字符，x表示一个字符串)，而且匹配会被记住，在语法中这种()被称为“capturing parentheses ”，即捕捉用的小括号。
匹配会被记住，是因为在表达式提供的函数中，有些函数返回一个数组，该数组会保存所匹配的所有字符串，例如exec()函数。
另外还要注意()中的x被记住的前提是匹配x。
例子1：
var regx=/a(b)c/; var rs=regx.exec(“abcddd”);
从上面可以看出,/a(b)c/匹配“abcddd”中的“abc”，因为()的原因，b也会记录下来，因此rs返回的数字内容为：
{abc,b}
例子2：
var regx=/a(b)c/; var rs=regx.exec(“acbcddd”);
rs返回null，因为/a(b)c/不匹配“acbcddd”，所以()中的b不会被记录下来（尽管字符串中含有b）
9>(?:x)：匹配x，但不会记住x，这种格式中的()被称为“non-capturing parentheses ”，即非捕捉用的小括号。
例子：
var regx=/a(?:b)c/; var rs=regx.exec(“abcddd”);
从上面可以看出,/a(?:b)c/匹配“abcddd”中的“abc”，因为(?:)的原因，b不会记录下来，因此rs返回的数字内容为：
{abc}
10>X(?=y)：匹配x，仅当后面紧跟着y时。如果符合匹配，则只有x会被记住，y不会被记住。
例子：
var regx=/user(?=name)/; var rs=regx.exec(“The username is Mary”);
结果：匹配成功，而且rs的值为{user}
11>X(?!y)：匹配x，仅当后面不紧跟着y时。如果符合匹配，则只有x会被记住，y不会被记住。
例子：
var regx=/user(?!name)/; var rs=regx.exec(“The user name is Mary”);
结果：匹配成功，而且rs的值为{user}
例子2：
var regx=//d+(?!/.)/; var rs=regx.exec(“54.235”);
结果：匹配成果，rs的值为{5}，不匹配54是因为54后面跟着“.”号，当然235也匹配，但是由于exec方法的行为，235不会被返回
12>x|y：匹配x或y。注意如果x和y都匹配上了，那么只记住x。
例子：
var regx=/beijing|shanghai/; var rs=regx.exec(“I love beijing and shanghai”);
结果：匹配成功，rs的值为{beijing}，虽然shanghai也匹配，但不会被记住。
13>{n}：匹配前一个字符的n次出现。
n必须是一个非负数，当然如果是一个负数或小数也不会报语法错误。
例子：
var regx=/ab{2}c/;
var rs=regx.exec(“abbcd”);结果：匹配成功，rs的值为：{abbc}。
14>{n,}：匹配前一个字符的至少n次出现。
例子：
var regx=/ab{2,}c/;
var rs=regx.exec(“abbcdabbbc”);结果：匹配成功，rs的值为：{abbc}。注意为什么abbbc也符合条件为什么没有被记住，这与exec方法的行为有关，后面会统一讲解。
15>{n,m}：匹配前一个字符的至少n次最多m次的出现。
只要n与m为数字，而且m>=n就不会报语法错误。
例子：
var regx=/ab{2,5}c/;
var rs=regx.exec(“abbbcd”);结果：匹配成功，rs的值为：{abbbc}。
例子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”);
结果：匹配成功，rs的值为：{abbbbb}，这说明，如果前一个字符出现多于m次，则只匹配m次。另外：
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]等同于[x-z]。
例子：
var regx=/a[bc]d/; var rs=regx.exec(“abddgg”);
结果：匹配成功，rs的值为：{abd}
例子2：
var regx=/a[bc]d/; var rs=regx.exec(“abcd”);
结果：匹配失败，rs的值为：null，之所以失败，是因为[bc]表示匹配b或c中的一个，但不会同时匹配。
17>[^xyz]：该模式表示匹配非[]中的一个字符，形式上[^xyz]等同于[^x-z]。
例子：
var regx=/a[^bc]d/; var rs=regx.exec(“afddgg”);
结果：匹配成功，rs的值为：{afd}
例子2：
var regx=/a[^bc]d/; var rs=regx.exec(“abd”);
结果：匹配失败，rs的值为：。
18>[/b]：匹配退格键。
19>/b：匹配一个词的边界符，例如空格和换行符等等，当然匹配换行符时，表达式应该附加参数m。
例子：
var regx=//bc./; var rs=regx.exec(“Beijing is a beautiful city”);
结果：匹配成功，rs的值为：{ci}，注意c前边的空格不会匹配到结果中，即{ ci}是不正确的。
20>/B：代表一个非单词边界。
例子：
var regx=//Bi./; var rs=regx.exec(“Beijing is a beautiful city”);
结果：匹配成功，rs的值为：{ij}，即匹配了Beijing中的ij。
21>/cX，匹配一个控制字符。例如， /cM 匹配一个 Control-M 或
回车符。 x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一
个原义的 'c' 字符。（实际的例子还需补充）
21>/d：匹配一个数字字符，等同于[0-9]。
例子：
var regx=/user/d/; var rs=regx.exec(“user1”);
结果：匹配成功，rs的值为：{user1}
22>/D：匹配一个非数字字符，等同于[^0-9]。
例子：
var regx=/user/D/; var rs=regx.exec(“userA”);
结果：匹配成功，rs的值为：{userA}
23>/f：匹配一个换页符。
24>/n：匹配一个换行符。因为是换行符，所以在表达式中要加入m参数。
例子：
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].
例子：
var regx=//si/; var rs=regx.exec(“Beijing is a city”);
结果：匹配成功，rs的值为：{ i}
27>/S：匹配一个非空格符，等同于[ ^/f/n/r/t/v/u00A0/u2028/u2029].
例子：
var regx=//Si/; var rs=regx.exec(“Beijing is a city”);
结果：匹配成功，rs的值为：{ei}
28>/t：匹配一个tab
例子：
var regx=/a/tb/; var rs=regx.exec(“a bc”);
结果：匹配成功，rs的值为： {a bc}
29>/v：匹配一个竖向的tab
30>/w：匹配一个数字、_或字母表字符，即[A-Za-z0-9_ ]。
例子：
var regx=//w/; var rs=regx.exec(“$25.23”);
结果：匹配成功，rs的值为：{2}
31>/W：匹配一个非数字、_或字母表字符，即[^A-Za-z0-9_ ]。
例子：
var regx=//w/; var rs=regx.exec(“$25.23”);
结果：匹配成功，rs的值为：{$}
32>/n：注意不是/n，这里n是一个正整数，表示匹配第n个()中的字符。
例子：
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}
另外，如果有多个合适的匹配，则第一次执行exec返回一个第一个匹配，此时继续执行exec，则依次返回第二个第三个匹配。例如：
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)，判断字符串str是否匹配表达式，返回一个布尔值。例如：
var regx=/user/d+/g; var flag=regx.test(“user12dd”);
flag的值为true。
3）String对象方法
1>match(expr)，返回与expr相匹配的一个字符串数组，如果没有加参数g，则返回第一个匹配，加入参数g则返回所有的匹配
例子：
var regx=/user/d/g; var str=“user13userddduser345”; var rs=str.match(regx);
rs的值为：{user1,user3}
2>search(expr)，返回字符串中与expr相匹配的第一个匹配的index值。
例子：
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的匹配字符串（注意小括号可以记忆匹配）。
例子：
var regx=/user/d/g; var str=“user13userddduser345”; var rs=str.replace(regx,”00”);
rs的值为：003userddd0045
例子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都没有关系，结果是一样的。
例子：
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，返回表达式字符串自身。例如：
var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var source=regx.source;
source的值为user/d
3）和匹配结果相关的三个属性：
1>index，返回当前匹配的位置。例如：
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，用于匹配的字符串。例如：
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个汉字。
实现：
<script>
function checkForm(obj){
var username=obj.username.value;
var regx=/^[/u4e00-/u9fa5]{2,4}$/g
if(!regx.test(username)){
alert(“Invalid username!”);
return false;
}
return true;
}
</script>
<form name=“myForm”onSubmit=“return checkForm(this)”>
<input type=“text” name=“username”/>
<input type=“submit” vlaue=“submit”/>
</form>2）实际应用二
描述：给定一个含有html标记的字符串，要求将其中的html标记去掉。
实现：
<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）对于表达式对象的exec方法，不加入g，则只返回第一个匹配，无论执行多少次均是如此，如果加入g，则第一次执行也返回第一个匹配，再执行返回第二个匹配，依次类推。例如
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）对于String对象的match方法，不加入g，也只是返回第一个匹配，一直执行match方法也总是返回第一个匹配，加入g，则一次返回所有的匹配（注意这与表达式对象的exec方法不同，对于exec而言，表达式即使加上了g，也不会一次返回所有的匹配）。例如：
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域中是这样的。
以上就是本文的全部内容，希望对大家的学习有所帮助，更多相关内容请关注PHP中文网！
相关推荐：
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Balises HTML courantes
Les dix principaux échanges de devises numériques
Comment utiliser la fonction dict en Python
Est-ce que plus la fréquence du processeur de l'ordinateur est élevée, mieux c'est ?
Comment utiliser les bugs de recherche
Quels sont les attributs d'une balise ?
utilisation de l'instruction switch
Utilisation de caractères arbitraires dans les expressions régulières
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
