Le contenu de cet article concerne la relation régulière en PHP, qui a une certaine valeur de référence. Maintenant, je le partage avec vous. Les amis dans le besoin peuvent s'y référer

Aperçu

Aperçu

• L'expression régulière est une règle grammaticale qui décrit le résultat d'une chaîne. Il s'agit d'un modèle de formatage spécifique qui peut faire correspondre, remplacer et intercepter les chaînes correspondantes. Les langages couramment utilisés ont essentiellement des expressions régulières, telles que JavaScript, Java, etc. En fait, tant que vous comprenez l’usage régulier d’une langue, il est relativement simple d’utiliser les règles habituelles d’autres langues. Le texte se concentre principalement sur la résolution des problèmes suivants.

• Quels sont les caractères d'échappement couramment utilisés

• Que sont les qualificatifs et les localisateurs

• Que sont localisateurs de mots

• Quels sont les caractères spéciaux

• Que sont les références arrière et comment utiliser les références arrière

• Modèle de correspondance

• Comment utiliser les expressions régulières en php

• Quels aspects de php doivent utiliser des expressions régulières

• Comment effectuer une correspondance d'e-mails, d'URL, de téléphone mobile

• Comment utiliser des expressions régulières pour remplacer certains caractères dans une chaîne

• La différence entre la correspondance gourmande et la correspondance paresseuse

• Retour en arrière et regroupement solide d'expressions régulières

Quels sont les avantages et les inconvénients des expressions régulières

Résumé des connaissances de base sur les expressions régulières“$”“^”Localisateurs de lignes (^ et $) "^de""de$"Les localisateurs de lignes sont utilisés pour décrire les limites de cordes.

représente le début de la ligne. Par exemple,

représente une chaîne se terminant par de.

Délimiteur de mot

Lorsque nous recherchons un mot, par exemple si an existe dans une chaîne "gril et corps", il est évident que s'il correspond, an est définitivement OK. la chaîne "gril et body" correspond. Comment puis-je faire correspondre des mots au lieu d'une partie de mots ? À ce stade, nous pouvons être un délimiteur de mots b.

Bien sûr, il y a un B majuscule, qui signifie exactement le contraire de b. La chaîne à laquelle elle correspond ne peut pas être un mot complet, mais une partie d'autres mots ou chaînes. Comme BanB.

Sélectionnez le caractère (|) pour représenter ou.

Sélectionnez le caractère pour représenter ou. Par exemple, Aa|aA signifie Aa ou aA. Notez que la différence entre l'utilisation de "[]" et "|" est que "[]" ne peut correspondre qu'à un seul caractère, tandis que "|" peut correspondre à une chaîne de n'importe quelle longueur. Lorsque vous utilisez "[]", il est souvent utilisé avec le caractère de connexion "-", tel que [a-d], qui représente a ou b ou c ou d.

Exclure des caractères, exclure des opérations

Les expressions régulières fournissent "^" pour exclure les caractères qui ne correspondent pas, ^ est généralement placé entre []. Par exemple, [^1-5], ce caractère n'est pas un nombre compris entre 1 et 5.

Par exemple, (D+) représente un ou plusieurs D

L'opérateur point

)

Les barres obliques inverses dans les expressions ont plusieurs significations, telles que l'échappement, la spécification d'un jeu de caractères prédéfini, la définition d'assertions et l'affichage de caractères non imprimables.

Caractères d'échappement

Caractères crochets ()

Les principales fonctions des parenthèses dans les expressions régulières sont :

• Modifier la portée des qualificatifs tels que (|, *, ^)
  Par exemple, (mon|votre)bébé, s'il n'y a pas de "()", | correspondra soit à mon soit à votrebébé. Avec des parenthèses, il correspondra soit à monbébé, soit à votrebébé.

• est regroupé pour faciliter les rétro-références

Rétro-références

Les rétro-références reposent sur des sous-expressions La "mémoire" la fonction correspond à des chaînes ou des caractères consécutifs. Par exemple, (dqs)(pps)12 signifie correspondre à la chaîne dqsppsdqspps. Dans l'application PHP suivante, j'apprendrai en détail les références arrière.

Modificateur de motif

Le rôle du modificateur de motif est de définir le modèle, c'est-à-dire la manière dont l'expression régulière est interprétée. Les principaux modes en php sont les suivants :

Application d'expressions régulières en php

Correspondance de chaînes en php

Ce qu'on appelle la correspondance de chaînes, l'implication est de déterminer si une chaîne contient ou est égale à une autre chaîne. Si nous n'utilisons pas d'expressions régulières, nous pouvons utiliser de nombreuses méthodes fournies en PHP pour porter de tels jugements.

N'utilise pas de correspondance régulière

• fonction strstr
  string strstr ( string h aystack,mixedneedle [ , bool $before_needle = false ])
  

• Note 1 : h a ystack est quand ChosesPersonnagePersonnageChaîne, l'aiguille est le personnage étant recherché une chaîne. Cette fonction est sensible à la casse.

• Remarque 2 : La valeur de retour va du début à la fin de l'aiguille.

• Remarque 3 : Concernant $needle, si ce n'est pas une chaîne, il est traité comme un entier et utilisé comme numéro de séquence du caractère.

• Remarque 4 : Si before_needle est vrai, renvoie la chose précédente.

• La fonction strstr est la même que la fonction strstr, sauf qu'elle n'est pas sensible à la casse

• Fonction strpo
  int strpos ( string haystack, mixedneedle [, int $offset = 0 ] )
  Remarque 1 : Le paramètre de décalage facultatif peut être utilisé pour spécifier quel caractère de la botte de foin doit commencez à chercher à partir de. La position numérique renvoyée est relative à la position de départ de la botte de foin.

• stripos - Trouvez la position où apparaît pour la première fois dans la chaîne ( n'est pas sensible à la taille)

• strrpos - Calcule la position de la dernière occurrence de dans la chaîne cible

• strripos - Calcule la position de la chaîne spécifiée dans la chaîne cible La dernière occurrence de (insensible à la casse)

Utiliser des expressions régulières pour faire correspondre

En php, preg_math( ) et Fonction preg_match_all pour une correspondance régulière. Les prototypes de ces deux fonctions sont les suivants :

int preg_match|preg_match_all ( string $pattern , string $subject [, array &$matches [, int $flags = 0 [, int $offset = 0 ]]] )

Recherche une correspondance entre le sujet et l'expression régulière donnée par le motif
modèle : Modèle à rechercher, type chaîne.
sujet : chaîne d'entrée.
matchs : si le paramètre matches est fourni, il sera renseigné comme résultats de recherche. matches[0]serapackagecomprenantcompletcompletModèleFormePiècecorrespondanceàtextece, matches[1] contiendra le premier sous-capture Regrouper le texte correspondant, et ainsi de suite.
flags : les drapeaux peuvent être définis sur les valeurs d'indicateur suivantes : PREG_OFFSET_CAPTURE Si cet indicateur est passé, le décalage de la chaîne (par rapport à la chaîne cible) sera renvoyé pour chaque occurrence d'une correspondance. Remarque : Cela modifiera le tableau rempli dans le paramètre matches afin que chaque élément devienne une chaîne où le 0ème élément est la chaîne correspondante et le 1er élément est le décalage de la chaîne correspondante dans la chaîne cible subject .
offset : généralement, la recherche commence au début de la chaîne cible. Le paramètre facultatif offset est utilisé pour spécifier la recherche commençant à partir d'un point inconnu dans la chaîne cible (l'unité est en octets).
Valeur de retour : preg_match() renvoie le nombre de correspondances pour le modèle. Sa valeur sera 0 (pas de correspondance) ou 1 car preg_match() arrêtera la recherche après la première correspondance. preg_match_all() est différent de cela, il recherchera le sujet jusqu'à la fin. Si une erreur se produit, preg_match() renvoie FALSE.

Exemple

• Exemple 1
  Chaîne de juge" http://blog.csdn . net/hsd2012" contient csdn ?
  Solution 1 (les règles régulières ne sont pas applicables) :
  Si les règles régulières ne sont pas applicables, nous pouvons utiliser soit strstr, soit strpos. Ici, j'utiliserai la fonction strstr, codez comme suit :

$str='http://blog.csdn.net/hsd2012';function checkStr1($str,$str2)
{    return strstr1($str,$str2)?true:false;
}echo checkStr($str,'csdn');

Solution 2 : Utiliser des expressions régulières
Parce que nous avons seulement besoin de déterminer s'il existe, nous choisissons preg_match.

$str='http://blog.csdn.net/hsd2012';$pattern='/csdn/';function checkStr2($str,$str2)
{    return preg_match($str2,$str)?true:false;
}echo checkStr2($str,$pattern);

• Exemple 2 (Inspection du délimiteur de mots)
  Déterminez si la chaîne "Je suis un bon garçon" contient le mot aller
  Déterminez d'abord qu'il s'agit d'un mot, pas d'une chaîne, donc lors de la comparaison, vous devez comparer s'il contient « go », c'est-à-dire s'il y a un espace avant et après la chaîne go.
  Analyse : si vous utilisez une comparaison non régulière, il vous suffit d'appeler la fonction checkStr1() ci-dessus. Notez qu'un espace doit être ajouté avant et après le deuxième paramètre, c'est-à-dire 'go'. Si vous utilisez des expressions régulières,
  nous pouvons envisager d'utiliser le délimiteur de mots b, puis $pattern='/bgob/'; puis appeler la fonction checkStr2

• Exemple 3 (Inspection. Référence arrière)
  Déterminez si la chaîne "Je suis un bon garçon" contient 3 lettres identiques
  Analyse : à ce stade, si nous n'utilisons pas d'expressions régulières, il sera difficile de juger , comme il y a trop de lettres, il nous est impossible de comparer toutes les lettres avec la chaîne respectivement, ce qui nécessiterait également beaucoup de travail. Cette fois-ci, il s’agit de références antérieures actuelles. Dans les expressions régulières PHP, n est utilisé pour représenter le résultat de la nième correspondance. Par exemple, 5 représente le cinquième résultat correspondant. Donc, la principale chose à noter à propos de $pattern='/(w).*1.*1/';
  dans cette question est que vous devez utiliser () lorsque vous utilisez la correspondance inversée, faites correspondre les caractères ou les chaînes qui apparaissent entre ().

Remplacement de chaînes en php

N'utilise pas d'expressions régulières

Lors du remplacement de chaînes en php, si les expressions régulières ne s'appliquent pas, nous utilisons généralement substr , mb_substr, str_replace et substr_replace Les différences entre ces fonctions sont les suivantes.

Utilisez des expressions régulières

Si vous utilisez le remplacement d'expressions régulières, PHP fournit les fonctions preg_replace _callback et preg_replace Le prototype de preg_replace est le suivant :
mixte preg_replace ( mixte pattern,mixedreplacement , mixte subject[,intlimit = -1 [, int &count]])Lettre CompterGongPeutDécrireDécrire : Dans le mot symbole sujet de la chaîne, recherchez pattern,ran < Après 🎜>, utilisez le remplacement pour remplacer , s'il y a limit signifie représente Limité à Faitremplacementremplacementlimit fois.pregreplacecallback与pregreplace功能相识，不同的是pregreplaceback使用一个回调函数callback来代替replacement.−例1将字符串”hello,中国”中的hello替换为′你好′;如果不是用正则:str=’hello,中国’; str=strreplace(′hello′,′你好′,str) 或是使用str=substrreplace(str,’你好’,0,5) 使用正则 pattern=′/hello/′;str=preg_replace (pattern,′你好′,str); - 例2 去除字符串”gawwenngeeojjgegop”中连续相同的字母

$str='gawwenngeeojjgegop';$pattern='/(.)\1/';$str=preg_replace($pattern,'',$str);

解析：当然这样可能会遇到，当第一次去除了重复了字符串后，又出来重复的字符串。如字符串味’gewwenngeeojjgegop’,针对这中问题，当然，这样的话，通过判断，继续替换下去。

• 例3
  将字符串中”age13gegep3iorji65k65k”;中出现的连续两个数字改为第二个数字，如字符串中13被改为3

$str='age13gegep3iorji65k65k';$pattern='/(\d)(\d)/';$str=preg_replace($pattern,'$2', $str);

解析：$n在正则表达式外使用反向引用。n代表第几次匹配到的结果。

php中字符串分割

不适用正则

php提供了explode函数去分割字符串，与其对应的是implode。关于explode原型如下：
array explode ( string delimiter,stringstring [, int $limit ] )
delimiter：边界上的分隔字符。
string：输入的字符串。
limit：如果设置了 limit 参数并且是正数，则返回的数组包含最多 limit 个元素，而最后那个元素将包含 string 的剩余部分。如果 limit 参数是负数，则返回除了最后的 -limit 个元素外的所有元素。如果 limit 是 0，则会被当做 1。

使用正则

关于通过正则表达式进行字符串分割，php提供了split、preg_split 函数。preg_split() 函数，通常是比 split() 更快的替代方案。
array preg_split ( string pattern,stringsubject [, int limit=−1[,intflags = 0 ]] )

• 例题
  将字符串 ‘http://blog.csdn.net/hsd2012/article/details/51152810‘按照’/’进行分割
  解法一：

$str='http://blog.csdn.net/hsd2012/article/details/51152810';$str=explode('/', $str);

解法二：

$str='http://blog.csdn.net/hsd2012/article/details/51152810';$pattern='/\//';  /*因为/为特殊字符，需要转移*/$str=preg_split ($pattern, $str);

php中贪婪匹配与惰性匹配

• 贪婪匹配：就是匹配尽可能多的字符。
  比如，正则表达式中m.*n，它将匹配最长以m开始，n结尾的字符串。如果用它来搜索manmpndegenc的话，它将匹配到的字符串是manmpndegen而非man。可以这样想，当匹配到m的时候，它将从后面往前匹配字符n。

• 懒惰匹配：就是匹配尽可能少的字符。
  有的时候，我们需要并不是去贪婪匹配，而是尽可能少的去匹配。这时候，就需要将其转为惰性匹配。怎样将一个贪婪匹配转为惰性匹配呢？只需要在其后面添加一个”？”即可。如m.*?n将匹配manmpndegenc，匹配到的字符串是man。

php正则表达式之回溯与固态分组

回溯

首先我们需要清楚什么是回溯，回溯就像是在走岔路口，当遇到岔路的时候就先在每个路口做一个标记。如果走了死路，就可以照原路返回，直到遇见之前所做过的标记，标记着还未尝试过的道路。如果那条路也走不能，可以继续返回，找到下一个标记，如此重复，直到找到出路，或者直到完成所有没有尝试过的路。首先我们看例题

$str='aageacwgewcaw';$pattern='/a\w*c/i';$str=preg_match($pattern, $str);

看到上面的程序，可能都清楚是什么意思，就是匹配$str是否包含这样一个由”a+0个或多个字母+c”不区分大小写的字符串。但是至于程序怎样去匹配的呢？匹配的过程中，回溯了多少次呢？

现在，如果我们将pattern改为pattern=’/a\w*?c/i’;又会回溯多少次呢？正确答案是回溯四次。

固态分组

固态分组，目的就是减少回溯次数， 使用(?>…)括号中的匹配时如果产生了备选状态，那么一旦离开括号便会被立即 引擎抛弃掉。举个典型的例子如： ‘\w+:’这个表达式在进行匹配时的流程是这样的，会优先去匹配所有的符合\w的字符，假如字符串的末尾没有’:’，即匹配没有找到冒号，此时触发回溯机制，他会迫使前面的\w+释放字符，并且在交还的字符中重新尝试与’:’作比对。但是问题出现在这里: \w是不包含冒号的，显然无论如何都不会匹配成功，可是依照回溯机制，引擎还是得硬着头皮往前找，这就是对资源的浪费。所以我们就需要避免这种回溯，对此的方法就是将前面匹配到的内容固化，不令其存储备用状态！，那么引擎就会因为没有备用状态可用而只得结束匹配过程。大大减少回溯的次数。
如下代码，就不会进行回溯：

$str='nihaoaheloo';$pattern='/(?>\w+):/';$rs=preg_match($pattern, $str);

当然有的时候，又需慎用固态分组，如下,我要检查$str中是否包含以a结尾的字符串，很明显是包含的，但是因为使用了固态分组，反而达不到我们想要的效果

$str='nihaoahelaa';$pattern1='/(?>\w+)a/';$pattern2='/\w+a/';$rs=preg_match($pattern1, $str);//0$rs=preg_match($pattern2, $str);//1

php中其他常用字符串操作函数

• 字符串截取截取 
  string substr ( string string,intstart [, int length])stringmbsubstr(stringstr , int start[,intlength = NULL [, string $encoding = mb_internal_encoding() ]] )

• 字符串中大小写转换 
  strtoupper 
  strtolower 
  ucfirst 
  ucwords

• 字符串比较 
  -strcmp、strcasecmp、strnatcmp

• 字符串过滤

• 字符串翻转 
  strrev($str);

• 字符串随机排序 
  string str_shuffle ( string $str )

Supplémentaire

Comment effectuer la correspondance d'e-mails, d'URL et de téléphone mobile

Utilisez la fonction preg_match pour la correspondance. Le contenu suivant est copié de TP.
Vérification de l'e-mail
pattern=′/w+([−+. ]w+)∗@w+([− .]w+)∗.w+([−.]w+)∗/';
url correspondant
pattern='/^http(s ?)://(?:[A-za-z0-9-]+.)+[A-za-z]{2,4}(:d+)?(?:[/?#][/= ?%-&~`@[]':+!.#w]*)?/';
Vérification du téléphone portable
p attern=′/1 [3458]d10/';

Les avantages et les inconvénients des expressions régulières en php

Les expressions régulières en PHP peuvent parfois nous aider à résoudre de nombreux problèmes difficiles de correspondance ou de remplacement dans les fonctions PHP. Ensuite, nous devons souvent considérer l'efficacité des expressions régulières en PHP, donc à certains moments, si nous pouvons éviter d'utiliser des expressions régulières, nous devrions essayer de ne pas les utiliser, à moins qu'elles ne doivent être utilisées dans certaines situations, ou nous pouvons réduire efficacement le nombre de retours en arrière.

Recommandations associées :

Expression régulière PHP (ajout de 177 numéros de téléphone portable)

Partage d'expressions régulières PHP

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!