Ce qui suit est une collection de codes de fonction courants pour les expressions régulières en PHP afin de faciliter l'apprentissage de l'expression régulière PHP
preg_grep.
(PHP4, PHP5)
preg_grep -- Renvoie les descriptions de cellules du tableau correspondant au modèle
array preg_grep ( string pattern, array input [, int flags] )
preg_grep() Renvoie un tableau contenant les cellules du tableau d'entrée qui correspondent au modèle de motif donné.
les drapeaux peuvent être les drapeaux suivants :
PREG_GREP_INVERT
S'il est passé dans cet indicateur, preg_grep() renvoie les cellules du tableau d'entrée qui ne correspondent pas au modèle donné. Cette balise est disponible depuis PHP 4.2.0.
Depuis PHP 4.0.4, les résultats renvoyés par preg_grep() sont indexés à l'aide des clés du tableau d'entrée. Si vous ne souhaitez pas de tels résultats, utilisez array_values() pour réindexer les résultats renvoyés par preg_grep().
Ce qui précède est la description de preg_grep() dans le manuel. Tout d'abord, il s'agit d'une fonction régulière compatible Perl, donc je suppose que preg_grep signifie p(perl)reg(regular)_grep. Sa caractéristique est qu'elle peut être utilisée pour les tableaux, grâce à sa propre extension, elle peut être utilisée de manière régulière. correspondant dans des tableaux multidimensionnels, et il peut renvoyer un tableau correspondant ou non via le paramètre flags. Son efficacité est beaucoup plus rapide que l'utilisation de la structure foreach(...){if...} (non vérifiée), et elle peut correspondre à des modèles complexes. Il est d'une grande utilité dans des applications telles que la recherche et le tri.
exemple:
<?
$arr = array('abc'=>12.213,'bb'=>12345,'ba'=>23.2321,34.3,'23'=>'3.3','23434'=>'bbb');
// Renvoie tous les éléments du tableau contenant des nombres à virgule flottante.
$fl_array = preg_grep ("/^(d+)?.d+$/", $arr);
print_r($fl_array);
?>
preg_match
(PHP 3 >= 3.0.9, PHP 4, PHP 5)
preg_match -- Instructions de correspondance d'expressions régulières
int preg_match (string pattern, string subject [, array matches [, int flags]] )
recherche dans la chaîne sujet le contenu qui correspond à l'expression régulière donnée par pattern.
Si des correspondances sont fournies, les résultats de la recherche seront renseignés. $matches[0] contiendra du texte qui correspond à l'ensemble du modèle, $matches[1] contiendra du texte qui correspond au premier sous-modèle capturé entre parenthèses, et ainsi de suite.
les drapeaux peuvent être les drapeaux suivants :
PREG_OFFSET_CAPTURE
Si cet indicateur est défini, le décalage de chaîne associé sera également renvoyé pour chaque occurrence d'une correspondance. Notez que cela modifie la valeur du tableau renvoyé afin que chaque cellule qu'il contient soit également un tableau, où le premier élément est la chaîne correspondante et le deuxième élément est son décalage. Cette balise est disponible depuis PHP 4.3.0.
Le paramètre flags est disponible depuis PHP 4.3.0.
preg_match() renvoie le nombre de fois où le modèle correspond. Soit 0 fois (pas de correspondance), soit 1 fois, puisque preg_match() arrêtera la recherche après la première correspondance. preg_match_all(), au contraire, recherchera jusqu'à la fin du sujet. Si une erreur se produit, preg_match() renvoie FALSE.
Astuce : Si vous voulez simplement voir si une chaîne est contenue dans une autre chaîne, n'utilisez pas preg_match(). Vous pouvez utiliser strpos() ou strstr() à la place, ce qui est beaucoup plus rapide.
Ce qui précède est la description de preg_match() dans le manuel. Je pense que la fonction de cette fonction est qu'elle peut être utilisée pour vérifier, c'est-à-dire si une certaine chaîne répond à certaines exigences. La limitation est que, comme mentionné ci-dessus, il correspond soit à 0 fois, soit à 1 fois. Et la valeur de retour est le nombre de correspondances. Lorsqu'une correspondance complète est requise, preg_match_all() peut être utilisée. Il convient également de mentionner le rôle du tableau $matches, qui peut être utilisé comme valeur de retour du modèle automatique, ce qui est parfois utile.
Exemple :
<?
if (preg_match ("/(bwebb)s(d)/i", "PHP est le langage de script Web 45 de choix.",$match)) {
print "Une correspondance a été trouvée.";
print_r($match);
} autre {
print "Aucune correspondance n'a été trouvée.";
}
?>
<?php
// Récupère le nom d'hôte à partir de l'URL
preg_match("/^(http://)?([^/]+)/i",
" http://www.php.net/index.html ", $matches);
$hôte = $matches[2] ;
// Récupère les deux segments suivants du nom d'hôte
preg_match("/[^./]+.[^./]+$/", $host, $matches);
echo "le nom de domaine est : {$matches[0]}n" ;
?>
preg_match_all
(PHP 3 >= 3.0.9, PHP 4, PHP 5)
preg_match_all -- Effectuer une correspondance globale d'expressions régulières L'explication de cette fonction dans le manuel est très claire, je ne l'expliquerai donc pas davantage.
illustrer
int preg_match_all (modèle de chaîne, sujet de chaîne, correspondances de tableau [, int flags])
recherche tout le contenu du sujet qui correspond à l'expression régulière donnée par pattern et place les résultats dans des correspondances dans l'ordre spécifié par les indicateurs.
Une fois la première correspondance trouvée, les recherches suivantes commencent à la fin de la correspondance précédente.
les indicateurs peuvent être une combinaison des indicateurs suivants (notez que cela n'a pas de sens d'utiliser PREG_PATTERN_ORDER et PREG_SET_ORDER ensemble) :
PREG_PATTERN_ORDER
Triez les résultats de sorte que $matches[0] soit un tableau de toutes les correspondances de modèles, $matches[1] soit un tableau de chaînes correspondant au sous-modèle dans la première parenthèse, et ainsi de suite.
<?php
preg_match_all ("|<[^>]+>(.*)</[^>]+>|U", "<b>exemple : </b><div align=left>ceci est un test</div >",
$out, PREG_PATTERN_ORDER);
print $out[0][0].", ".$out[0][1]."n";
print $out[1][0].", ".$out[1][1]."n";
?>
Cet exemple affichera :
<b>exemple : </b>, <div align=left>ceci est un test</div>
exemple : , il s'agit d'un test.
Par conséquent, $out[0] contient la chaîne correspondant à l'intégralité du modèle et $out[1] contient la chaîne entre une paire de balises HTML.
PREG_SET_ORDER
Triez les résultats de sorte que $matches[0] soit le tableau du premier ensemble de correspondances, $matches[1] soit le tableau du deuxième ensemble de correspondances, et ainsi de suite.
<?php
preg_match_all ("|<[^>]+>(.*)</[^>]+>|U",
"<b>exemple : </b><div align=left>ceci est un test</div>",
$out, PREG_SET_ORDER);
print $out[0][0].", ".$out[0][1]."n";
print $out[1][0].", ".$out[1][1]."n";
?>
Cet exemple affichera :
<b>exemple : </b>, exemple :
<div align=left>c'est un test</div>, c'est un test
Dans cet exemple, $matches[0] est le premier ensemble de résultats correspondants, $matches[0][0] contient le texte correspondant à l'intégralité du modèle, $matches[0][1] contient le texte correspondant au premier sous-modèle. , se terminant par Et ainsi de suite. De même, $matches[1] est le deuxième ensemble de correspondances, et ainsi de suite.
PREG_OFFSET_CAPTURE
Si cet indicateur est défini, le décalage de chaîne associé sera également renvoyé pour chaque occurrence d'une correspondance. Notez que cela modifie la valeur du tableau renvoyé afin que chaque cellule soit également un tableau, où le premier élément est la chaîne correspondante et le deuxième élément est son décalage dans le sujet. Cette balise est disponible depuis PHP 4.3.0.
Si aucune balise n'est donnée, PREG_PATTERN_ORDER est supposé.
Renvoie le nombre de fois où le modèle entier a été mis en correspondance (éventuellement zéro), ou FALSE en cas d'erreur.
Exemple 1. Obtenir tous les numéros de téléphone à partir d'un SMS
<?php
preg_match_all ("/(? (d{3})? )? (?(1) [-s] ) d{3}-d{4}/x",
"Appelez le 555-1212 ou le 1-800-555-1212", $phones);
?>
Exemple 2. Recherche de balises HTML correspondantes (gourmandes)
<?php
// \2 est un exemple de référence inverse, sa signification dans PCRE est
// Doit correspondre au contenu compris entre le deuxième jeu de crochets dans l'expression régulière elle-même, dans ce cas
// C'est ([w]+). Parce que la chaîne est entre guillemets doubles, vous avez besoin
//Ajoute une barre oblique inverse supplémentaire.
$html = "<b>texte en gras</b><a href=howdy.html>cliquez sur moi</a>";
preg_match_all ("/(<([w]+)[^>]*>)(.*)(</\2>)/", $html, $matches);
pour ($i=0; $i< nombre($matches[0]); $i++) {
echo "matched : ".$matches[0][$i]."n";
echo "partie 1 : ".$matches[1][$i]."n";
echo "partie 2 : ".$matches[3][$i]."n";
echo "partie 3 : ".$matches[4][$i]."nn";
}
?>
preg_quote
(PHP 3 >= 3.0.9, PHP 4, PHP 5)
preg_quote -- échappement de la description du caractère d'expression régulière
string preg_quote ( string str [, string delimiter] )
preg_quote() prend str comme paramètre et ajoute une barre oblique inverse devant chaque caractère appartenant à la syntaxe de l'expression régulière. Si vous devez faire correspondre une chaîne générée dynamiquement en tant que modèle, vous pouvez utiliser cette fonction pour échapper aux caractères spéciaux qu'elle peut contenir.
Si le délimiteur d'argument facultatif est fourni, ce caractère sera également échappé. Il peut être utilisé pour échapper au délimiteur requis par la fonction PCRE. Le délimiteur le plus couramment utilisé est la barre oblique /.
Les caractères spéciaux pour les expressions régulières incluent : . + * ? [ ^ ] $ ( ) { } = !
Remarque : Cette fonction peut être utilisée en toute sécurité sur des objets binaires.
Ce qui précède est l'explication du manuel, qui est très claire, donc je n'entrerai pas dans les détails. De plus, il y a une note dans le manuel indiquant que cette fonction peut être utilisée en toute sécurité pour les objets binaires, ce qui est très utile.
Exemple : Exemple 1. Exemple preg_quote()
<?php
$keywords = '40$ pour un g3/400';
$mots-clés = preg_quote($mots-clés, '/');
echo $keywords; // renvoie $40 pour un g3/400
?>
Exemple 2. Ajouter de l'italique à un mot dans un texte
<?php
// Dans cet exemple, preg_quote($word) est utilisé pour garder l'astérisque hors de l'expression régulière
// A une signification particulière.
$textbody = "Ce livre est *très* difficile à trouver.";
$word = "*très*";
$textbody = preg_replace ("/".preg_quote($word)."/",
"<i>".$mot."</i>",
$textbody);
?>
L'étape suivante consiste à appliquer la fonction preg_replace qui est super flexible, super puissante et très largement utilisée.
preg_replace
(PHP 3 >= 3.0.9, PHP 4, PHP 5)
preg_replace – effectue une recherche d'expression régulière et remplace les instructions
Mixed preg_replace (modèle mixte, remplacement mixte, sujet mixte [, limite int])
recherche dans le sujet les correspondances du modèle modèle et les remplace par remplacement. Si la limite est spécifiée, seules les correspondances limites seront remplacées. Si la limite est omise ou a une valeur de -1, toutes les correspondances seront remplacées.
Le remplacement peut contenir une référence arrière sous la forme \n ou (depuis PHP 4.0.4) sous la forme $n, cette dernière étant préférée. Chacune de ces références sera remplacée par du texte correspondant au nième sous-modèle entre crochets capturé. n peut aller de 0 à 99, où \0 ou $0 fait référence au texte correspondant à l'ensemble du modèle. Comptez la parenthèse gauche de gauche à droite (en commençant à 1) pour obtenir le nombre de sous-motifs.
Pour les modèles de remplacement qui suivent une référence arrière par un nombre (c'est-à-dire un nombre qui suit immédiatement un modèle correspondant), la notation familière \1 ne peut pas être utilisée pour représenter la référence arrière. Par exemple, \11 rendra preg_replace() confus s'il veut une référence arrière de \1 suivie du numéro 1 ou une référence arrière de \11 . La solution dans ce cas est d'utiliser ${1}1. Cela crée une référence arrière isolée pour 1 $, laissant l'autre 1 juste un littéral.
Si une correspondance est trouvée, le sujet remplacé sera renvoyé, sinon le sujet original sera renvoyé.
Chaque paramètre de preg_replace() (sauf limite) peut être un tableau. Si le motif et le remplacement sont des tableaux, ils seront traités dans l'ordre dans lequel leurs clés apparaissent dans le tableau. Ce n'est pas nécessairement le même que l'ordre numérique de l'indice. Si un index est utilisé pour identifier quel modèle doit être remplacé par quel remplacement, le tableau doit être trié avec ksort() avant d'appeler preg_replace().
Si le sujet est un tableau, une recherche et un remplacement sont effectués sur chaque élément du sujet et un tableau est renvoyé.
Si motif et remplacement sont tous deux des tableaux, preg_replace() en retirera les valeurs afin de rechercher et de remplacer le sujet. S'il y a moins de valeurs dans le remplacement que dans le modèle, une chaîne vide est utilisée comme valeur de remplacement restante. Si motif est un tableau et remplacement est une chaîne, cette chaîne est utilisée comme valeur de remplacement pour chaque valeur du motif. L’inverse n’a aucun sens.
Le modificateur /e amène preg_replace() à traiter l'argument de remplacement comme du code PHP (après que les références arrière appropriées aient été remplacées). Astuce : Assurez-vous que le remplacement forme une chaîne de code PHP valide, sinon PHP signalera une erreur d'analyse syntaxique sur la ligne contenant preg_replace().
Remarque : Le paramètre limit a été ajouté après PHP 4.0.1pl2.
Je pense que sa puissance réside dans le fait qu'il peut gérer non seulement des chaînes, mais également des tableaux, et sa fonction de référence inverse est très flexible. Fondamentalement, il peut répondre à la plupart des besoins des utilisateurs ordinaires. S'il n'est pas compétent, nous avons également la fonction preg_replace_callback(), qui peut personnaliser la fonction de rappel pour répondre à vos besoins avancés. Comme la conception de filtres, etc.
preg_replace_callback
(PHP 4 >= 4.0.5, PHP 5)
preg_replace_callback -- Utiliser la fonction de rappel pour effectuer une recherche d'expression régulière et remplacer des instructions
Mixed preg_replace_callback (modèle mixte, rappel de rappel, sujet mixte [, int limit])
Cette fonction se comporte presque comme preg_replace(), sauf qu'au lieu de fournir un paramètre de remplacement, une fonction de rappel est spécifiée. Cette fonction prend en entrée un tableau de correspondances dans la chaîne cible et renvoie la chaîne utilisée pour le remplacement.
Exemple 1. Exemple preg_replace_callback()
<?php
// Ce texte est pour 2002,
// Je souhaite maintenant le rendre disponible pour 2003
$text = "Le premier avril est le 01/04/2002n";
$text.= "Le dernier Noël était le 24/12/2001n";
// fonction de rappel
function next_year ($ matches) {
// Normalement : $matches[0] est la correspondance complète
// $matches[1] est la correspondance du sous-modèle dans la première parenthèse
// et ainsi de suite
return $matches[1].($matches[2]+1);
}
echo preg_replace_callback(
"|(d{2}/d{2}/)(d{4})|",
"l'année prochaine",
$texte);
//Le résultat est :
// Le premier avril est le 01/04/2003
// Noël dernier, c'était le 24/12/2002
?>
Vous aurez souvent besoin de la fonction de rappel pour un preg_replace_callback() à un seul endroit. Dans ce cas, vous pouvez utiliser create_function() pour déclarer une fonction anonyme comme rappel dans l'appel à preg_replace_callback(). Ayez toutes les informations sur l'appel au même endroit et n'encombrez pas l'espace de noms de la fonction avec un nom de fonction de rappel qui n'est utilisé nulle part ailleurs.
Pour les amis qui utilisent la fonction preg_replace_callback(), vous devriez probablement avoir besoin de la fonction de rappel (sinon, pourquoi l'utiliser ? N'est-il pas préférable d'utiliser preg_replace directement), mais elle n'est souvent utilisée qu'à un seul endroit. Dans ce cas, vous pouvez utiliser create_function() pour déclarer une fonction anonyme comme fonction de rappel de preg_replace_callback(). De cette façon, nous satisfaisons le besoin de déclarer des informations sans nous laisser tromper par un nom de fonction qui ne sera plus utilisé.
Exemple 2. preg_replace_callback() et create_function()
<?php
/* Un filtre de ligne de commande de style UNIX qui supprime la chaîne au début de chaque paragraphe
*Convertir les lettres majuscules en lettres minuscules*/
$fp = fopen("php://stdin", "r") ou die("impossible de lire stdin");
tandis que (!feof($fp)) {
$line = fgets($fp);
$line = preg_replace_callback(
'|<p>s*w|',
créer_fonction(
// L'utilisation de guillemets simples ici est critique,
// Sinon, remplacez tous les $ par $
'$matchs',
'return strtolower($matches[0]);'
),
$ligne
);
echo $ligne;
}
fclose($fp);
?>
Enfin
preg_split
(PHP 3 >= 3.0.9, PHP 4, PHP 5)
preg_split – Divisez une chaîne à l'aide d'expressions régulières. Je n'entrerai pas dans les détails ici.
illustrer
array preg_split ( string pattern, string subject [, int limit [, int flags]] )
renvoie un tableau contenant les sous-chaînes du sujet divisé le long des limites correspondant au modèle.
Si limit est spécifié, au plus les sous-chaînes limit sont renvoyées. Si limit est -1, cela signifie qu'il n'y a pas de limite et peut être utilisé pour continuer à spécifier des indicateurs de paramètres facultatifs.
les indicateurs peuvent être n'importe quelle combinaison des indicateurs suivants (combinés avec l'opérateur OR au niveau du bit | ) :
PREG_SPLIT_NO_EMPTY
Si cet indicateur est défini, preg_split() renvoie uniquement les composants non vides.
PREG_SPLIT_DELIM_CAPTURE
Si cet indicateur est défini, les expressions entre crochets dans les modèles de délimiteur sont également capturées et renvoyées. Cette balise a été ajoutée dans PHP 4.0.5.
PREG_SPLIT_OFFSET_CAPTURE
Si cet indicateur est défini, le décalage de chaîne associé à chaque occurrence du résultat correspondant sera également renvoyé. Notez que cela modifie la valeur du tableau renvoyé afin que chaque cellule soit également un tableau, où le premier élément est la chaîne correspondante et le deuxième élément est son décalage dans le sujet. Cette balise est disponible depuis PHP 4.3.0.
Astuce : Si vous n'avez pas besoin de la puissance des expressions régulières, vous pouvez choisir d'utiliser des alternatives plus rapides (et plus simples) telles que explosive() ou str_split().