Explication graphique et textuelle détaillée de la correspondance IP régulière

Cette fois, je vais vous apporter une explication graphique et textuelle détaillée de l'IP correspondante régulière. Quelles sont les précautions pour l'IP correspondante régulière Voici des cas pratiques, jetons un coup d'oeil.

Ici, je vais vous donner une explication détaillée d'une expression régulière qui correspond à une adresse IP

Les connaissances sur les expressions régulières seront mentionnées dans l'explication détaillée.

Avant de vous expliquer, permettez-moi d'abord de vous présenter les règles de génération d'adresses IP.

L'adresse IP est composée d'un nombre binaire de 32 chiffres converti en quatre chaînes décimales .

Comment convertir ? Expliqué ci-dessous :

Binaire : 1111111111111111111111111111111

Divisé en quatre parties : 11111111.11111111.11111111.11111111

Conversion : +2^6+2^5+2^4+ 2^3+2^2+2^1+2^0=255

Convertir en plage décimale : 0~255.0~255.0~255.0~255

C'est la plage de l'IP adresse.

En fonction des règles et de la plage de génération d'IP, nous pouvons utiliser des expressions régulières pour faire correspondre l'adresse IP, mais comment faire la correspondance ? Chacun sa méthode, je vais vous expliquer ici mon approche.

Sur la base des règles de chaîne des adresses IP, j'ai divisé l'expression correspondant aux adresses IP en deux parties à considérer.

La première partie : Match 3 0~255 (notez le point à la fin)

La deuxième partie : Match le dernier numéro 0~255

En d'autres termes , Faites d'abord correspondre la chaîne 0 ~ 255 (notez le point à la fin), puis répétez la correspondance 3 fois, puis faites correspondre la dernière partie numérique 0 ~ 255. C'est mon idée de faire correspondre les adresses IP.

Tout d'abord, je tiens à mentionner qu'il n'y a aucun moyen d'effectuer des opérations numériques avec des expressions régulières, nous ne pouvons donc pas utiliser d'opérations numériques pour filtrer la plage numérique de l'IP. Puisqu'il n'existe aucun moyen de filtrer la plage numérique d'IP à l'aide d'opérations numériques, quelles autres méthodes devrions-nous utiliser pour filtrer cette plage numérique ? Mon idée est de discuter en groupes, puis de fusionner ces groupes pour former la gamme numérique de l'IP.

① En supposant que le numéro IP est dans le chiffre des centaines, puis en fonction de la plage de numéros IP, nous pouvons dessiner les situations suivantes. En supposant que le premier nombre est 1, alors la plage de ce nombre est 1[0-9][0-9]. Cela ne devrait pas être difficile à comprendre, donc je ne l’expliquerai pas.

② En supposant que le premier nombre soit 2, alors selon les règles de plage des numéros IP, il y a deux situations ici. Pourquoi ? Pensez-y, le plus grand nombre est 255. Lorsque le chiffre des dizaines est 5, le chiffre unique ne peut être que 5 au maximum, n'est-ce pas ? Et lorsque le chiffre des dizaines est compris entre 0 et 4, le chiffre des unités peut être n’importe quel nombre, n’est-ce pas ?

Donc, les deux situations ici sont :

A, 2[0-4][0-9]

B, 25[0-5]

③. Après avoir analysé la situation des centaines, l'étape suivante est la situation des dizaines. S'il s'agit d'un chiffre des dizaines, alors le premier nombre devant le chiffre des dizaines ne peut pas être zéro, n'est-ce pas ?

La situation à dix chiffres peut donc être : [1-9][0-9]

④ Le reste est la situation à un chiffre, tout le monde devrait. arriver facilement à la conclusion, qui est : [0-9].

Après avoir analysé les quatre situations, nous avons abouti au regroupement de plages de numéros IP comme suit :

　　　　1[0-9][0-9]

　　　2[0 - 4][0-9]

　　　　　　　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　　

Comment exprimer le regroupement ci-dessus à l'aide d'expressions régulières ? C'est très simple, utilisez simplement le symbole régulier ou | et le symbole de regroupement (), donc l'expression régulière de regroupement ci-dessus est :

　　　　　(1[0-9][0-9])|(2[0-4][0-9])|(25[0-5])|([1-9][0-9])|([0-9])

À ce stade, l'expression régulière pour la plage de nombres correspondante a été écrite, donc selon mes idées précédentes : Partie 1 : Match 3 0~255 (Faites attention au point à la fin) <.>

La deuxième partie : Faire correspondre le dernier nombre 0~255

Faisons correspondre la première partie de l'adresse IP. L'expression régulière est la suivante :

　　　　 (1[0-9][0-9]\.)|(2[0-4][0-9]\.)|(25[0-5]\.)|([1-9][0-9]\.)|([0-9]\.)

J'ajoute. après chaque numéro Si vous atteignez un point, il correspondra à 0~255 (Faites attention au point suivant)

Alors, comment répéter le match trois fois ? C'est très simple. Il suffit de traiter ces cinq groupes dans leur ensemble et de répéter la correspondance trois fois. L'expression régulière est la suivante :

((1[0-9][0-9]\.)|(2[0-4][0-9]\.)|(25[0-5]\.)|([1-9][0-9]\.)|([0-9])\.)){3}

La première partie a été mise en correspondance, et l'étape suivante est la suivante. pour épisser la deuxième partie. Nombres. La partie numérique a été clairement écrite ci-dessus, donc je ne l'expliquerai plus. Ce qui suit est l'expression régulière complète :

((1[0-9][0-9]\.)|(2[0-4][0-9]\.)|(25[0-5]\.)|([1-9][0-9]\.)|([0-9]\.)){3}((1[0-9][0-9])|(2[0-4][0-9])|(25[0-5])|([1-9][0-9])|([0-9]))

À ce stade, l'expression régulière. pour la correspondance IP est sortie. Cependant, ce n'est pas la dernière expression régulière pour la correspondance IP. Pourquoi ? C'est très simple. L'expression régulière capturera et fera correspondre chaque groupe. L'adresse IP correspondante est divisée en autant de groupes, et le contenu de chaque groupe sera capturé par l'expression régulière. Je ne sais pas combien d'adresses IP ont été capturées ci-dessus. , haha, Alors comment supprimer le contenu groupé ? C'est très simple, utilisez ce symbole ?:

  ? : Le symbole est placé entre parenthèses (), ce qui signifie capturer le groupe mais pas le contenu de l'expression régulière. Donc, si on le met dans chaque groupe, ne supprimera-t-on pas le contenu du groupe ? Par conséquent, nous devons également ajouter ?: à chaque groupe, et l'expression régulière après l'ajout est la suivante :

(?:(?:1[0-9][0-9]\.)|(?:2[0-4][0-9]\.)|(?:25[0-5]\.)|(?:[1-9][0-9]\.)|(?:[0-9]\.)){3}(?:(?:1[0-9][0-9])|(?:2[0-4][0-9])|(?:25[0-5])|(?:[1-9][0-9])|(?:[0-9]))

Même ici, l'adresse IP ne correspond toujours pas, et nous devons toujours utiliser ^ et $ pour le limiter. Le début et la fin de la chaîne, donc l'expression régulière finale pour faire correspondre les adresses IP est :

^(?:(?:1[0-9][0-9]\.)|(?:2[0-4][0-9]\.)|(?:25[0-5]\.)|(?:[1-9][0-9]\.)|(?:[0-9]\.)){3}(?:(?:1[0-9][0-9])|(?:2[0-4][0-9])|(?:25[0-5])|(?:[1-9][0-9])|(?:[0-9]))$

C'est mon expression régulière la plus complète pour faire correspondre les adresses IP. et voir s'il y a des bugs. J'espère également que les lecteurs feront part de leurs inquiétudes afin de ne pas induire les autres lecteurs en erreur.

Les crochets () dans les expressions régulières ci-dessus apparaissent tous par paires. S'il y en a qui apparaissent par paires, veuillez les ajouter vous-même.

Voici mon test :

<?php
$pattern = &#39;/^(?:(?:2[0-4][0-9]\.)|(?:25[0-5]\.)|(?:1[0-9][0-9]\.)|(?:[1-9][0-9]\.)|(?:[0-9]\.)){3}(?:(?:2[0-5][0-5])|(?:25[0-5])|(?:1[0-9][0-9])|(?:[1-9][0-9])|(?:[0-9]))$/&#39;;
//正则匹配ip地址
$ip     = &#39;254.21.0.198&#39;;
preg_match($pattern,$ip,$out);
echo &#39;<pre class="brush:php;toolbar:false">';
print_r($out);
$ip     = '255.777.0.198';
preg_match($pattern,$ip,$out);
print_r($out);
$ip     = '07.25.8.198';
preg_match($pattern,$ip,$out);
print_r($out);
$ip     = '1207.25.8.198';
preg_match($pattern,$ip,$out);
print_r($out);
$ip     = 'qq107.25.8.198';
preg_match($pattern,$ip,$out);
print_r($out);
$ip     = '\.\.\.107.25.8.198';
preg_match($pattern,$ip,$out);
print_r($out);
$ip     = '\.\.\.  7.25.8.198';
preg_match($pattern,$ip,$out);
print_r($out);
$ip     = '107.25.8.19822vvv';
preg_match($pattern,$ip,$out);
print_r($out);
$ip     = '107.25.r8.1982';
preg_match($pattern,$ip,$out);
print_r($out);
$ip     = '107.225.8.19';
preg_match($pattern,$ip,$out);
print_r($out);
$ip     = '225.225.225.225';
preg_match($pattern,$ip,$out);
print_r($out);
$ip     = '0.0.0.0';
preg_match($pattern,$ip,$out);
print_r($out);
$ip     = '00.0.0.0';
preg_match($pattern,$ip,$out);
print_r($out);
$ip     = '0.202.1.0';
preg_match($pattern,$ip,$out);
print_r($out);
$ip     = '0.202.1.226';
preg_match($pattern,$ip,$out);
print_r($out);
$ip     = '249.202.1.0';
preg_match($pattern,$ip,$out);
print_r($out);
$s='';
for($i=0;$i<32;$i++){
  $s .= '1';
}
echo $s;
echo strlen($s);

Je pense que vous maîtrisez la méthode après avoir lu le cas présenté dans cet article. Pour des informations plus intéressantes, veuillez prêter attention aux autres articles connexes sur le sujet. php site chinois !

Lecture recommandée :

Implémentation régulière des nombres en js avec des espaces séparés tous les quatre chiffres

En PHP Explication détaillée de gourmands, non gourmands et backtracking efficaces utilisant des expressions régulières (avec code)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!