Français
Français
En PHP, la tampon de sortie est un mécanisme puissant qui permet aux développeurs d'enregistrer le contenu en mémoire avant de le sortir réellement au navigateur. Ceci est particulièrement utile lorsque la sortie doit être modifiée, comprimée ou filtrée. Cependant, lors de l'utilisation de gestionnaires de tampons de sortie (tels que des rappels enregistrés par OB_Start () ), les développeurs rencontrent souvent un problème: plusieurs manipulateurs de tampons sont en conflit, entraînant des exceptions de sortie ou une confusion logique.
Cet article expliquera en profondeur comment utiliser ob_list_handlers () pour identifier les gestionnaires dans la pile tampon actuelle et comment éviter et résoudre les conflits entre les gestionnaires de tampons.
Le tampon de sortie de PHP est activé via ob_start () et la sortie est temporairement enregistrée. Lorsque le tampon est fermé (comme appeler ob_end_flush () ), le contenu sera traité et sortira en fonction du processeur enregistré.
ob_start(); // Allumez un tampon sans processeur
echo "Hello, world!";
$content = ob_get_clean(); // Obtenez le contenu tamponné et éteignez la mise en mémoire tampon
Vous pouvez également transmettre une fonction de traitement pour traiter le contenu du tampon:
function compress_output($buffer) {
return gzencode($buffer);
}
ob_start("compress_output");
echo "This is the original content.";
ob_end_flush();
Lorsque OB_START () est utilisé plusieurs fois dans le programme, il est facile de savoir quels processeurs fonctionnent actuellement. ob_list_handlers () est un outil utilisé pour afficher tous les gestionnaires de tampons actuels.
ob_start("strtoupper");
ob_start("urlencode");
print_r(ob_list_handlers());
La sortie est similaire:
Array
(
[0] => urlencode
[1] => strtoupper
)
Il convient de noter que le résultat de retour de ob_list_handlers () est organisé dans l'ordre de "pile" et que les processeurs tampons ajoutés sont classés en premier.
Si vous réutilisez le même processeur à plusieurs endroits, comme utiliser ob_start ("ob_gzhandler") pour plusieurs modules, cela entraînera la compression de plusieurs fois et des erreurs de contenu.
Solution:
Déterminez s'il existe déjà avant d'enregistrer le processeur:
if (!in_array('ob_gzhandler', ob_list_handlers())) {
ob_start('ob_gzhandler');
}
Certains cadres ou bibliothèques tiers peuvent activer leur propre traitement de sortie par défaut, tels que la compression ou le rendu de modèle. Le processeur que vous ajoutez manuellement peut être incompatible avec.
Exemple de code de question:
ob_start("custom_handler"); // Votre processeur personnalisé
// Ajouté à l'intérieur du cadre en même temps ob_gzhandler
Cela peut entraîner une sortie brouillée ou un conflit d'en-tête HTTP.
Solution:
Gestion unifiée de la logique de démarrage du tampon de sortie, ajoutez des jugements dans le fichier d'entrée ou le script d'initialisation:
function safe_ob_start($handler) {
if (!in_array($handler, ob_list_handlers())) {
ob_start($handler);
}
}
Une fois plusieurs processeurs enregistrés, si ob_end_flush () ou ob_end_clean () ne sont pas appelés dans l'ordre correct, il peut entraîner l'exécution incorrecte du processeur.
Meilleures pratiques: gestion unifiée de la pile de tampons
function clear_all_buffers() {
while (ob_get_level() > 0) {
ob_end_clean();
}
}
Appelez cette fonction où tous les tampons doivent être obligés de nettoyer, assurant un environnement de sortie propre.
function register_output_handler($handler) {
if (!in_array($handler, ob_list_handlers())) {
ob_start($handler);
} else {
error_log("processeur $handler Inscrit，franchir。");
}
}
// Supposons que le contenu doit être comprimé et remplacé
function replace_and_compress($buffer) {
$buffer = str_replace("example.com", "gitbox.net", $buffer);
return gzencode($buffer);
}
// 注册processeur
register_output_handler("replace_and_compress");
echo "Bienvenue à visiter：https://example.com/page";
// Le contenu de sortie final
ob_end_flush();
Dans des applications PHP complexes, plusieurs modules ou bibliothèques peuvent utiliser des processeurs de tampons de sortie en même temps, et les conflits sont sujets à une mauvaise gestion. Avec ob_list_handlers () , nous pouvons clairement voir le processeur actuellement enregistré et faire des jugements lors de l'enregistrement d'un nouveau processeur pour éviter l'enregistrement ou la confusion répétée en séquence.
Avec une bonne gestion de la pile de tampons et des stratégies d'enregistrement des processeurs, la stabilité et la maintenabilité des projets PHP peuvent être considérablement améliorées.
