PHP
Sortie Buffering
Recherche…
Paramètres
| Fonction | Détails |
|---|---|
| ob_start () | Démarre le tampon de sortie, toute sortie placée après cela sera capturée et ne sera pas affichée |
| ob_get_contents () | Renvoie tout le contenu capturé par ob_start() |
| ob_end_clean () | Vide le tampon de sortie et l'éteint pour le niveau d'imbrication actuel |
| ob_get_clean () | Déclencheurs à la fois ob_get_contents() et ob_end_clean() |
| ob_get_level () | Renvoie le niveau d'imbrication actuel du tampon de sortie |
| ob_flush () | Vider le tampon de contenu et l'envoyer au navigateur sans mettre fin au tampon |
| ob_implicit_flush () | Active le vidage implicite après chaque appel de sortie. |
| ob_end_flush () | Videz le tampon de contenu et envoyez-le au navigateur pour mettre fin au tampon |
Utilisation de base pour obtenir du contenu entre les tampons et la compensation
La mise en mémoire tampon de sortie vous permet de stocker tout contenu textuel (texte, HTML ) dans une variable et de l'envoyer au navigateur en une seule pièce à la fin de votre script. Par défaut, php envoie votre contenu tel qu'il l'interprète.
<?php
// Turn on output buffering
ob_start();
// Print some output to the buffer (via php)
print 'Hello ';
// You can also `step out` of PHP
?>
<em>World</em>
<?php
// Return the buffer AND clear it
$content = ob_get_clean();
// Return our buffer and then clear it
# $content = ob_get_contents();
# $did_clear_buffer = ob_end_clean();
print($content);
#> "Hello <em>World</em>"
Tout contenu généré entre ob_start() et ob_get_clean() sera capturé et placé dans la variable $content .
L'appel de ob_get_clean() déclenche à la fois ob_get_contents() et ob_end_clean() .
Tampons de sortie imbriqués
Vous pouvez imbriquer des tampons de sortie et récupérer le niveau pour qu'ils fournissent un contenu différent à l'aide de la fonction ob_get_level() .
<?php
$i = 1;
$output = null;
while( $i <= 5 ) {
// Each loop, creates a new output buffering `level`
ob_start();
print "Current nest level: ". ob_get_level() . "\n";
$i++;
}
// We're at level 5 now
print 'Ended up at level: ' . ob_get_level() . PHP_EOL;
// Get clean will `pop` the contents of the top most level (5)
$output .= ob_get_clean();
print $output;
print 'Popped level 5, so we now start from 4' . PHP_EOL;
// We're now at level 4 (we pop'ed off 5 above)
// For each level we went up, come back down and get the buffer
while( $i > 2 ) {
print "Current nest level: " . ob_get_level() . "\n";
echo ob_get_clean();
$i--;
}
Les sorties:
Current nest level: 1
Current nest level: 2
Current nest level: 3
Current nest level: 4
Current nest level: 5
Ended up at level: 5
Popped level 5, so we now start from 4
Current nest level: 4
Current nest level: 3
Current nest level: 2
Current nest level: 1
Capturer le tampon de sortie pour le réutiliser plus tard
Dans cet exemple, nous avons un tableau contenant des données.
Nous capturons le tampon de sortie dans $items_li_html et l'utilisons deux fois dans la page.
<?php
// Start capturing the output
ob_start();
$items = ['Home', 'Blog', 'FAQ', 'Contact'];
foreach($items as $item):
// Note we're about to step "out of PHP land"
?>
<li><?php echo $item ?></li>
<?php
// Back in PHP land
endforeach;
// $items_lists contains all the HTML captured by the output buffer
$items_li_html = ob_get_clean();
?>
<!-- Menu 1: We can now re-use that (multiple times if required) in our HTML. -->
<ul class="header-nav">
<?php echo $items_li_html ?>
</ul>
<!-- Menu 2 -->
<ul class="footer-nav">
<?php echo $items_li_html ?>
</ul>
Enregistrez le code ci-dessus dans un fichier output_buffer.php et exécutez-le via php output_buffer.php .
Vous devriez voir les 2 éléments de liste que nous avons créés ci-dessus avec les mêmes éléments de liste que nous avons générés en PHP en utilisant le tampon de sortie:
<!-- Menu 1: We can now re-use that (multiple times if required) in our HTML. -->
<ul class="header-nav">
<li>Home</li>
<li>Blog</li>
<li>FAQ</li>
<li>Contact</li>
</ul>
<!-- Menu 2 -->
<ul class="footer-nav">
<li>Home</li>
<li>Blog</li>
<li>FAQ</li>
<li>Contact</li>
</ul>
Exécution du tampon de sortie avant tout contenu
ob_start();
$user_count = 0;
foreach( $users as $user ) {
if( $user['access'] != 7 ) { continue; }
?>
<li class="users user-<?php echo $user['id']; ?>">
<a href="<?php echo $user['link']; ?>">
<?php echo $user['name'] ?>
</a>
</li>
<?php
$user_count++;
}
$users_html = ob_get_clean();
if( !$user_count ) {
header('Location: /404.php');
exit();
}
?>
<html>
<head>
<title>Level 7 user results (<?php echo $user_count; ?>)</title>
</head>
<body>
<h2>We have a total of <?php echo $user_count; ?> users with access level 7</h2>
<ul class="user-list">
<?php echo $users_html; ?>
</ul>
</body>
</html>
Dans cet exemple, nous supposons que $users est un tableau multidimensionnel et nous le parcourons pour trouver tous les utilisateurs ayant un niveau d’accès de 7.
S'il n'y a pas de résultats, nous redirigeons vers une page d'erreur.
Nous utilisons le tampon de sortie ici parce que nous déclenchons une redirection d' header() fonction du résultat de la boucle
Utiliser le tampon de sortie pour stocker le contenu dans un fichier, utile pour les rapports, les factures, etc.
<?php
ob_start();
?>
<html>
<head>
<title>Example invoice</title>
</head>
<body>
<h1>Invoice #0000</h1>
<h2>Cost: £15,000</h2>
...
</body>
</html>
<?php
$html = ob_get_clean();
$handle = fopen('invoices/example-invoice.html', 'w');
fwrite($handle, $html);
fclose($handle);
Cet exemple prend le document complet et l’écrit dans un fichier, il n’envoie pas le document dans le navigateur, mais en utilisant echo $html;
Traitement du tampon via un rappel
Vous pouvez appliquer tout type de traitement supplémentaire à la sortie en transmettant un appel à ob_start() .
<?php
function clearAllWhiteSpace($buffer) {
return str_replace(array("\n", "\t", ' '), '', $buffer);
}
ob_start('clearAllWhiteSpace');
?>
<h1>Lorem Ipsum</h1>
<p><strong>Pellentesque habitant morbi tristique</strong> senectus et netus et malesuada fames ac turpis egestas. <a href="#">Donec non enim</a> in turpis pulvinar facilisis.</p>
<h2>Header Level 2</h2>
<ol>
<li>Lorem ipsum dolor sit amet, consectetuer adipiscing elit.</li>
<li>Aliquam tincidunt mauris eu risus.</li>
</ol>
<?php
/* Output will be flushed and processed when script ends or call
ob_end_flush();
*/
Sortie:
<h1>LoremIpsum</h1><p><strong>Pellentesquehabitantmorbitristique</strong>senectusetnetusetmalesuadafamesacturpisegestas.<ahref="#">Donecnonenim</a>inturpispulvinarfacilisis.</p><h2>HeaderLevel2</h2><ol><li>Loremipsumdolorsitamet,consectetueradipiscingelit.</li><li>Aliquamtinciduntmauriseurisus.</li></ol>
Flux de sortie vers le client
/**
* Enables output buffer streaming. Calling this function
* immediately flushes the buffer to the client, and any
* subsequent output will be sent directly to the client.
*/
function _stream() {
ob_implicit_flush(true);
ob_end_flush();
}
Utilisation typique et raisons d'utiliser ob_start
ob_start est particulièrement utile lorsque vous avez des redirections sur votre page. Par exemple, le code suivant ne fonctionnera pas:
Hello!
<?php
header("Location: somepage.php");
?>
L'erreur qui sera donnée est quelque chose comme: des en- headers already sent by <xxx> on line <xxx> .
Pour résoudre ce problème, vous devez écrire quelque chose comme ceci au début de votre page:
<?php
ob_start();
?>
Et quelque chose comme ça à la fin de votre page:
<?php
ob_end_flush();
?>
Cela stocke tout le contenu généré dans un tampon de sortie et l'affiche en une seule fois. Par conséquent, si vous avez des appels de redirection sur votre page, ceux-ci se déclencheront avant que des données ne soient envoyées, ce qui supprime la possibilité que des en- headers already sent erreur.