Introduction de base aux expressions régulières et exemples d'apprentissage

Je rencontre souvent des situations où je dois utiliser des expressions régulières, et je recherche, copie et colle toujours habituellement Au fil du temps, je connaissais un peu les expressions régulières, mais maintenant j'ai même du mal à lire une expression complexe. . Par conséquent, j'ai décidé de bien apprendre les expressions régulières. Ici, je vais commencer par les bases, enregistrer plusieurs expressions courantes, pratiquer la capacité de lire les expressions régulières et présenter brièvement l'objet regexp en JavaScript.

1. Introduction aux expressions régulières :

Expression régulière : C'est un modèle de texte composé de caractères communs et de caractères spéciaux. règle de correspondance de chaîne qui peut être utilisée pour vérifier si une chaîne contient une certaine sous-chaîne, remplacer une certaine chaîne ou extraire une certaine sous-chaîne d'une chaîne. Création d'expressions régulières Tout comme les expressions mathématiques, vous pouvez combiner de petites expressions pour créer des expressions plus grandes.

Caractères normaux  : Les caractères normaux incluent tous les caractères imprimables et non imprimables qui ne sont pas explicitement désignés comme métacaractères. Cela inclut toutes les lettres majuscules et minuscules, tous les chiffres, tous les signes de ponctuation et quelques autres. . symbole.

非打印字符

非打印字符	说明
cx	匹配由x指明的控制字符。例如 cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。
f	匹配一个换页符。等价于 x0c 和 cL。
n	匹配一个换行符。等价于 x0a 和 cJ。
r	匹配一个回车符。等价于 x0d 和 cM。
s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ fnrtv]。
S	匹配任何非空白字符。等价于 [^ fnrtv]
t	匹配一个制表符。等价于 x09 和 cI
v	匹配一个垂直制表符。等价于 x0b 和 cK

Caractères non imprimables

Caractères non imprimables	Description
cx	Correspond au caractère de contrôle spécifié par x. Par exemple, cM correspond à un caractère Control-M ou à un retour chariot. La valeur de x doit être A-Z ou a-z. Sinon, c est traité comme un caractère « c » littéral.
f	Correspond à un saut de formulaire. Équivalent à x0c et cL.
n	Correspond à un caractère de nouvelle ligne. Équivalent à x0a et cJ.
r	Correspond à un caractère de retour chariot. Équivalent à x0d et cM.
s	Correspond à n'importe quel caractère d'espacement, y compris les espaces, les tabulations, les sauts de formulaire, etc. Équivalent à [fnrtv].
S	Correspond à tout caractère autre qu'un espace. Équivalent à [^ fnrtv]
t	correspond à un caractère de tabulation. Équivalent à x09 et cI
v	correspond à un caractère de tabulation verticale. Equivalent à x0b et cK

Caractères spéciaux  : Certains caractères avec des significations particulières, comme le caractère générique "*", ces caractères si Pour effectuer une recherche dans une chaîne, vous devez utiliser un caractère d'échappement, qui est la barre oblique inverse.

通配符

特殊字符	描述
$	匹配输入字符串的结尾位置。
()	标记一个子表达式的开始和结束。
*	匹配前面子表达式零次或多次。
+	匹配前面的子表达式一次或多次。
.	匹配除换行符n之外的任何单字符。
[	标记一个中括号表达式的开始。
?	匹配前面的子表达式一次或零次或指明一个非贪婪限定符。
	将下一个字符标记为特殊字符、或元义字符、或向后引用、或八进制转义符。
^	匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。
{	标记限定符表达式的开始。
|	指明两项之间的一个选择。

Qualificateur : Le qualificatif est utilisé pour spécifier combien de fois un composant donné de l'expression régulière doit apparaître pour répondre au nombre variable de correspondances, comprenant principalement {0 ou 1}, {1 ou n} , {0 ou 1}, {n}, {supérieur ou égal à n}, {supérieur ou égal à n, inférieur ou égal à m} six types. Les expressions correspondantes sont *, +, ? ,{n},{n,},{n,m}.

限定符

限定符	描述
*	匹配前面的子表达式零次或多次。
+	匹配前面的表达式一次或多次。
？	匹配前面的子表达式零次或一次。
{n}	n是一个非负整数，匹配确定的n次。
{n,}	n是一个非负整数，至少匹配n次。
{n,m}	m,n是非负整数，n<=m，最少匹配n次，最多匹配m次。注意在“，”和两个数之间不能有空格。

Localisateur  : Le localisateur nous permet de fixer l'expression régulière au début ou à la fin de la ligne. Vous pouvez également créer des expressions spéciales, par exemple : des expressions régulières qui apparaissent à l'intérieur d'un mot ou au début d'un mot ou à la fin d'une ou plusieurs fois. Les localisateurs sont utilisés pour décrire les limites de chaînes ou de mots.

定位符

字符	描述
^	匹配输入字符串的开始位置。如果设置RegExp为Multiline属性，还可以与n和r之后的位置匹配。
$	匹配输入字符串结尾的位置。如果设置RegExp为Multiline属性，还可以与n和r之后的位置匹配。
b	匹配一个字边界，即字与空格间的位置。
B	非字边界匹配。

Remarque : vous ne pouvez pas utiliser de qualificatifs avec des points d'ancrage. Puisqu'il ne peut y avoir plus d'une position avant ou après une nouvelle ligne ou une limite de mot, les "expressions comme ^*" ne sont pas autorisées.

Pour faire correspondre le texte au début d'une ligne de texte, ^ doit être placé au début de l'expression régulière ; pour faire correspondre le texte à la fin d'une ligne de texte, utilisez $ à la fin de l'expression régulière. expression. Ne confondez pas cette utilisation de ^ ou $ avec l'utilisation d'expressions entre crochets.

par exemple :

/^Chapitre [1-9][0-9]{0,1}/les titres de chapitre correspondants sont deux Le nombre de chiffres du titre commençant par Chapter ;

/^Chapter [1-9][0-9]{0,1}$/ correspond à la fois au début et à la fin. du titre du chapitre, c'est-à-dire que cette ligne n'a que le titre du chapitre

/bCha/ correspond aux limites des mots, c'est-à-dire aux limites commençant par Cha ; >

/ terb/Mots se terminant par ter.

/Bapt/, correspond aux limites non-mots, telles que apt dans les correspondances de chapitre, mais l'aptitude ne correspond pas ;

Sélectionner : placez tous les éléments entre parenthèses et séparez les sélections adjacentes par |. Mais l'un des effets secondaires de l'utilisation des parenthèses est que les correspondances pertinentes seront mises en cache et disponibles à ce moment-là ? : Mettre comme première option pour éliminer cet effet secondaire

Élément non capturant :

Backreference : (Inexplicablement, j'ai pensé à la récursivité en langage C...) Je pense qu'en termes simples, une backreference fait référence à un modèle qui a été mis en cache, qui est la passe n dans ce qui suit article. pour accéder au tampon. L'ajout de parenthèses autour d'un modèle d'expression régulière ou d'une partie d'un modèle entraînera le stockage des correspondances associées dans un tampon temporaire (semblable à une sous-chaîne. Rappelez-vous ce que j'ai dit au début, les expressions régulières sont comme des expressions mathématiques, constituées de petites expressions simples. .les expressions sont combinées en grandes expressions complexes, ces tampons temporaires peuvent être compris comme les résultats de correspondance de ces petites expressions), et chaque sous-correspondance capturée est stockée dans l'ordre de gauche à droite dans l'expression. Les numéros de tampon commencent à 1 et peuvent stocker jusqu'à 99 sous-expressions capturées. Chaque tampon est accessible par n, où n est un nombre décimal à un ou deux chiffres qui identifie un tampon spécifique. Des métacaractères non capturants peuvent-ils être utilisés ? :,? =,? ! pour remplacer la capture et ignorer la mise en cache des correspondances associées.

L'une des applications les plus simples et les plus utiles des références arrière est la possibilité de trouver des correspondances de deux mots adjacents identiques dans le texte :

eg1 : Extraire des mots identiques.

var str=Est-ce que c'est le coût de l'essence qui augmente ?

var patt1= /b([a-z]+) 1b/;

document.write(str.match(patt1));

eg2 : diviser l'URL, à partir de ceci exemple Il semble que la référence arrière cite ou extraie en fait les sous-éléments de la grande expression et les utilise. Je pense que cette référence arrière est un peu obscure. (Mettez-le ici pour l'instant, notez-le et modifiez-le plus tard)  ;

var patt1 = /(w+) ://([^/:]+)(:d*) ?([^# ]*)/

arr = str .match(patt1);

2.

1./chapitre [1-9][0-9]/

Cette expression correspond au chapitre + n'importe quel entier, tel que 1, 19, 109, 10099.. . . .

Tout d'abord, le chapitre précédent est corrigé, [1-9] est également corrigé, et ensuite [0-9] est qualifié par le qualificatif *, ce qui signifie qu'il peut apparaître zéro ou plusieurs fois. Par conséquent, il peut être vide, sur un bit ou sur plusieurs bits.

2./[a-zA-z]+://[^s]*/

URL de correspondance

3./d{3}-d{ 8}|d{4}-{7,8}/

Correspondre au numéro de téléphone national

4.[1-9][0-9]{4,}

Correspondre au numéro QQ de Tencent

5.[1-9]d{5}(?!d)

Correspondre au code postal national

6.^(d{ 6})(d{4})(d{2})(d{2})(d{3})([0-9]|X)$

correspond au numéro d'identification à 18 chiffres

7.^[1-9]d*$

correspond à des entiers positifs

8.^-[1-9]d*

correspond Entier négatif

9.^-?[1-9]d*$

correspond à l'entier

10.^[1-9]d*.d*|0 .d*[1-9]d*$

correspond à un nombre à virgule flottante positif

11.^-[1-9]d*.d*|-0.d*[1 - 9]d*$

correspond à un nombre à virgule flottante négatif

Trois, l'objet RegExp de JavaScript

1.Créez un objet d'expression régulière :

new RegExp(pattern, attributes); Le paramètre
pattern fait référence à l'expression régulière, qui est une chaîne, et les attributs sont un paramètre facultatif comprenant g, je suis. Fait respectivement référence à la correspondance globale, à la correspondance sensible à la casse et à la correspondance multiligne.

2.Attributs de l'objet RegExP :

global : Si l'objet RegExp a le drapeau m

par exemple : if(patt1.global) { alert("La propriété globale est définie"); };

ignoreCase : si l'objet RegExp a le drapeau m ;

laseIndex : un entier, marquant la position du caractère où commence la prochaine correspondance ;

multiline : si le L'objet RegExp a le drapeau m ;

source : le texte original de l'expression régulière.

3.Méthodes de l'objet RegExp :

compile : Compilez l'expression régulière.

compile() a deux utilisations. La première est de compiler des expressions régulières pendant l'exécution du script. La seconde consiste à modifier et recompiler l'expression régulière ;

par exemple : RegExpObject.compile(regexp,modifier);

Le premier paramètre est l'expression régulière et le deuxième paramètre spécifie le type de correspondance.

var str="Every man in the world! Every woman on earth!";

patt=/man/g;
str2=str.replace(patt,"person");
document.write(str2+"<br />");patt=/(wo)?man/g;
patt.compile(patt);//这里改变了正则表达式str2=str.replace(patt,"person");
document.write(str2);<p><strong>exec</strong>：检索字符串中指定的值，返回找到的值并确定其位置。</p>
<p>eg：RegExpObject.exec(<em>string</em>);//返回一个结果，用于存放匹配的数组，如果未找到匹配，则为null。</p>
<h3>说明：</h3>
<p>exec() 方法的功能非常强大，它是一个通用的方法，而且使用起来也比 test() 方法以及支持正则表达式的 String 对象的方法更为复杂。</p>
<p>如果 exec() 找到了匹配的文本，则返回一个结果数组。否则，返回 null。此数组的第 0 个元素是与正则表达式相匹配的文本，第 1 个元素是与 RegExpObject 的第 1 个子表达式相匹配的文本（如果有的话），第 2 个元素是与 RegExpObject 的第 2 个子表达式相匹配的文本（如果有的话），以此类推。除了数组元素和 length 属性之外，exec() 方法还返回两个属性。index 属性声明的是匹配文本的第一个字符的位置。input 属性则存放的是被检索的字符串 string。在调用非全局的 RegExp 对象的 exec() 方法时，返回的数组与调用方法 String.match() 返回的数组是相同的。</p>
<p>但是，当 RegExpObject 是一个全局正则表达式时，exec() 的行为就稍微复杂一些。它会在 RegExpObject 的 lastIndex 属性指定的字符处开始检索字符串 string。当 exec() 找到了与表达式相匹配的文本时，在匹配后，它将把 RegExpObject 的 lastIndex 属性设置为匹配文本的最后一个字符的下一个位置。这就是说，可以通过反复调用 exec() 方法来遍历字符串中的所有匹配文本。当 exec() 再也找不到匹配的文本时，它将返回 null，并把 lastIndex 属性重置为 0。</p>
<h2>提示和注释</h2>
<p class="important">重要事项：如果在一个字符串中完成了一次模式匹配之后要开始检索新的字符串，就必须手动地把 lastIndex 属性重置为 0。</p>
<p class="tip">提示：请注意，无论 RegExpObject 是否是全局模式，exec() 都会把完整的细节添加到它返回的数组中。这就是 exec() 与 String.match() 的不同之处，后者在全局模式下返回的信息要少得多。因此我们可以这么说，在循环中反复地调用 exec() 方法是唯一一种获得全局模式的完整模式匹配信息的方法。</p>
<div class="cnblogs_code"><pre class="brush:php;toolbar:false">var str = "正则表达式的exec方法测试"; 
var patt = new RegExp("exec","g");var result;while ((result = patt.exec(str)) != null)  {
       　　 document.write('result:'+result);
            document.write("<br />");
            document.write('patt.lastIndex:'+patt.lastIndex);
          }

test：检索字符串中指定的值，返回true或false。

eg：var result = patt1.test(str);

4.支持正则表达式的string对象的方法：

search：检索与正则表达式相匹配的值。

stringObj.search(regexp);//参数可以是子串，也可以是regexp对象。

注意：search（）方法不执行全局匹配，它将忽略标志g，它同时忽略regexp的lastIndex属性，并且总是从字符串开始进行检索，所以他的返回值始终是sgringObj的第一个匹配的位置。如果要忽略大小写应追加i标记。

document.write(str.search(/abc/i);

match：找到一个或多个正则表达式的匹配。

stringObj.match(searchValue);//参数为要检索的字符串值

stringObj.match(regexp);//要匹配的模式的regexp对象。

返回存放匹配结果的数组。该数组的内容依赖于regexp是否具有全局属性g；

说明

match() 方法将检索字符串 stringObject，以找到一个或多个与 regexp 匹配的文本。这个方法的行为在很大程度上有赖于 regexp 是否具有标志 g。

如果 regexp 没有标志 g，那么 match() 方法就只能在 stringObject 中执行一次匹配。如果没有找到任何匹配的文本， match() 将返回 null。否则，它将返回一个数组，其中存放了与它找到的匹配文本有关的信息。该数组的第 0 个元素存放的是匹配文本，而其余的元素存放的是与正则表达式的子表达式匹配的文本。除了这些常规的数组元素之外，返回的数组还含有两个对象属性。index 属性声明的是匹配文本的起始字符在 stringObject 中的位置，input 属性声明的是对 stringObject 的引用。

如果 regexp 具有标志 g，则 match() 方法将执行全局检索，找到 stringObject 中的所有匹配子字符串。若没有找到任何匹配的子串，则返回 null。如果找到了一个或多个匹配子串，则返回一个数组。不过全局匹配返回的数组的内容与前者大不相同，它的数组元素中存放的是 stringObject 中所有的匹配子串，而且也没有 index 属性或 input 属性。

注意：在全局检索模式下，match() 即不提供与子表达式匹配的文本的信息，也不声明每个匹配子串的位置。如果您需要这些全局检索的信息，可以使用 RegExp.exec()。

eg：document.write(str.match(/\d+/g));

replace：替换与正则表达式匹配的子串。

stringObect.replace(regexp/substr,replacement);

regexp/substr:必须，正则表达式或者自字符串。

replacement):一个字符串值，规定了替换文本或生成替换文本的函数。

返回一个新的字符串，使用replacement替换第一次匹配或者所有匹配之后得到的。注意：指定g全局变量则替换所有的匹配，否则只替换第一次匹配到的字符串。

split：把字符串分割为字符串数组。

stringObect.split(separator,howmany);

separator:必须，字符串或正则表达式，从该参数指定的地方分割字符串；

howmany：可选，指定返回数组的最大长度，若设置了该参数，返回的子串不会多余这个参数指定的数组，如果没有设置该参数，整个字符串都会被分割。

返回一个字符串数组，不包括separator本身。

 

<br><br>

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!