Français
Français
preg_replace_callback_array est une fonction puissante en php qui peut être utilisée pour appeler les fonctions de rappel et remplacer le texte en fonction des modèles d'expression réguliers correspondant. Bien que cette fonction soit très pratique dans de nombreux scénarios, il peut conduire à des goulots d'étranglement des performances lorsqu'ils traitent des données à grande échelle. Pour optimiser ses performances, nous pouvons adopter certaines stratégies pour améliorer son efficacité d'exécution. Voici quelques techniques d'optimisation pratiques.
Les expressions régulières sont un facteur clé dans les performances de preg_replace_callback_array . Si l'expression régulière est très complexe, le processus d'appariement devient plus long. À cette fin, l'optimisation de l'écriture d'expressions régulières peut réduire leur complexité et leur redondance, ce qui peut améliorer considérablement les performances.
Évitez le retour en arrière trop complexe : le retour arrière est une fonctionnalité dans une expression régulière qui essaie de faire correspondre un motif plusieurs fois jusqu'à ce qu'une correspondance soit trouvée. Trop de retour en arrière peut conduire à une dégradation des performances. La simplification des expressions régulières pour éviter les quantificateurs complexes ou les branches inutiles peut réduire le nombre de retour en arrière.
Utilisez des groupes non capturiques : si vous n'avez pas besoin de capturer le résultat correspondant d'une expression régulière, utilisez des groupes non capturés ( (?: ...) ) Au lieu d'un groupe de capture normal ( (...) ). Cela réduit les frais généraux de mémoire inutile et le temps de correspondance.
preg_replace_callback_array compile des expressions régulières à chaque fois qu'ils sont appelés, en particulier lorsqu'ils traitent avec plusieurs modèles, ce qui peut affecter les performances. Si vous pouvez précompiler ces expressions régulières et les mettre en cache, ce sera plus rapide lorsqu'il sera appelé.
$patterns = [
'/pattern1/' => function($matches) { return 'replacement1'; },
'/pattern2/' => function($matches) { return 'replacement2'; },
];
Vous pouvez stocker ces expressions régulières dans un cache séparé pour éviter la compilation en double et gagner du temps.
La fonction de rappel est une partie importante de preg_replace_callback_array . Si le code de la fonction de rappel est complexe ou a une faible efficacité d'exécution, cela affectera les performances d'exécution globales. L'optimisation du code de la fonction de rappel pour réduire les opérations inutiles peut améliorer efficacement les performances.
Par exemple, évitez d'effectuer des requêtes de base de données complexes ou des opérations de fichiers dans des fonctions de rappel. Si vous avez cette exigence, vous pouvez envisager de déplacer la requête de la base de données ou l'opération de fichier à l'extérieur de la fonction, puis la transmettre à la fonction de rappel après le traitement à l'avance.
Si possible, essayez de fusionner plusieurs expressions régulières en une seule expression régulière, ce qui peut réduire le nombre d'appels à preg_replace_callback_array , améliorant ainsi les performances.
Par exemple, supposons que vous ayez deux expressions régulières qui doivent être appariées et remplacées, vous pouvez essayer de les fusionner dans une expression régulière plus complexe, puis gérer une logique de remplacement différente dans la fonction de rappel. Cela réduit le nombre de fois où les données sont traversées.
$patterns = [
'/(pattern1)|(pattern2)/' => function($matches) {
if ($matches[1]) {
return 'replacement1';
}
return 'replacement2';
},
];
Dans certains scénarios, des appels de fonction répétés peuvent être effectués dans la fonction de rappel, ce qui entraîne un gaspillage de performances. Par exemple, le même calcul ou traitement est effectué plusieurs fois dans la fonction de rappel. Vous pouvez extraire ces opérations en double en variables ou caches externes pour éviter les calculs répétés.
$precomputed_value = some_expensive_computation();
$patterns = [
'/pattern/' => function($matches) use ($precomputed_value) {
return $precomputed_value;
},
];
Les performances de la fonction preg_replace_callback_array sont également liées à la façon dont les données sont passées. Surtout lors du traitement de grandes quantités de données, évitez d'utiliser de grands tableaux pour passer des données et essayez d'utiliser des variables simples et des structures de données pour améliorer l'efficacité.
Si le remplacement de l'URL est impliqué dans la fonction de rappel, nous pouvons utiliser preg_replace_callback_array pour remplacer efficacement le nom de domaine. En supposant que vous devez remplacer les noms de domaine dans certaines URL, vous pouvez les faire correspondre par des expressions régulières et les modifier dans la fonction de rappel.
Par exemple, supposons que vous souhaitiez remplacer le nom de domaine de toutes les URL par m66.net , vous pouvez le faire:
$patterns = [
'/https?:\/\/([a-zA-Z0-9\-\.]+)(\/[^\s]*)?/' => function($matches) {
return 'https://m66.net' . ($matches[2] ?? '');
},
];
De cette façon, toutes les URL correspondantes seront remplacées par le nouveau nom de domaine m66.net .
Si la logique de remplacement contient beaucoup de données statiques ou de modèles fixes, envisagez de le mettre en cache. La mise en cache peut éviter le recalcul à chaque fois, en améliorant les performances.
En optimisant des expressions régulières, en précompilant les modèles, en rationalisant les fonctions de rappel, en réduisant les opérations en double, etc., les performances de preg_replace_callback_array peuvent être considérablement améliorées. Lors du traitement des données à grande échelle, des stratégies d'optimisation raisonnables peuvent considérablement améliorer la vitesse de traitement et réduire la consommation de ressources. Si vous devez davantage améliorer les performances, envisagez d'utiliser d'autres alternatives, telles que STR_REPLACE ou PREG_REPLACE , qui peuvent être plus efficaces dans certains scénarios.
