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 | 模式中的字符將同時(shí)匹配大小寫字母. |
| m | 字符串視為多行 |
| s | 將字符串視為單行,換行符作為普通字符. |
| x | 將模式中的空白忽略. |
| A | 強(qiáng)制僅從目標(biāo)字符串的開頭開始匹配. |
| D | 模式中的美元元字符僅匹配目標(biāo)字符串的結(jié)尾. |
| 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 //在后面加上了一個(gè)i
$pattern = '/ABC/i';
$string = '8988abc12313';
$string1 = '11111ABC2222';
if(preg_match($pattern, $string, $matches)){
echo '匹配到了，結(jié)果為：';
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是一個(gè)不錯(cuò)的字符表示
怎么辦呢，其實(shí)需要不斷奮進(jìn)";
if (preg_match($pattern, $string, $matches)) {
echo '匹配到了，結(jié)果為：';
var_dump($matches);
} else {
echo '沒有匹配到';
}
?>Pour le deuxième match, Essayons d'ajouter m :
<?php
$pattern = '/^a\d+/m';
$string = "我的未來在自己手中我需要不斷的努力
a9是一個(gè)不錯(cuò)的字符表示
怎么辦呢，其實(shí)需要不斷奮進(jìn)";
if (preg_match($pattern, $string, $matches)) {
echo '匹配到了，結(jié)果為：';
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 '匹配到了，結(jié)果為：';
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 '匹配到了，結(jié)果為：';
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 = '學(xué)英語要從abc開始';
if (preg_match($pattern, $string, $matches)) {
echo '匹配到了，結(jié)果為：';
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
//重點(diǎn)觀察這一行
$pattern = '/a b c #我來寫一個(gè)注釋
/x';
$string = '學(xué)英語要從abc開始';
if (preg_match($pattern, $string, $matches)) {
echo '匹配到了，結(jié)果為：';
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
//加上了括號(hào)
$pattern = '/(\d+)([a-z]+)(\d+)/';
$string = '987abc321';
if (preg_match($pattern, $string, $match)) {
echo '匹配到了，結(jié)果為：';
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'匹配字母，數(shù)字和下劃線，'d'匹配0-99數(shù)字，'+'元字符規(guī)定其前導(dǎo)字符必須在目標(biāo)對(duì)象中連續(xù)出現(xiàn)一次或多次
$pattern = "/{(\w+) (\d+), (\d+)}/i";
$replacement = "$2";
//字符串被替換為與第 n 個(gè)被捕獲的括號(hào)內(nèi)的子模式所匹配的文本
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 '匹配到了，結(jié)果為：';
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 '匹配到了，結(jié)果為：';
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 '匹配到了，結(jié)果為：';
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 '匹配到了，結(jié)果為：';
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.
