Modificateurs de modèle dans les expressions régulières php
Nous avons terminé l'introduction à l'expression des expressions régulières à 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 motifs couramment utilisés sont :
| 模式匹配符 | 功能 |
|---|---|
| i | 模式中的字符将同时匹配大小写字母. |
| m | 字符串视为多行 |
| s | 将字符串视为单行,换行符作为普通字符. |
| x | 将模式中的空白忽略. |
| A | 强制仅从目标字符串的开头开始匹配. |
| D | 模式中的美元元字符仅匹配目标字符串的结尾. |
| U | 匹配最近的字符串. |
est la suivante :
/ Expression régulière/Caractère de correspondance de modèle Le caractère de correspondance de modèle
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 correspondances de modèles.
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, $string et $string1 ont tous deux été mis en correspondance avec succès. Par conséquent, après avoir ajouté i à la fin, la casse du contenu correspondant peut être ignorée.
m est traité comme plusieurs lignes
Lors de la correspondance avec des expressions régulières, la chaîne cible à faire correspondre est généralement traitée comme une seule 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 :
Oh ouais ! Le match a été réussi. /^ad+/ Le contenu correspondant est a9, qui doit être au début de la ligne. La deuxième ligne correspond également avec succès.
s est reconnu comme une ligne
Si ce modificateur est défini, le métacaractère point (.) dans le motif correspond à tous les caractères, y compris 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 '没有匹配到';
}
?>Le résultat est le suivant, Match 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 pattern matcher a été ajouté. Parce que, après avoir ajouté . (point), il peut correspondre à tous les caractères.
x Ignorer les caractères d'espacement
1. Si ce modificateur est défini, tous les caractères d'espacement du motif seront 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 !
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.
e Trouvez l'élément correspondant et remplacez-le
e motif 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 (match régulier $ mixte, remplacement $ mixte, chaîne de recherche $ mixte)
La fonction de preg_replace : utilisez l'élément correspondant $regular pour trouver la variable de chaîne $search. 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 '没有匹配到';
}
?>Jetons un coup d'œil Résultat :
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 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);
?>Regardons les résultats de l'exécution :
Conclusion :
Dans l'exemple ci-dessus, $2 pointe vers le premier (d+) représenté par l'expression régulière. C'est l'équivalent d'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.
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.
Ajoutons un U majuscule au même morceau de code 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 '没有匹配到';
}
?>
Nous avons constaté que seule la correspondance est sortie :
<div>你好</div>
comme ça, annulant les caractères gourmands de la régularité. Laissez-le trouver la correspondance la plus proche et c'est OK.
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 :
1. 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
2. Si A est ajouté lorsque en utilisant le modificateur de motif, $string1 peut être mis en correspondance, car il doit commencer à correspondre depuis le début
D Il n'y a pas de retour chariot
après la fin. du symbole $.Si ce modificateur est défini, les métacaractères dollar dans le modèle ne correspondent 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($pattern1, $string, $match)) {
echo '匹配到了，结果为：';
var_dump($match);
}else {
echo '没有匹配到';
}
?>Conclusion :
1. Par exemple, lorsque le modèle correspond à $string, il y a un retour chariot après la chaîne this de $string. 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.
