Métacaractères dans la représentation régulière php

Métacaractères

pose un problème : d signifie correspondre à un caractère. Et maintenant, je veux faire correspondre dix ou huit, que dois-je faire avec un nombre quelconque de nombres ?

Pour le moment, nous utiliserons des métacaractères. Lors de l'utilisation d'atomes, j'ai constaté qu'il ne pouvait correspondre qu'à un seul caractère, mais des problèmes surviennent lors de la correspondance de plusieurs caractères.
À l'heure actuelle, nous devons utiliser des métacaractères pour nous aider à modifier les atomes et à réaliser plus de fonctions.

Ne soyez pas effrayé par ce qui suit. Nous comprendrons tout après avoir fait des expériences petit à petit. L'essentiel est qu'ils soient plus polyvalents.
Il est préférable de préparer une petite carte pour vous aider à vous en souvenir.

Jetons un coup d'oeil :

元字符	功能说明
*	是代表匹配前面的一个原子，匹配0次或者任意多次前面的字符。
+	匹配一次或多前前面的一个字符
?	前面的字符可有可无【可选】 有或没有
.	更标准一些应该把点算作原子。匹配除了n以外的所有字符
	或者。注：它的优先级最低了。
^	必须要以抑扬符之后的字符串开始
$	必须要以$之前的字符结尾
b	词边界
B	非边界
{m}	有且只能出现m次
{n,m}	可以出现n到m次
{m,}	至少m次，最大次数不限制
()	改变优先级或者将某个字符串视为一个整体，匹配到的数据取出来也可以使用它

+ correspond au caractère précédent

<?php
$zz = '/\d+/';

$string = "迪奥和奥迪250都是我最爱";

//待会儿再试试中间没有0-9的情况
//$string = "迪奥和奥迪都是我最爱";


if(preg_match($zz, $string, $matches)){
   echo '匹配到了，结果为：';
   var_dump($matches);
}else{
   echo '没有匹配到';
}

?>

au moins une fois, ce qui prouve le + dans d+. d correspond aux nombres et + correspond au caractère précédent au moins une fois.

* correspond au caractère précédent 0 fois ou un certain nombre de fois

<?php
$zz = '/\w*/';

$string = "!@!@!!@#@!$@#!";

//待会儿再试试中间没有0-9的情况
//$string1 = "!@#!@#!abcABC#@#!";


if(preg_match($zz, $string, $matches)){
   echo '匹配到了，结果为：';
   var_dump($matches);
}else{
   echo '没有匹配到';
}

?>

indique que les $string1 et $string commentés correspondent avec succès . Parce que w correspond à 0-9A-Za-z_ et * signifie que le w précédent n'existe pas. S'il est présent, il peut y en avoir 1 ou plus.

 ? Le caractère précédent apparaît 0 ou 1 fois, facultatif

<?php

$zz = '/ABC\d?ABC/';

$string = "ABC1ABC";

//待会儿再试试中间没有0-9的情况
//$string1 = "ABC888888ABC";
//$string2 = "ABCABC";


if(preg_match($zz, $string, $matches)){
   echo '匹配到了，结果为：';
   var_dump($matches);
}else{
   echo '没有匹配到';
}

?>

correspond à $string, $string2 avec succès, mais ne parvient pas à correspondre à $string1.
Parce qu'il y a ABC avant et après la correspondance, et qu'il y a un 0-9 au milieu, 0-9 est facultatif, mais il ne peut pas y en avoir plus d'un.

. (point) Correspond à tous les caractères sauf n

<?php

$zz = '/gg.+gg/';

$string = "ABC1ABC";


if(preg_match($zz, $string, $matches)){
   echo '匹配到了，结果为：';
   var_dump($matches);
}else{
   echo '没有匹配到';
}

?>

correspond à $string, $string2 réussit, mais ne parvient pas à correspondre à $string1.
Parce qu'il y a ABC avant et après la correspondance, et qu'il y a un 0-9 au milieu, 0-9 est facultatif, mais il ne peut pas y en avoir plus d'un.

| (barre verticale), ou, la priorité la plus basse

Voyons à travers des expériences la correspondance de priorité et ou

<?php

$zz = '/abc|bcd/';

$string1 = "abccd";
$string2 = "ggggbcd";

if (preg_match($zz, $string1, $matches)) {
   echo '匹配到了，结果为：';
   var_dump($matches);
} else {
   echo '没有匹配到';
}

?>

Voyons Regardez :

1. Au début, mon idée de matching était de faire correspondre abccd ou abbcd. Cependant, lors de la correspondance de $string1 et $string2, les résultats correspondants sont abc et bcd

2. Implémentés ou correspondants, les résultats correspondants sont abc ou bcd. Il n’a pas de priorité plus élevée que les chaînes contiguës.

Alors la question est : que dois-je faire si je veux faire correspondre abccd ou abccd dans l'exemple ci-dessus ?

Vous devez utiliser () pour modifier la priorité.

<?php

$zz = '/ab(c|b)cd/';

$string1 = "起来abccd阅兵";
$string2 = "ggggbcd";
$string3 = '中国abbcd未来';

if (preg_match($zz, $string1, $matches)) {
   echo '匹配到了，结果为：';
   var_dump($matches);
} else {
   echo '没有匹配到';
}

?>

Les résultats sont les suivants :

Conclusion :

1. Il correspond à abccd ou abbcd ($string1 ou $string3).

2. Mais il y a un élément supplémentaire dans le tableau correspondant, et l'indice de cet élément est 1

3. Tant que le contenu de () correspond avec succès, les données correspondantes seront être placé dans Dans cet élément de tableau avec l'indice 1.

^ (circonflexe), doit commencer par la chaîne après ^

<?php

$zz = '/^猪哥好帅\w+/';

$string1 = "猪哥好帅abccdaaaasds";
//$string2没有以猪哥好帅开始
$string2 = "帅abccdaaaasds";


if (preg_match($zz, $string1, $matches)) {
   echo '匹配到了，结果为：';
   var_dump($matches);
} else {
   echo '没有匹配到';
}

?>

Les conclusions suivantes ont été trouvées grâce à des expériences :

1.$string1 Le la correspondance est réussie, mais $string2 ne correspond pas avec succès

2. Parce que $string1 commence par le caractère spécifié

3. Et $string2 ne commence pas par le caractère après ^

4. La signification de la traduction de cette règle régulière est : commençant par "Frère Cochon est si beau" suivi d'au moins un caractère a-zA-Z0-9_.

$ (signe dollar) doit se terminer par le caractère avant $

<?php

$zz = '/\d+努力$/';

$string1 = "12321124333努力";
//$string2
$string2 = "12311124112313力";


if (preg_match($zz, $string1, $matches)) {
   echo '匹配到了，结果为：';
   var_dump($matches);
} else {
   echo '没有匹配到';
}

?>

Exécutons-le, examinons les résultats et tirons la conclusion :

1.$string1 correspond avec succès, mais $string2 ne parvient pas à correspondre

2. Le caractère avant $ est d+, suivi de l'effort chinois.

3. Le match est donc tout entier. d fait référence à un entier de 0 à 9, et le signe + représente au moins une limite de mots 0-9

b et B et une limite de non-mot

Quoi nous expliquerons Est-ce que la limite :

1. Les expressions régulières ont des limites Cette limite est la limite où le début et la fin du délimiteur sont réguliers.

2. Il s'agit d'un mot anglais, suivi d'un espace, ce qui signifie que le mot est terminé et a atteint la limite du mot

b limite du mot, ce qui signifie qu'il doit être à la avant ou enfin.
B n'est pas une frontière, c'est-à-dire qu'il ne peut pas être au début ou à la fin d'une expression régulière.

<?php

$zz = '/\w+\b/';

$string1 = "this is a apple";
$string2 = "thisis a apple";
$string3 = "thisisaapple";

if (preg_match($zz, $string1, $matches)) {
   echo '匹配到了，结果为：';
   var_dump($matches);
} else {
   echo '没有匹配到';
}

?>

Conclusion :

1.$string1, $string2 et $string3 correspondent tous avec succès.

2. Lorsque $string1 correspond, cet espace est la limite

3. Lorsque $string2 correspond, ceci est la limite

4. Lorsque $string3 correspond, thisisaapple atteint l'ensemble des expressions régulières représente la fin et donc la limite. Le match est donc réussi.

Expérimentons avec des limites non-mots :

<?php

$zz = '/\Bthis/';

$string1 = "hellothis9";

//$string2 = "hello this9";
//$string2 = "this9中国万岁";

if (preg_match($zz, $string1, $matches)) {
   echo '匹配到了，结果为：';
   var_dump($matches);
} else {
   echo '没有匹配到';
}

?>

Résumé :

1. La correspondance de $string1 est réussie mais $string2 échoue.

2. Parce que B est suivi de ceci, cela ne peut pas apparaître aux limites des mots (espaces et début et fin).

{m} peut et ne peut apparaître que m fois

<?php

$zz = '/喝\d{3}酒/';

$string1 = "喝988酒";

//$string2 = "喝98811酒";

if (preg_match($zz, $string1, $matches)) {
   echo '匹配到了，结果为：';
   var_dump($matches);
} else {
   echo '没有匹配到';
}

?>

Conclusion :
Dans l'exemple ci-dessus, d{3} j'ai précisé que 0-9 peut n'apparaissent que 3 fois, pas une fois de plus ou de moins.

{n,m} peut apparaître n à m fois

<?php

$zz = '/喝\d{1,3}酒/';

$string1 = "喝9酒";

//$string2 = "喝988酒";

if (preg_match($zz, $string1, $matches)) {
   echo '匹配到了，结果为：';
   var_dump($matches);
} else {
   echo '没有匹配到';
}

?>

Conclusion :
Dans l'exemple ci-dessus, j'ai spécifié 0-9 pour d{1, 3} Ne peut apparaître qu'une, 2 ou 3 fois. Tous les autres moments sont faux

{m,} au moins m fois, le nombre maximum n'est pas limité

<?php

$zz = '/喝\d{2,}/';

$string1 = "喝9";

//$string2 = "喝98";
//$string3 = "喝98122121";


if (preg_match($zz, $string1, $matches)) {
   echo '匹配到了，结果为：';
   var_dump($matches);
} else {
   echo '没有匹配到';
}

?>

Conclusion :
d{2,} dans dans l'exemple ci-dessus, je stipule que les chiffres 0 à 9 après la boisson apparaissent au moins deux fois, et il n'y a pas de limite au nombre maximum de fois. Par conséquent, $string1 ne parvient pas à correspondre et $string2 est mis en correspondance avec succès. $string3 correspond avec succès.