Métacaractères d'expressions régulières et règles de correspondance

Métacaractères

Métacaractères                                                                                                                                                                                                                                                                         fois ou un nombre quelconque de caractères précédents. <<> + correspondant à un caractère devant ou plus Une approche plus standard serait de compter les points comme des atomes. Correspond à tous les caractères sauf n

|                  ou. Remarque : Il a la priorité la plus basse.

<^>^ La chaîne après la rune doit commencer $ doit se terminer à la fin du caractère

Bordure du mot B

Bordure sans bordure B

<{> {m} l'a et ne peut apparaître que

{n, m} Limite

<(> () Changer la priorité ou traiter une chaîne dans son ensemble. Les données correspondantes peuvent. également être utilisé pour l'utiliser

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

correspond avec succès, prouvant le + dans d+. d correspond aux nombres et + correspond au caractère précédent au moins une fois.

* Correspond à 0 ou à n'importe quel nombre de caractères précédents

<?php
$zz = '/\w*/';
$string = "!@!@!!@#@!$@#!";
//待会儿再试试中间没有0-9的情况
//$string1 = "!@#!@#!abcABC#@#!";
if(preg_match($zz, $string, $matches)){
    echo '匹配到了，结果为：';
    var_dump($matches);
}else{
    echo '没有匹配到';
}
?>

montre 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 abccd ou abbcd. Cependant, lorsque $string1 et $string2 correspondent, les résultats correspondants sont abc et bcd

2 Implémenté ou correspondant, 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 '没有匹配到';
}
?>

Le résultat est le suivant :

correspond, le résultat est :

tableau (taille=2)

0 => chaîne 'abccd' (longueur = 5)

1 => chaîne 'c' (longueur = 1)

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

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

3) et $string2 ne commence pas par le caractère après ^

La signification de cette traduction régulière est la suivante : commencez par "être 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 :

$string1 correspond avec succès, mais $string2 correspond sans succès. Le caractère avant

$ est d+, suivi des efforts chinois.

Par conséquent, le match est tout cela. 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 que la limite du mot a été atteinte

la limite du mot b signifie qu'elle doit être au début ou à la fin.
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 :

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

Lorsque $string1 correspond, cet espace est la limite

Lorsque $string2 correspond, thisis est la limite

Lorsque $string3 correspond, thisisaapple atteint la fin de. l'expression régulière entière. Il en va de même pour les limites. Le match est donc réussi.

Expérimentons avec des limites autres que les 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, 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 stipulé que 0-9 ne peut apparaître que 3 fois, plus une fois de moins Pas même une fois.

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

Règles de correspondance

Correspondance de modèles de base

Tout commence par les bases. Les modèles sont les éléments les plus fondamentaux des expressions régulières. Ils constituent un ensemble de caractères qui décrivent les caractéristiques d'une chaîne. Les modèles peuvent être simples, constitués de chaînes ordinaires, ou très complexes, utilisant souvent des caractères spéciaux pour représenter une plage de caractères, des récurrences ou pour représenter le contexte. Par exemple :

^once

Ce modèle contient un caractère spécial ^, ce qui signifie que le modèle ne correspond qu'aux chaînes commençant par une fois. Par exemple, ce modèle correspond à la chaîne « il était une fois » mais ne correspond pas à « Il était une fois un homme de New York ». Tout comme le symbole ^ indique le début, le symbole $ est utilisé pour faire correspondre les chaînes qui se terminent par un modèle donné.

bucket$

Ce modèle correspond à "Qui a gardé tout cet argent dans un seau" mais ne correspond pas aux "seaux". Lorsque les caractères ^ et $ sont utilisés ensemble, ils représentent une correspondance exacte (les chaînes sont identiques aux modèles). Par exemple :

^bucket$

Correspond uniquement à la chaîne "bucket". Si un modèle n'inclut pas ^ et $, il correspond à n'importe quelle chaîne contenant le modèle. Par exemple : motif

une fois

avec une chaîne

Il était une fois un un homme de New York
Qui gardait tout son argent dans un seau.

est un match.

Les lettres (o-n-c-e) de ce motif sont des caractères littéraux, c'est-à-dire qu'elles représentent les lettres elles-mêmes, tout comme les chiffres. D'autres caractères un peu plus complexes, comme la ponctuation et les caractères blancs (espaces, tabulations, etc.), nécessitent des séquences d'échappement. Toutes les séquences d'échappement commencent par une barre oblique inverse (). La séquence d'échappement pour le caractère de tabulation est : t. Donc, si nous voulons détecter si une chaîne commence par un caractère de tabulation, nous pouvons utiliser ce modèle :

^t

De même, utilisez n pour représenter " Nouvelle ligne", r signifie retour chariot. D'autres symboles spéciaux peuvent être utilisés avec une barre oblique inverse devant. Par exemple, la barre oblique inverse elle-même est représentée par \, le point est représenté par ., et ainsi de suite.

Cluster de caractères

Dans les programmes INTERNET, les expressions régulières sont généralement utilisées pour vérifier les entrées de l'utilisateur. Lorsqu'un utilisateur soumet un FORMULAIRE, il ne suffit pas d'utiliser des caractères littéraux ordinaires pour déterminer si le numéro de téléphone, l'adresse, l'adresse e-mail, le numéro de carte de crédit, etc. saisis sont valides.

Nous devons donc utiliser une manière plus libre de décrire le modèle que nous voulons, à savoir les groupes de caractères. Pour créer un cluster représentant toutes les voyelles, placez toutes les voyelles entre crochets :

[AaEeIiOoUu]

Ce modèle correspond à n'importe quel caractère de voyelle, mais ne peut représenter que un personnage. Utilisez des traits d'union pour représenter une plage de caractères, tels que :

[a-z] // Correspond à toutes les lettres minuscules
[A-Z] // Correspond à toutes les lettres majuscules
[a- zA- Z] //Faire correspondre toutes les lettres
[0-9] //Faire correspondre tous les chiffres
[0-9.-] //Faire correspondre tous les chiffres, points et signes moins
[ frtn ] //Faire correspondre tous caractères blancs

Encore une fois, ceux-ci ne représentent qu'un seul caractère, ce qui est très important. Si vous souhaitez faire correspondre une chaîne composée d'une lettre minuscule et d'un chiffre, telle que "z2", "t6" ou "g7", mais pas "ab2", "r2d3" ou "b52", utilisez ce modèle :

^[a-z][0-9]$

Bien que [a-z] représente une plage de 26 lettres, ici il ne peut être utilisé qu'avec la première chaîne correspond où les caractères sont des lettres minuscules.

Il a été mentionné plus tôt que ^ représente le début d'une chaîne, mais il a aussi une autre signification. Lorsque ^ est utilisé entre crochets, cela signifie « ne pas » ou « exclure » et est souvent utilisé pour éliminer un certain caractère. En reprenant l'exemple précédent, nous exigeons que le premier caractère ne puisse pas être un nombre :

^[^0-9][0-9]$

Ce modèle correspond à "&5", "g7" et "-2", mais ne correspond pas à "12" et "66". Voici quelques exemples d'exclusion de caractères spécifiques :

[^a-z] //Tous les caractères sauf les lettres minuscules
[^\/^] //Tous les caractères sauf ()(/)(^)
[^" '] //Tous caractères sauf les guillemets doubles (") et les guillemets simples (')

Les caractères spéciaux "." (point, point) sont utilisés dans les expressions régulières Représente tous les caractères sauf "nouvelle ligne". Ainsi, le modèle "^.5$" correspond à toute chaîne de deux caractères se terminant par le chiffre 5 et commençant par un autre caractère autre que "nouvelle ligne". Le modèle "." peut correspondre à n'importe quelle chaîne, à l'exception des chaînes vides et des chaînes contenant uniquement une "nouvelle ligne".

Les expressions régulières de PHP ont des groupes de caractères communs intégrés, la liste est la suivante :

Groupes de caractères                                                                     🎜>[[:alpha:]] N'importe quelle lettre

[[:digit:]] N'importe quel chiffre

[[:alnum:]] N'importe quelle lettre et chiffre
[[:space:]] tous les caractères d'espacement

[[:upper:]] toutes les lettres majuscules

[[:lower:]] toutes les lettres minuscules

[[:punct:]] Toute ponctuation mark

[[:xdigit:]] Tout nombre hexadécimal, équivalent à [0-9a-fA-F]

Identifiez les doublons

Vous savez déjà comment faire correspondre une lettre ou un chiffre, mais plus encore. Dans de nombreux cas, vous souhaiterez peut-être faire correspondre un mot ou un groupe de chiffres. Un mot est composé de plusieurs lettres et un groupe de nombres est constitué de plusieurs nombres singuliers. Les accolades ({}) qui suivent un caractère ou un groupe de caractères sont utilisées pour déterminer le nombre de fois que le contenu précédent est répété. groupe de caractères

Description

^[a-zA-Z_]$ Toutes les lettres et traits de soulignement

^[[:alpha:]]{3}$ Tous les mots de 3 lettres

^a$ Lettre a
^a{4} $ aaaa

^a{2,4}$ aa,aaa ou aaaa

^a{1,3}$ a,aa ou aaa

^a{2 ,}$ Chaînes contenant plus de deux a

^a{2,} Tels que : aardvark et aaab, mais apple ne fonctionne pas

a{2,} Tels que : baad et aaa, Mais pas Nantucket

t{2} deux caractères de tabulation

.{2} les deux caractères

Ces exemples décrivent trois utilisations différentes des accolades. Un nombre, {x} signifie « le caractère ou le groupe de caractères précédent apparaît seulement x fois » ; un nombre plus une virgule, {x,} signifie « le contenu précédent apparaît x fois ou plus » ; ,y} signifie "le contenu précédent apparaît au moins x fois, mais pas plus de y fois". Nous pouvons étendre le modèle à plus de mots ou de chiffres :

^[a-zA-Z0-9_]{1,}$ //Tous contenant plus d'une lettre, un chiffre ou une chaîne de soulignement
^[1-9]{1,}$ //Tous les nombres positifs
^-{0,1}[0-9]{1,}$ //Tous les nombres entiers
^[-]?[ 0-9]+.?[0-9]+$ //Tous les nombres à virgule flottante

Le dernier exemple n'est pas facile à comprendre, n'est-ce pas ? Regardez-le de cette façon : tout commence par un signe moins facultatif ([-]?) (^), suivi d'un ou plusieurs chiffres ([0-9]+) et suivi d'un point décimal (.) 1 ou plus de chiffres ([0-9]+) et non suivi de quoi que ce soit d'autre ($). Ci-dessous, vous découvrirez les méthodes les plus simples que vous pouvez utiliser.

Les caractères spéciaux "?" sont égaux à {0,1}, ils représentent tous deux : "0 ou 1 contenu précédent" ou "le contenu précédent est facultatif". Ainsi, l'exemple actuel peut être simplifié en :

^-?[0-9]{1,}.?[0-9]{1,}$

Les caractères spéciaux "*" sont égaux à {0,}, ils représentent tous deux "0 ou plusieurs contenus précédents". Enfin, le caractère "+" est égal à {1,}, ce qui signifie "1 ou plusieurs contenus précédents", donc les 4 exemples ci-dessus peuvent s'écrire comme :

^[a-zA - Z0-9_]+$ //Toutes les chaînes contenant plus d'une lettre, un chiffre ou un trait de soulignement
^[0-9]+$ //Tous les nombres positifs
^-?[0-9] +$ // Tous les entiers
^-?[0-9]*.?[0-9]*$ //Tous les nombres à virgule flottante

Bien sûr, cela ne fonctionne pas Réduit techniquement le complexité des expressions régulières, mais les rend plus faciles à lire.