ob_start

(PHP 4, PHP 5, PHP 7, PHP 8)

ob_start — Ausgabepufferung aktivieren

Beschreibung

ob_start(?callable $callback = null, int $chunk_size = 0, int $flags = PHP_OUTPUT_HANDLER_STDFLAGS): bool

Diese Funktion aktiviert die Ausgabepufferung. Während die Ausgabepufferung aktiv ist, werden Skriptausgaben nicht direkt an den Client weitergegeben, sondern in einem internen Puffer gesammelt. Welche Ausgaben genau betroffen sind, ist unter What Output Is Buffered? beschrieben.

Ausgabepuffer können verschachtelt werden, d. h. ob_start() kann erneut aufgerufen werden, während bereits ein anderer Puffer aktiv ist. Sind mehrere Ausgabepuffer aktiv, wird die Ausgabe in der Reihenfolge der Verschachtelung durch jeden dieser Puffer gefiltert. Siehe Nesting Output Buffers für weitere Einzelheiten.

Eine ausführliche Beschreibung der Ausgabepuffer ist unter User-Level Output Buffers zu finden.

Parameter-Liste

callback

Optional kann ein callback-Callable angegeben werden. Dieses kann auch durch Übergabe von null umgangen werden.

callback wird aufgerufen, wenn der Ausgabepuffer geleert (gesendet), bereinigt oder am Ende des Skripts geleert wird.

Die Signatur von callback ist wie folgt:

handler(string $buffer, int $phase = ?): string

buffer: Der Inhalt des Ausgabepuffers.
phase: Eine Bitmaske von PHP_OUTPUT_HANDLER_*-Konstanten . Weitere Einzelheiten sind unter Flags Passed To Output Handlers zu finden.

Wenn callback false zurückgibt, wird der Inhalt des Puffers zurückgegeben. Weitere Einzelheiten sind unter Output Handler Return Values zu finden.

Warnung

Wenn eine der folgenden Funktionen innerhalb eines Ausgabe-Handlers aufgerufen wird, führt dies zu einem schwerwiegenden Fehler: ob_clean(), ob_end_clean(), ob_end_flush(), ob_flush(), ob_get_clean(), ob_get_flush(), ob_start().

Weitere Einzelheiten zu callbacks (Ausgabe-Handler) sind unter Output Handlers und Working With Output Handlers zu finden.

chunk_size

Wird der optionale Parameter chunk_size übergeben, dann wird der Puffer nach jedem Codeblock geleert, der zu einer Ausgabe führt, durch die der Puffer die Größe von chunk_size erreicht oder überschreitet. Der Vorgabewert 0 bedeutet, dass die gesamte Ausgabe gepuffert wird, bis der Puffer ausgeschaltet wird. Weitere Einzelheiten sind unter Buffer Size zu finden.

flags

Beim Parameter flags handelt es sich um eine Bitmaske, die die Operationen steuert, die mit dem Ausgabepuffer durchgeführt werden können. Die Vorgabe ist, zu erlauben, dass Ausgabepuffer bereinigt, geleert und entfernt werden dürfen, was ausdrücklich mit den Flags für die Steuerung des Ausgabepuffers . eingestellt werden kann. Weitere Einzelheiten sind unter Operations Allowed On Buffers zu finden.

Jedes Flag steuert den Zugriff auf einen Satz von Funktionen, wie im Folgenden beschrieben:

Konstante	Funktionen
`PHP_OUTPUT_HANDLER_CLEANABLE`	ob_clean()
`PHP_OUTPUT_HANDLER_FLUSHABLE`	ob_flush()
`PHP_OUTPUT_HANDLER_REMOVABLE`	ob_end_clean(), ob_end_flush(), ob_get_clean(), ob_get_flush()

Hinweis: Vor PHP 8.4.0 konnte der Parameter flags auch die Statusflags des Ausgabe-Handlers setzen.

Rückgabewerte

Gibt bei Erfolg true zurück. Bei einem Fehler wird false zurückgegeben.

Beispiele

Beispiel #1 Beispiel einer benutzerdefinierten Callback-Funktion

<?php

function callback($buffer)
{
  // ersetzt alle Äpfel mit Birnen
  return (str_replace("Äpfel", "Birnen", $buffer));
}

ob_start("callback");

?>
<html>
<body>
<p>Das ist wie Äpfel mit Birnen zu vergleichen.</p>
</body>
</html>
<?php

ob_end_flush();

?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

<html>
<body>
<p>Das ist wie Birnen mit Birnen zu vergleichen.</p>
</body>
</html>

Beispiel #2 Erzeugen eines nicht löschbaren Ausgabepuffers

<?php

ob_start(null, 0, PHP_OUTPUT_HANDLER_STDFLAGS ^ PHP_OUTPUT_HANDLER_REMOVABLE);

?>

Siehe auch

ob_get_contents() - Liefert den Inhalt des Ausgabepuffers
ob_end_clean() - Löscht den Inhalt des aktiven Ausgabepuffers und deaktiviert ihn
ob_end_flush() - Leert (sendet) den Rückgabewert des aktiven Ausgabe-Handlers und deaktiviert den aktiven Ausgabepuffer
ob_implicit_flush() - Schaltet die implizite Ausgabe ein bzw. aus
ob_gzhandler() - ob_start callback function to gzip output buffer
ob_iconv_handler() - Konvertiert Zeichensatzkodierung als Ausgabepuffer-Handler (output buffer handler)
mb_output_handler() - Callback function converts character encoding in output buffer
ob_tidyhandler() - ob_start callback function to repair the buffer

Found A Problem?

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 6 notes

down

Ray Paseur (Paseur ... ImagineDB.com) ¶

19 years ago

You can use PHP to generate a static HTML page.  Useful if you have a complex script that, for performance reasons, you do not want site visitors to run repeatedly on demand.  A "cron" job can execute the PHP script to create the HTML page.  For example:

<?php // CREATE index.html
   ob_start();
/* PERFORM COMLEX QUERY, ECHO RESULTS, ETC. */
   $page = ob_get_contents();
   ob_end_clean();
   $cwd = getcwd();
   $file = "$cwd" .'/'. "index.html";
   @chmod($file,0755);
   $fw = fopen($file, "w");
   fputs($fw,$page, strlen($page));
   fclose($fw);
   die();
?>

down

net_navard at yahoo dot com ¶

18 years ago

Hello firends

ob_start() opens a buffer in which all output is stored. So every time you do an echo, the output of that is added to the buffer. When the script finishes running, or you call ob_flush(), that stored output is sent to the browser (and gzipped first if you use ob_gzhandler, which means it downloads faster). 

The most common reason to use ob_start is as a way to collect data that would otherwise be sent to the browser.

These are two usages of ob_start():

1-Well, you have more control over the output. Trivial example: say you want to show the user an error message, but the script has already sent some HTML to the browser. It'll look ugly, with a half-rendered page and then an error message. Using the output buffering functions, you can simply delete the buffer and sebuffer and send only the error message, which means it looks all nice and neat buffer and send 
2-The reason output buffering was invented was to create a seamless transfer, from: php engine -> apache -> operating system -> web user

If you make sure each of those use the same buffer size, the system will use less writes, use less system resources and be able to handle more traffic. 

With Regards, Hossein

down

ed.oohay (a) suamhcs_rodnan ¶

21 years ago

Output Buffering even works in nested scopes or might be applied in recursive structures... thought this might save someone a little time guessing and testing :)

<pre><?php
    
    ob_start();              // start output buffer 1
    echo "a";                // fill ob1
        
        ob_start();              // start output buffer 2
        echo "b";                // fill ob2
        $s1 = ob_get_contents(); // read ob2 ("b")
        ob_end_flush();          // flush ob2 to ob1
        
    echo "c";                // continue filling ob1
    $s2 = ob_get_contents(); // read ob1 ("a" . "b" . "c")
    ob_end_flush();          // flush ob1 to browser
    
    // echoes "b" followed by "abc", as supposed to:
    echo "<HR>$s1<HR>$s2<HR>";
    
?></pre>

... at least works on Apache 1.3.28

Nandor =)

down

Asher Haig (ahaig at ridiculouspower dot com) ¶

17 years ago

When a script ends, all buffered output is flushed (this is not a bug: http://bugs.php.net/bug.php?id=42334&thanks=4). What happens when the script throws an error (and thus ends) in the middle of an output buffer? The script spits out everything in the buffer before printing the error!

Here is the simplest solution I have been able to find. Put it at the beginning of the error handling function to clear all buffered data and print only the error:

$handlers = ob_list_handlers();
while ( ! empty($handlers) )    {
    ob_end_clean();
    $handlers = ob_list_handlers();
}

down

Chris ¶

14 years ago

Careful with while using functions that change headers of a page; that change will not be undone when ending output buffering.

If you for instance have a class that generates an image and sets the appropriate headers, they will still be in place after the end of ob.

For instance:
<?php
  ob_start();
  myClass::renderPng(); //header("Content-Type: image/png"); in here
  $pngString = ob_get_contents();
  ob_end_clean();
?>

will put the image bytes into $pngString, and set the content type to image/png. Though the image will not be sent to the client, the png header is still in place; if you do html output here, the browser will most likely display "image error, cannot be viewed", at least firefox does.

You need to set the correct image type (text/html) manually in this case.

down

ernest at vogelsinger dot at ¶

19 years ago

When you rely on URL rewriting to pass the PHP session ID you should be careful with ob_get_contents(), as this might disable URL rewriting completely.

Example:
ob_start();
session_start();
echo '<a href=".">self link</a>';
$data = ob_get_contents();
ob_end_clean();
echo $data;

In the example above, URL rewriting will never occur. In fact, rewriting would occur if you ended the buffering envelope using ob_end_flush(). It seems to me that rewriting occurs in the very same buffering envelope where the session gets started, not at the final output stage.

If you need a scenario like the one above, using an "inner envelope" will help:

ob_start();
ob_start();   // add the inner buffering envelope
session_start();
echo '<a href=".">self link</a>';
ob_end_flush(); // closing the inner envelope will activate URL rewriting
$data = ob_get_contents();
ob_end_clean();
echo $data;

In case you're interested or believe like me that this is rather a design flaw instead of a feature, please visit bug #35933 (http://bugs.php.net/bug.php?id=35933) and comment on it.

＋add a note