Expressions régulières pour débutants en PHP

1.Délimiteur

Quel est le délimiteur ?

Le soi-disant délimiteur consiste à définir une limite, et le contenu doit être écrit à l'intérieur de cette limite

// C'est le délimiteur dans les expressions régulières. L'expression doit être écrite au milieu. de // 🎜>

c'est-à-dire /a-z/

2 Quels sont les délimiteurs de

?

Tout caractère autre que les lettres, les chiffres et les barres obliques inverses peut être délimité par des symboles, tels que |, //, {}, !!, etc., mais il convient de noter que s'il n'y a pas spécial Si nécessaire, nous utilisons tous les symboles délimiteurs comme expressions régulières

3.

La composition des expressions régulières

Une expression régulière standard se compose de 3 parties :

(1). Séparateur

(2). Expression

(3). Modificateur

Séparateur  : Le délimiteur est utilisé pour envelopper. l'expression, qui peut être n'importe quel caractère à l'exception des caractères spéciaux. Le délimiteur couramment utilisé "/"

Expression : L'expression est composée de quelques caractères spéciaux (métacaractères) et de caractères non spéciaux ( caractères de texte) sous la forme

Modificateur : les modificateurs dans les expressions régulières PHP peuvent modifier de nombreuses caractéristiques des expressions régulières, rendant les expressions régulières plus adaptées à vos besoins (Remarque : les modificateurs sont sensibles à la casse, ce qui signifie "e" n'est pas égal à "E")

Quels sont les modificateurs dans les expressions régulières ?

Types et introduction des modificateurs d'expressions régulières PHP :

◆i : Si "i" est ajouté au modificateur, l'expression régulière annulera la sensibilité à la casse, c'est-à-dire "a" et "A" sont identiques.

◆m : Le début régulier "^" et la fin "$" par défaut concernent uniquement les chaînes normales. Si "m" est ajouté au modificateur, alors le début et la fin feront référence à chaque ligne de la chaîne. : Le début de chaque ligne est "^" et la fin est "$".

◆s : Si "s" est ajouté au modificateur, le "." par défaut signifie que tout caractère à l'exception du caractère de nouvelle ligne deviendra n'importe quel caractère, y compris le caractère de nouvelle ligne !

◆x : Si ce modificateur est ajouté, les caractères d'espacement dans l'expression seront ignorés à moins qu'ils n'aient été échappés.

◆e : Ce modificateur n'est utile qu'en remplacement, ce qui signifie qu'il est utilisé comme code PHP en remplacement.

◆A : Si ce modificateur est utilisé, l'expression doit être le début de la chaîne correspondante. Par exemple, "/a/A" correspond à "abcd".

◆E : Contrairement à "m", si ce modificateur est utilisé, alors "$" correspondra à la fin absolue de la chaîne, pas avant le caractère de nouvelle ligne. Ce mode est activé par défaut.

◆U : Il a la même fonction que le point d'interrogation, et sert à définir le "mode gourmand".

Atomes dans les expressions régulières

Les atomes sont les plus petites unités dans les expressions régulières. Pour parler franchement, les atomes sont le contenu qui doit être. correspondait. Une expression régulière valide doit contenir au moins un atome

Explication : les espaces, les retours chariot, les sauts de ligne, 0-9, A-Za-z, le chinois, les signes de ponctuation et les symboles spéciaux que nous voyons sont tous des atomes. Avant de faire l'exemple atomique, expliquons d'abord une fonction, preg_match

Syntaxe : int preg_match ( string $regular, string $string[, array &$result] )

Ce qui précède est preg_match Plusieurs Paramètres principaux couramment utilisés. Je n'ai pas énuméré plusieurs autres paramètres ci-dessus. Parce que les deux autres paramètres sont trop rares.

Prouvons-le par des expériences :

<?php
	header("Content-type: text/html; charset=utf-8");//设置编码
	$zz = '/a/';

	$string = 'ddfdjjvai2jfvkwkfi24';

	if(preg_match($zz, $string, $matches)){
	    echo '匹配到了，结果为：';
	    var_dump($matches);
	}else{
	    echo '没有匹配到';
	}
?>

Remarque : $zz est une règle d'expression régulière $string est une chaîne Cet exemple permet de déterminer si cette chaîne satisfait l'expression régulière correspondante si la formule. est satisfait, le résultat sera affiché. S'il n'est pas satisfait, les informations seront affichées

Atomes spécialement identifiés

.

d Correspondances 0-9

<?php
	header("Content-type: text/html; charset=utf-8");//设置编码

	//   \d的用法

	$zz = '/\d/';
	$string = '我爱喝9你爱不爱喝';

	if(preg_match($zz, $string, $matches)){
	    echo '匹配到了，结果为：';
	    var_dump($matches);
	}else{
	    echo '没有匹配到';
	}
?>

D Tous les caractères sauf 0-9

<?php
    //  \D   匹配出0-9以外的所有字符
	$zz = '/\D/';
	$string = '12124323453453';

	if(preg_match($zz, $string, $matches)){
	    echo '匹配到了，结果为：';
	    var_dump($matches);
	}else{
	    echo '没有匹配到';
	}
?>

w a-z A-Z0-9_

<?php 
	//  \w   匹配a-zA-Z0-9 还有下划线

	$zz = '/\w/';  
	$string = '新中_国万岁呀万岁';
	if(preg_match($zz, $string, $matches)){
	    echo '匹配到了，结果为：';
	    var_dump($matches);
	}else{
	    echo '没有匹配到';
	}
?>

W L'opposé de w

<?php
    //\W  除a-zA-Z0-9_ 以外的所有字符

	$zz = '/\W/';  
	$string = '......';

	if(preg_match($zz, $string, $matches)){
	    echo '匹配到了，结果为：';
	    var_dump($matches);
	}else{
	    echo '没有匹配到';
	}
?>

s correspond à tous les caractères d'espacement

<?php
        //  \s  匹配所有的空白字符
	$zz = '/\s/';
	$string = "中国万
	岁";

	if(preg_match($zz, $string, $matches)){
	    echo '匹配到了，结果为：';
	    var_dump($matches);
	}else{
	    echo '没有匹配到';
	}
?>

S caractères non vides

<?php
	//  \S  匹配非空字符
	$zz = '/\S/';
	$string = "        
          a       ";

	if(preg_match($zz, $string, $matches)){
	    echo '匹配到了，结果为：';
	    var_dump($matches);
	}else{
	    echo '没有匹配到';
	}
?>

[] Plage spécifiée d'atomes

<?php
	//  [] 指定原子范围
	$zz = '/[0-5]\w+/';
	$string = '6a';
	$string1 = '1C';
	if(preg_match($zz, $string, $matches)){
	    echo '匹配到了，结果为：';
	    var_dump($matches);
	}else{
	    echo '没有匹配到';
	}

?>

Il est difficile de se souvenir de ces w s W S. Il y a donc un équivalent ci-dessous, et l'effet est le même que s w etc.

+ correspond au caractère précédent au moins une fois

<?php
	header("Content-type: text/html; charset=utf-8");//设置编码

	$zz = '/\d+/';

	$string = "迪奥和奥迪250都是我最爱";
	//待会儿再试试中间没有0-9的情况
	//$string = "迪奥和奥迪都是我最爱";

	if(preg_match($zz, $string, $matches)){
	    echo '匹配到了，结果为：';
	    var_dump($matches);
	}else{
	    echo '没有匹配到';
	}
?>

* Correspond à 0 fois 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 '没有匹配到';
	}
?>

Le personnage 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 '没有匹配到';
	}
?>

(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 '没有匹配到';
	}
?>

<. 🎜>| (barre verticale), ou la priorité la plus basse

<?php
        $zz = '/abc|bcd/';
	$string1 = "abccd";
	$string2 = "ggggbcd";

	if (preg_match($zz, $string1, $matches)) {
	    echo '匹配到了，结果为：';
	    var_dump($matches);
	} else {
	    echo '没有匹配到';
	}
?>

À travers l'exemple ci-dessus, nous pouvons voir :

1. devait correspondre à 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

^ (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 correspond avec succès, $string2 ne correspond pas avec succès

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

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

<. 🎜>4. La traduction de cette expression régulière signifie : commencer par "Li Wenkai est 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 '没有匹配到';
	}
?>

Remarque :

$string1 correspond avec succès, et la correspondance $string2 échoue. Le caractère avant

$ est d+, suivi des efforts chinois.

Par conséquent, le match est tout cela. d fait référence au type entier de 0 à 9, et le signe + représente au moins un 0-9

{m} qui ne peut apparaître que m fois

<?php
	$zz = '/喝\d{1,3}酒/';
	$string1 = "喝9酒";
	//$string2 = "喝988酒";
	if (preg_match($zz, $string1, $matches)) {
	    echo '匹配到了，结果为：';
	    var_dump($matches);
	} else {
	    echo '没有匹配到';
	}
?>

Remarque :

Dans l'exemple ci-dessus, d{1,3}, j'ai précisé que 0-9 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 '没有匹配到';
	}
?>

Dans l'exemple ci-dessus, d{2,}, je stipule que le 0-9 après la boisson doit apparaître 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 est une correspondance réussie

Compétences en expression régulière

Écrivez un peu et testez un peu

Parce que nous avons besoin d'une régularisation constante, utilisez preg_match Vérifiez si la comparaison est réussie. Si cela réussit, écrivons le point suivant. Jusqu'à ce que vous ayez fini d'écrire et que tous les matchs soient réussis !

Écrivons ensuite un exemple intégré d'expression régulière pour le courrier électronique

Première étape : répertorier tous les formats de courrier électronique

liwenkai@phpxy.com

iwenkai@ corp.baidu.cm

iwenkai@126.com

_w_k@xxx.com

2345@qq.com

Faites d'abord correspondre le personnage w+ avant @ (car c'est 0-9A-Za-z_)

Le deuxième est suivi d'un caractère @

Le troisième s'écrit [a-zA-Z0-9 -]+ Parce que les principaux noms de domaine tels que qq et 126 ne peuvent pas avoir

souligné

corp.baidu ou 126. Habituellement, le suffixe de l'e-mail est comme ceci. Nous pouvons donc l'écrire comme : ([a-zA-Z0-9-]+.){1,2}

Ce qui précède est d'échapper pour qu'il ait sa propre signification. Les parenthèses doivent être répétées au moins une fois et au maximum deux fois.

Suivez simplement com|cn|org|gov.cn|net|edu.cn et ainsi de suite

<?php
	header("Content-type: text/html; charset=utf-8");//设置编码

	$zz = '/\w+@([a-zA-Z0-9-]+.){1,2}(com|cn|org|gov.cn|net|edu.cn)/';

	$string1 = "k53981@qq.com";


	if (preg_match($zz, $string1, $matches)) {
	    echo '匹配到了，结果为：';
	    var_dump($matches);
	} else {
	    echo '没有匹配到';
	}

?>