Tutoriel de développement PHP de base : modificateurs de modèle dans les expressions régulières

1. Introduction au problème

Nous avons terminé l'introduction à l'expression régulière à travers les métacaractères et les atomes. Il existe certaines situations particulières auxquelles nous devons encore faire face.

Comment faire correspondre si abc est au début de la deuxième ligne ?
Je ne veux pas que l’expression régulière soit particulièrement gourmande en correspondance avec tout, que dois-je faire si elle n’en correspond qu’en partie ?

À l'heure actuelle, nous devons utiliser la correspondance de modèles suivante pour améliorer la fonction régulière.

Les caractères de correspondance de modèle couramment utilisés sont :

L'utilisation des caractères de correspondance de modèle est la suivante :

/ Expression régulière expression/motif Le symbole de correspondance de motif

est placé à la fin de cette phrase. Par exemple :

/w+/s

Nous connaissons clairement le format. La prochaine chose la plus importante est de renforcer la compréhension et la mémoire de l'utilisation des caractères correspondant à des modèles. . Nous utilisons du code pour comprendre la différence entre l'ajout et la non-ajout de caractères correspondant à un modèle

2 i n'est pas sensible à la casse

<?php
//在后面加上了一个i
$pattern = '/ABC/i';
$string = '8988abc12313';
$string1 = '11111ABC2222';
if(preg_match($pattern, $string, $matches))
{ echo '匹配到了，结果为：'; var_dump($matches); }
else{ echo '没有匹配到'; }
?>

Conclusion, les deux. $string et $string1 correspondent avec succès. Par conséquent, après avoir ajouté i à la fin, la casse du contenu correspondant peut être séparée

3. m est considéré comme plusieurs lignes

Lorsqu'une correspondance régulière est effectuée, la chaîne cible à mettre en correspondance est généralement considérée comme une ligne.

Le métacaractère "début de ligne" (^) correspond uniquement au début de la chaîne, et le métacaractère "fin de ligne" ($) correspond uniquement à la fin de la chaîne.

Lorsque ce modificateur est défini, "début de ligne" et "fin de ligne" correspondront non seulement au début et à la fin de la chaîne entière, mais correspondront également respectivement après et avant le caractère de nouvelle ligne qu'elle contient.

Remarque : s'il n'y a pas de caractère "n" dans la chaîne à rechercher ou s'il n'y a pas de ^ ou de $ dans le modèle, la définition de ce modificateur n'a aucun effet.

Vérifions cette fonctionnalité à travers des expériences et du code :

Pour le premier match, vous constaterez que le match échoue :

<?php
$pattern = '/^a\d+/';
$string = "我的未来在自己手中我需要不断的努力
a9是一个不错的字符表示
怎么办呢，其实需要不断奋进";
 
if (preg_match($pattern, $string, $matches)) {
    echo '匹配到了，结果为：';
    var_dump($matches);
} else {
    echo '没有匹配到';
}
?>

Pour le deuxième match, Essayons d'ajouter m :

<?php
$pattern = '/^a\d+/m';
$string = "我的未来在自己手中我需要不断的努力
a9是一个不错的字符表示
怎么办呢，其实需要不断奋进";
if (preg_match($pattern, $string, $matches)) {
    echo '匹配到了，结果为：';
    var_dump($matches);
} else {
    echo '没有匹配到';
}
?>

Résultat :

Comme indiqué à droite

La correspondance est réussie. /^ad+/ Le contenu correspondant est a9, qui doit être au début de la ligne. La deuxième ligne correspond également avec succès.

4. s est traité comme une seule ligne

Si ce modificateur est défini, le métacaractère point (.) dans le motif correspond à tous les caractères. , y compris les nouvelles lignes.

La première fois, aucun caractère de correspondance de modèle s n'est ajouté :

<?php
$pattern = '/新的未来.+\d+/';
$string = '新的未来
987654321';
if (preg_match($pattern, $string, $matches)) {
    echo '匹配到了，结果为：';
    var_dump($matches);
} else {
    echo '没有匹配到';
}
?>

La deuxième fois, le caractère de correspondance de modèle s est ajouté après l'expression régulière :

<?php
$pattern = '/新的未来.+\d+/s';
$string = "新的未来
987654321";
if (preg_match($pattern, $string, $matches)) {
    echo '匹配到了，结果为：';
    var_dump($matches);
} else {
    echo '没有匹配到';
?>

Les résultats sont les suivants, le match a été réussi !

Conclusion :

1 Parce que dans le nouveau futur, il y a un saut de ligne après le futur

<🎜. >2. Et .(point) correspond à tous les caractères à l'exception des caractères autres que des espaces. Par conséquent, la première fois a échoué

3. La deuxième fois, le modèle s a été ajouté. Parce que, après avoir ajouté . (point), il peut correspondre à tous les caractères.

5. x ignore les caractères d'espacement

1. Si ce modificateur est défini, les caractères d'espacement dans le motif sont complètement ignorés, à l'exception de ceux qui sont échappés ou dans les classes de caractères.

2. Les caractères entre le caractère # en dehors de la classe de caractères non échappés et le caractère de nouvelle ligne suivant sont également ignorés.

Expérimentons d'abord avec des fonctionnalités telles que l'ignorance des lignes vides :

<?php
$pattern = '/a b c /x';
$string = '学英语要从abc开始';
if (preg_match($pattern, $string, $matches)) {
    echo '匹配到了，结果为：';
    var_dump($matches);
} else {
    echo '没有匹配到';
}
?>

Cela peut également correspondre avec succès.

Il y a des espaces dans $pattern, et il y a un espace après chaque abc. Il n'y a pas d'espaces dans $string.
Donc x ignore les caractères d'espacement.

La deuxième phrase est plus difficile à comprendre littéralement,

<?php
//重点观察这一行
$pattern = '/a b c #我来写一个注释
/x';
$string = '学英语要从abc开始';
if (preg_match($pattern, $string, $matches)) {
    echo '匹配到了，结果为：';
    var_dump($matches);
} else {
    echo '没有匹配到';
}
?>

Le résultat est aussi un match réussi !

Conclusion : Nous avons constaté que la deuxième caractéristique de x est qu'il est ignoré : les caractères entre le caractère # et le caractère de nouvelle ligne suivant sont également ignorés.

6. e Rechercher l'élément correspondant et le remplacer

• Le mode e est également appelé référence inversée . La fonction principale est de supprimer le contenu entre parenthèses d'expression régulière et de le placer dans l'élément de remplacement pour remplacer la chaîne d'origine.

• Preg_replace() doit être utilisé avant d'utiliser ce modèle de correspondance.

preg_replace mixte (correspondance $regular mixte, remplacement $replacement mixte, chaîne de recherche $ mixte)

• La fonction de preg_replace : utiliser $ Le régulier le terme correspondant est trouvé et la variable de chaîne de recherche $ est trouvée. Utilisez ensuite la variable $replacement pour la remplacer.

Avant l'explication formelle, passons en revue les connaissances précédentes. Nous mettons délibérément des parenthèses autour de chaque atome à faire correspondre :

<?php
//加上了括号
$pattern = '/(\d+)([a-z]+)(\d+)/';
$string = '987abc321';
if (preg_match($pattern, $string, $match)) {
    echo '匹配到了，结果为：';
    var_dump($match);
} else {
    echo '没有匹配到';
}
?>

Regardons le résultat à droite.

C'est à ce moment-là que nous parlions auparavant des parenthèses : il y a des parenthèses en dehors du contenu correspondant. Le contenu entre parenthèses sera également placé dans les éléments du tableau. Comme le montre l'image : 987, abc, 321.

Regardons ensuite le modèle e dans l'expression régulière :

<?php
$string = "{April 15, 2003}";
//'w'匹配字母，数字和下划线，'d'匹配0-99数字，'+'元字符规定其前导字符必须在目标对象中连续出现一次或多次
$pattern = "/{(\w+) (\d+), (\d+)}/i";
$replacement = "$2";
//字符串被替换为与第 n 个被捕获的括号内的子模式所匹配的文本
echo preg_replace($pattern, $replacement, $string);
?>

Observez le résultat à droite

Conclusion :

Dans l'exemple ci-dessus, $2 pointe vers le premier (d+) représenté par l'expression régulière. Cela équivaut à en retirer 15 à nouveau

Lors du remplacement, j'écris 2$. Les éléments correspondants sont supprimés et utilisés pour remplacer à nouveau les résultats correspondants.

7. U contrôle du mode gourmand

Les expressions régulières sont gourmandes par défaut, c'est-à-dire qu'elles correspondent autant que possible.

Regardons à quel point l'expression régulière est gourmande :

<?php
$pattern = '/<div>.*<\/div>/';
$string = "<div>你好</div><div>我是</div>";
if (preg_match($pattern, $string, $match)) {
    echo '匹配到了，结果为：';
    var_dump($match);
} else {
    echo '没有匹配到';
}
?>

Jetons un coup d'œil aux résultats et obtenons la conclusion suivante. Il correspond directement de "

Bonjour" à "Je suis

". Une correspondance maximale a été réalisée.

Pour le même morceau de code, ajoutons un U majuscule et voyons l'effet :

<?php
$pattern = '/<div>.*<\/div>/U';
$string = "<div>你好</div><div>我是</div>";
if (preg_match($pattern, $string, $match)) {
    echo '匹配到了，结果为：';
    var_dump($match);
} else {
    echo '没有匹配到';
}
?>

Observons le résultat :

Nous avons constaté que seule la correspondance est sortie :

<div>Bonjour</div>

De cette façon, le caractère gourmand de régularité est annulé. Laissez-le trouver la correspondance la plus proche et c'est OK.

8. A Correspond à

à partir du début de la chaîne cible Ce modèle est similaire à l'effet ^ (circonflexe) dans les métacaractères. .

<?php
$pattern = '/this/A';
$string = 'hello this is a ';
//$string1 = 'this is a ';
if (preg_match($pattern, $string, $match)) {
    echo '匹配到了，结果为：';
    var_dump($match);
} else {
    echo '没有匹配到';
}
?>

Conclusion :

Si $string ne peut pas être mis en correspondance lors de l'ajout du modificateur de mode A, il peut être mis en correspondance sans l'ajouter

Si le modificateur de mode A est ajouté, $string1 peut être mis en correspondance, car il doit être mis en correspondance depuis le début

D End$ Pas de chariot. le retour est autorisé après

Si ce modificateur est défini, le métacaractère dollar dans le modèle ne correspondra qu'à la fin de la chaîne cible. Sans cette option, le signe dollar correspondra également avant le dernier caractère s'il s'agit d'un caractère de nouvelle ligne.

<?php
$pattern = '/\w+this$/';
 //$pattern1 = '/\w+this$/D';
$string = "hellothis ";
 if (preg_match($pattern, $string, $match))
{ echo '匹配到了，结果为：'; var_dump($match); }
else
{ echo '没有匹配到'; }
?>

Le résultat est affiché à droite

Conclusion :

1 Par exemple, lorsque le motif correspond à $string, il y a un retour après la chaîne this. de $string car. Il peut également correspondre avec succès sans ajouter le caractère correspondant D

2 Par exemple, lorsque le motif correspond à $string, D est ajouté. Il y a un espace après la chaîne this dans $string et la correspondance échoue.