Tutoriel de développement PHP de base : métacaractères dans les expressions régulières

1. Métacaractères

Nouvelles exigences : d représente la correspondance d'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.

Voyons :

• + Faire correspondre le caractère précédent <🎜 au moins une fois >

Le code est le suivant :

<?php
$zz = '/\d+/';
$string = "迪奥和奥迪250都是我最爱";
//待会儿再试试中间没有0-9的情况
//$string = "迪奥和奥迪都是我最爱";
if(preg_match($zz, $string, $matches)){
    echo '匹配到了，结果为：';
    var_dump($matches);
}else{
    echo '没有匹配到';
}
?>

Le match est réussi, prouvant le + en 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

Le code est le suivant :

<?php
$zz = '/\w*/';
 
$string = "!@!@!!@#@!$@#!";
//$string1 = "!@#!@#!abcABC#@#!";
if(preg_match($zz, $string, $matches)){
    echo '匹配到了，结果为：';
    var_dump($matches);
}else{
    echo '没有匹配到';
}
?>

Notez 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

Le code est le suivant :

<?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 '没有匹配到';
}
?>

ne correspond pas correctement car le recto et le verso sont obligatoire C'est gg,

2. | (barre verticale), soit, la priorité la plus basse

Voyons à travers des expériences la somme des priorités et ou Matching

<?php
 
$zz = '/abc|bcd/';
$string1 = "abccd";
$string2 = "ggggbcd";
 
if (preg_match($zz, $string1, $matches)) {
    echo '匹配到了，结果为：';
    var_dump($matches);
} else {
    echo '没有匹配到';
}
?>

Jetons un coup d'oeil :

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é.

Le code est le suivant :

<?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 placées dans l'élément du tableau avec l'indice 1.

3. ^ (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 correspond avec succès, $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 : commencez par Xiaoming et continuez. a-zA-Z0-9_Au moins un caractère.

4. $ (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 et voyons. En regardant les résultats, nous sommes arrivés à la conclusion :

1.$string1 a correspondu avec succès, mais $string2 n'a pas réussi à correspondre

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

3 Donc, ce qui correspond, c'est ce tout. d fait référence à un entier de 0 à 9, et le signe + représente au moins un 0 à 9

5. Limites de mots b et B et limites de non-mots

Expliquons ce que sont les limites :

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

2. c'est 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, c'est ça signifie que ce doit être le premier ou le dernier.

• 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, c'est la limite

3. Lorsque $string2 correspond, c'est la limite. >

4. Lorsque $string3 correspond, thisisaapple atteint la fin de toute l'expression régulière, c'est donc aussi 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é :

Correspond à $string1 avec succès mais $string2 échoue .

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

6. {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 : Exemple ci-dessus Dans d{3}, j'ai stipulé que 0-9 ne peut apparaître que 3 fois, pas une fois de plus ou de moins.

7. {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 : Partie 1 Dans l'exemple d{1,3}, j'ai stipulé que 0-9 ne peut apparaître qu'une, 2 ou 3 fois. Toutes les autres fois sont fausses

8. {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 :
Dans l'exemple ci-dessus, nous stipulons que d{2,} et les 0-9 suivants 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.