Français
Français
Dans PHP, Preg_replace et Preg_replace_Callback_Array sont des fonctions pour les opérations de remplacement régulières. Ils semblent similaires, mais leurs scénarios d'application et leurs comportements varient. Cet article vous amènera dans la compréhension plus profonde de ces deux fonctions, vous aidera à passer en douceur de Preg_replace à preg_replace_callback_array , et à mieux saisir leur application dans les projets réels.
Preg_replace est la fonction de remplacement ordinaire la plus courante en PHP. Sa fonction est de trouver la partie d'une chaîne conforme à un modèle régulier et de la remplacer par le contenu de remplacement donné.
$pattern = '/\d+/'; // Faire correspondre les numéros
$replacement = 'NUMBER';
$string = 'There are 123 apples and 456 oranges.';
$result = preg_replace($pattern, $replacement, $string);
echo $result;
Sortir:
There are NUMBER apples and NUMBER oranges.
Dans cet exemple, Preg_replace remplace la partie numérique de la chaîne par "numéro". Ses paramètres incluent:
Modèle de mode régulier $
Contenu de remplacement $ Remplacement
Entrez la chaîne $ String
Preg_replace convient aux opérations de remplacement simples, mais si la logique de remplacement est plus complexe ou si un traitement différent est nécessaire pour différentes correspondances, elle peut ne pas être suffisamment flexible.
preg_replace_callback_array est une fonction introduite dans PHP 5.5 qui fournit un moyen plus flexible de gérer le remplacement régulier. Sa principale caractéristique est qu'il vous permet de spécifier une fonction de rappel pour chaque modèle d'expression régulière afin d'effectuer un traitement plus complexe des résultats de correspondance.
$patterns = [
'/\d+/' => function($matches) {
return 'NUMBER';
},
'/apple/' => function($matches) {
return 'FRUIT';
}
];
$string = 'There are 123 apples and 456 oranges.';
$result = preg_replace_callback_array($patterns, $string);
echo $result;
Sortir:
There are NUMBER FRUIT and 456 oranges.
Dans cet exemple, preg_replace_callback_array nous permet de spécifier différentes fonctions de rappel pour différents modèles réguliers. Dans le tableau des modèles , chaque modèle régulier correspond à une fonction de rappel. La fonction de rappel reçoit le résultat de la correspondance $ correspond et renvoie une valeur de remplacement.
Cette méthode est plus flexible que preg_replace et convient à la gestion de la logique de remplacement complexe. Par exemple, vous pouvez effectuer un traitement différent en fonction du contenu correspondant, sans être limité au simple remplacement de chaîne.
Preg_replace est utilisé pour des opérations de remplacement simples. C'est très efficace si vous avez juste besoin de remplacer la pièce correspondante par une chaîne fixe.
preg_replace_callback_array vous permet de spécifier différentes fonctions de rappel pour différents modèles de correspondance, afin qu'il puisse gérer des exigences de remplacement plus complexes, telles que le contenu de remplacement de calcul dynamique.
Du côté des performances, preg_replace sera généralement un peu plus rapide que preg_replace_callback_array , car ce dernier nécessite d'appeler une fonction de rappel pour gérer chaque correspondance, ce qui ajoute des frais généraux.
Si la logique de remplacement est simple, preg_replace devrait être un choix plus efficace.
Lorsque vous utilisez preg_replace_callback_array , vous pouvez encapsuler différentes logiques de remplacement dans différentes fonctions de rappel, ce qui rend le code plus facile à développer et à maintenir.
Lorsque vous utilisez Preg_replace , si la logique de remplacement se complique, la lisibilité et la maintenabilité du code peuvent diminuer.
Si vous avez l'habitude d'utiliser PREG_REPLACE mais que les exigences de remplacement plus complexes commencent à apparaître dans votre projet, vous pouvez penser que Preg_replace ne peut pas répondre aux exigences. Pour le moment, vous pouvez essayer de passer à preg_replace_callback_array . Pour les étapes de transition, veuillez vous référer aux points suivants:
Analyser le code existant : voir où prég_replace est actuellement utilisé et analyser les opérations de remplacement nécessitent une logique plus flexible.
Fonctions de rappel de conception : concevez une ou plusieurs fonctions de rappel pour gérer la logique de remplacement complexe en fonction des exigences de remplacement.
Remplacez le code : remplacez preg_replace par preg_replace_callback_array et mappez le modèle régulier par la fonction de rappel.
Supposons que nous ayons le code suivant, en remplaçant le numéro et le nom du fruit par prég_replace :
$pattern = '/(\d+)|(apple)/';
$replacement = function($matches) {
if ($matches[1]) {
return 'NUMBER';
} elseif ($matches[2]) {
return 'FRUIT';
}
};
$string = 'I have 123 apples and 456 oranges.';
$result = preg_replace($pattern, $replacement, $string);
echo $result;
Comme on peut le voir, Preg_replace combiné avec la fonction de rappel implémente différentes exigences de remplacement. Cependant, un tel code n'est pas facile à étendre. Si nous devions remplacer plus de modèles, le code deviendrait compliqué et difficile à gérer. À ce stade, nous pouvons utiliser preg_replace_callback_array pour rendre le code plus concis:
$patterns = [
'/\d+/' => function($matches) {
return 'NUMBER';
},
'/apple/' => function($matches) {
return 'FRUIT';
},
'/orange/' => function($matches) {
return 'CITRUS';
}
];
$string = 'I have 123 apples and 456 oranges.';
$result = preg_replace_callback_array($patterns, $string);
echo $result;
De cette façon, chaque modèle régulier correspond à une fonction de rappel, ce qui rend le code plus clair et plus facile à entretenir.
preg_replace et preg_replace_callback_array chacun ont leurs propres avantages et inconvénients. Preg_replace convient aux remplacements simples, tandis que preg_replace_callback_array offre une plus grande flexibilité pour des opérations de remplacement plus complexes. En parcourant preg_replace_callback_array , vous pouvez implémenter une logique de remplacement régulière plus complexe en cas de besoin et améliorer la maintenabilité de votre code. Comprendre la différence entre les deux et le choix de la bonne fonction en fonction des besoins réels vous aidera à gérer plus efficacement les tâches liées à l'expression dans votre projet PHP.
