diff --git a/reference/outcontrol/flushing-system-buffers.xml b/reference/outcontrol/flushing-system-buffers.xml
new file mode 100644
index 000000000..8c7407523
--- /dev/null
+++ b/reference/outcontrol/flushing-system-buffers.xml
@@ -0,0 +1,161 @@
+
+
+
+
+ Leeren (senden) der Systempuffer
+
+ PHP bietet zwei Möglichkeiten, die Systempuffer zu leeren (den Inhalt zu
+ senden und zu löschen):
+ Durch den Aufruf von flush und durch die Aktivierung des
+ impliziten Leerens mittels ob_implicit_flush oder der
+ &php.ini;-Direktive implicit_flush.
+
+
+
+ Verhalten beim Leeren des Ausgabepuffers
+
+ Wenn das implizite Leeren des Ausgabepuffers deaktiviert ist, leert ihn PHP
+ nur dann, wenn flush aufgerufen wird oder wenn das
+ Skript endet.
+
+
+ Wenn das implizite Leeren des Ausgabepuffers aktiviert ist, versucht PHP ihn
+ nach jedem Codeblock, der zu einer Ausgabe führt, zu leeren.
+ Ausgabe sind in diesem Zusammenhang Daten mit einer Länge ungleich Null:
+
+
+
+ außerhalb der Tags <?php ?>
+
+
+
+
+ die von Sprachkonstrukten und Funktionen ausgegeben werden, deren
+ ausdrücklicher Zweck es ist, vom Benutzer bereitgestellte Variablen oder
+ Zeichenketten auszugeben, &zb; echo,
+ print, printf,
+ var_dump, var_export,
+ vprintf
+
+
+
+
+ die von Funktionen ausgegeben werden, deren Zweck es ist,
+ Daten/Informationen über das laufende Skript oder PHP zu sammeln und
+ auszugeben, &zb; debug_print_backtrace,
+ phpcredits, phpinfo,
+ ReflectionExtension::info
+
+
+
+
+ die von PHP bei einer nicht abgefangenen Exception oder einem nicht
+ behandelten Fehler ausgegeben werden (abhängig von den Einstellungen von
+ display_errors und
+ error_reporting)
+
+
+
+
+ alles, was auf php://output geschrieben wird
+
+
+
+
+
+
+ Die Ausgabe leerer Zeichenketten und das Senden von Headern werden nicht
+ als Ausgabe betrachtet und führt nicht zu einem Leeren des Puffers.
+
+
+
+
+ Wenn das implizite Leeren aktiviert ist, führen auch Steuerzeichen (&zb;
+ "\n", "\r", "\0")
+ zum Leeren.
+
+
+
+
+
+ Einschränkungen
+
+ Mit dieser Funktionalität können die Ausgabepuffer der Benutzerebene nicht
+ geleert werden. Um diese zusammen mit den Systempuffern zu verwenden, müssen
+ die Ausgabepuffer der Benutzerebene vor den Systempuffern geleert werden,
+ damit PHP überhaupt eine Ausgabe erzeugen kann.
+
+
+
+ Wenn die Funktion flush aufgerufen wird oder
+ implizites Leeren aktiviert ist, besteht die Gefahr, dass die
+ Ausgabehandler von Ausgabepuffern auf Benutzerebene, die Header in einem
+ Web-Kontext setzen und senden (&zb; ob_gzhandler),
+ gestört werden, indem die Header gesendet werden, bevor diese Handler dies
+ tun können.
+
+
+
+ Die von der zugrundeliegenden Software/Hardware implementierte Pufferung
+ kann von PHP nicht außer Kraft gesetzt werden und sollte bei der Arbeit mit
+ den PHP-Funktionen zur Pufferungssteuerung berücksichtigt werden.
+ Die Überprüfung der Pufferungseinstellungen des Webservers, des Browsers und
+ der Konsole und die Beschäftigung damit kann mögliche Probleme verringern.
+ Bei der Arbeit in einem Web-Kontext können entweder die
+ Pufferungseinstellungen des Webservers oder die Pufferung des Skripts so
+ angepasst werden, dass sie zusammenarbeiten, während die
+ Pufferungsstrategien der verschiedenen Browser umgangen werden können, indem
+ die Pufferung im PHP-Skript angepasst wird.
+ Auf Konsolen, die eine Zeilenpufferung implementieren, könnten vor dem
+ Leeren der Ausgabe an den entsprechenden Stellen Zeilenumbrüche eingefügt
+ werden.
+
+
+
+
+ Unterschiede zwischen den <acronym>SAPI</acronym>s beim Leeren
+
+ Obwohl das Leeren der Puffer von jeder SAPI auf eine
+ etwas andere Weise implementiert wird, fallen diese Implementierungen in
+ eine von zwei Kategorien:
+
+
+
+ SAPIs, die in einem Web-Kontext verwendet werden,
+ leeren zuerst die Header und dann die Ausgabe;
+ Apache2Handler, CGI
+ FastCGI und FPM sind solche
+ SAPIs.
+
+
+
+
+ andere SAPIs wie CLI und
+ embed leeren nur die Ausgabe
+
+
+
+
+
+
+
+
diff --git a/reference/outcontrol/functions/ob-get-clean.xml b/reference/outcontrol/functions/ob-get-clean.xml
new file mode 100644
index 000000000..efd28bcea
--- /dev/null
+++ b/reference/outcontrol/functions/ob-get-clean.xml
@@ -0,0 +1,128 @@
+
+
+
+
+
+
+ ob_get_clean
+ Ruft den Inhalt des aktiven Ausgabepuffers ab und deaktiviert ihn
+
+
+
+ &reftitle.description;
+
+ stringfalseob_get_clean
+
+
+
+ Diese Funktion ruft den Ausgabe-Handler auf (mit den Flags
+ PHP_OUTPUT_HANDLER_CLEAN und
+ PHP_OUTPUT_HANDLER_FINAL), verwirft dessen
+ Rückgabewert, gibt den Inhalt des aktiven Ausgabepuffers zurück und schaltet
+ den aktiven Ausgabepuffer ab.
+
+
+ ob_get_clean schlägt fehl, wenn der aktive
+ Ausgabepuffer ohne das Flag
+ PHP_OUTPUT_HANDLER_REMOVABLE gestartet wurde.
+
+
+ ob_get_clean entfernt den Inhalt des aktiven
+ Ausgabepuffers auch dann, wenn er ohne das Flag
+ PHP_OUTPUT_HANDLER_CLEANABLE gestartet wurde.
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ Gibt bei Erfolg den Inhalt des aktiven Ausgabepuffers zurück oder &false;
+ bei einem Fehler.
+
+
+
+ Wenn es keinen aktiven Ausgabepuffer gibt, gibt
+ ob_get_clean false zurück, erzeugt aber keine Meldung
+ der Stufe E_NOTICE.
+
+
+
+
+
+ &reftitle.errors;
+
+ Wenn die Funktion fehlschlägt, erzeugt sie ein E_NOTICE.
+
+
+
+
+ &reftitle.examples;
+
+
+ Ein einfaches <function>ob_get_clean</function>-Beispiel
+
+
+]]>
+
+ &example.outputs;
+
+
+
+
+
+
+
+
+ &reftitle.seealso;
+
+
+ ob_start
+ ob_get_contents
+ ob_clean
+ ob_end_clean
+ ob_get_flush
+
+
+
+
+
+
diff --git a/reference/outcontrol/functions/ob-get-flush.xml b/reference/outcontrol/functions/ob-get-flush.xml
new file mode 100644
index 000000000..97711060f
--- /dev/null
+++ b/reference/outcontrol/functions/ob-get-flush.xml
@@ -0,0 +1,127 @@
+
+
+
+
+
+
+ ob_get_flush
+
+ Leert (sendet) den Rückgabewert des aktiven Ausgabe-Handlers, gibt den
+ Inhalt des aktiven Ausgabepuffers zurück und deaktiviert ihn
+
+
+
+
+ &reftitle.description;
+
+ stringfalseob_get_flush
+
+
+
+ Diese Funktion ruft den Ausgabe-Handler auf (mit dem Flag
+ PHP_OUTPUT_HANDLER_FINAL), leert (sendet) dessen
+ Rückgabewert, gibt den Inhalt des aktiven Ausgabepuffers zurück und schaltet
+ den aktiven Ausgabepuffer ab.
+
+
+ ob_get_flush schlägt fehl, wenn der aktive
+ Ausgabepuffer ohne das Flag
+ PHP_OUTPUT_HANDLER_REMOVABLE gestartet wurde.
+
+
+ ob_get_flush leert (sendet) den Rückgabewert des
+ Ausgabe-Handlers auch dann, wenn er ohne das Flag
+ PHP_OUTPUT_HANDLER_FLUSHABLE gestartet wurde.
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ Gibt bei Erfolg den Inhalt des aktiven Ausgabepuffers zurück oder &false;
+ bei einem Fehler.
+
+
+
+
+ &reftitle.errors;
+
+ Wenn die Funktion fehlschlägt, erzeugt sie eine Meldung der Stufe
+ E_NOTICE.
+
+
+
+
+ &reftitle.examples;
+
+
+ <function>ob_get_flush</function>-Beispiel
+
+
+]]>
+
+ &example.outputs;
+
+ default output handler
+)
+Array
+(
+)
+]]>
+
+
+
+
+
+
+ &reftitle.seealso;
+
+
+ ob_start
+ ob_get_contents
+ ob_flush
+ ob_end_flush
+ ob_get_clean
+
+
+
+
+
+
diff --git a/reference/outcontrol/functions/ob-get-length.xml b/reference/outcontrol/functions/ob-get-length.xml
new file mode 100644
index 000000000..676395924
--- /dev/null
+++ b/reference/outcontrol/functions/ob-get-length.xml
@@ -0,0 +1,100 @@
+
+
+
+
+
+
+ ob_get_length
+ Liefert die Größe des Ausgabepuffers
+
+
+
+ &reftitle.description;
+
+ intfalseob_get_length
+
+
+
+ Diese Funktion gibt die Größe des Inhalts des Ausgabepuffers in Bytes zurück.
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ Gibt die Größe des Inhalts des Ausgabepuffers in Bytes zurück, oder &false;
+ wenn die Pufferung nicht aktiv ist.
+
+
+
+
+ &reftitle.examples;
+
+
+ Ein einfaches <function>ob_get_length</function>-Beispiel
+
+
+]]>
+
+ &example.outputs;
+
+
+
+
+
+
+
+
+ &reftitle.seealso;
+
+
+ ob_start
+ ob_get_contents
+
+
+
+
+
+
diff --git a/reference/outcontrol/functions/ob-get-status.xml b/reference/outcontrol/functions/ob-get-status.xml
new file mode 100644
index 000000000..e91c598c9
--- /dev/null
+++ b/reference/outcontrol/functions/ob-get-status.xml
@@ -0,0 +1,222 @@
+
+
+
+
+
+
+ ob_get_status
+ Ermittelt den Status von Ausgabepuffern
+
+
+
+ &reftitle.description;
+
+ arrayob_get_status
+ boolfull_status&false;
+
+
+ ob_get_status gibt die Statusinformationen über den
+ Ausgabepuffer der obersten Ebene zurück oder, wenn
+ full_status auf &true; gesetzt ist, über die aktiven
+ Ausgabepuffer aller Ebenen.
+
+
+
+
+ &reftitle.parameters;
+
+
+
+ full_status
+
+
+ &true;, damit der Status der aktiven Ausgabepuffer aller Ebenen
+ zurückgegeben werden. Wenn &false; oder nicht gesetzt, wird nur der
+ Status des Ausgabepuffers der oberste Ebene zurückgegeben.
+
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ Wenn full_status weggelassen wird oder &false; ist,
+ wird ein einfaches Array mit Statusinformationen über die aktive
+ Ausgabeebene zurückgegeben.
+
+
+ Wenn full_status &true; ist, wird ein Array mit
+ jeweils einem Element für jede aktive Ausgabepuffer-Ebene zurückgegeben.
+ Die Ausgabeebene wird als Schlüssel des Arrays der obersten Ebene verwendet
+ und jedes Array-Element selbst ist ein weiteres Array, das
+ Statusinformationen über eine aktive Ausgabeebene enthält.
+
+
+ Wenn die Ausgabepufferung nicht aktiviert ist, wird ein leeres Array
+ zurückgegeben.
+
+
+
+ Die Elemente des von <function>ob_get_status</function> zurückgegebenen Arrays
+ SchlüsselWert
+
+ name
+
+ Der Name des aktiven Ausgabe-Handlers (siehe die Rückgabewerte von
+ ob_list_handlers für Details)
+
+
+
+ type
+
+ 0 (interner Handler) oder
+ 1 (benutzerdefinierter Handler)
+
+
+
+ flags
+
+ Die Bitmaske der von ob_start gesetzten Flags, des
+ Typs des Ausgabe-Handlers (siehe oben) und des Status des
+ Pufferungsprozesses
+ (PHP_OUTPUT_HANDLER_*-Konstanten).
+ Wenn der Handler den Puffer erfolgreich verarbeitet und nicht &false;
+ zurückgegeben hat, werden die Konstanten
+ PHP_OUTPUT_HANDLER_STARTED und
+ PHP_OUTPUT_HANDLER_PROCESSED gesetzt.
+ Wenn der Handler den Puffer nicht verarbeiten konnte oder &false;
+ zurückgegeben hat, werden die Konstanten
+ PHP_OUTPUT_HANDLER_STARTED und
+ PHP_OUTPUT_HANDLER_DISABLED gesetzt.
+
+
+
+ level
+
+ Die Verschachtelungsebene der Ausgabe (beginnend bei Null). Es ist zu
+ beachten, dass der Wert, der von ob_get_level für
+ dieselbe Ebene zurückgegeben wird, um eins abweicht.
+ Für ob_get_status ist die erste Ebene
+ 0 und für ob_get_level
+ 1.
+
+
+
+ chunk_size
+
+ Die Größe eines Blocks in Bytes. Wird gesetzt durch
+ ob_start oder
+ output_buffering, wenn diese
+ Option aktiviert ist und ihr Wert auf eine positive Ganzzahl gesetzt ist
+
+
+
+ buffer_size
+
+ Die Größe des Ausgabepuffers in Bytes
+
+
+
+ buffer_used
+
+ Die Größe der Daten im Ausgabepuffer in Bytes (entspricht dem
+ Integer-Rückgabewert von ob_get_length)
+
+
+
+
+
+
+
+ &reftitle.examples;
+
+
+ Das Array, das zurückgegeben wird, wenn <parameter>full_status</parameter> &false; ist
+
+ URL-Rewriter
+ [type] => 0
+ [flags] => 112
+ [level] => 2
+ [chunk_size] => 0
+ [buffer_size] => 16384
+ [buffer_used] => 1024
+)
+]]>
+
+
+
+
+
+ Das Array, das zurückgegeben wird, wenn <parameter>full_status</parameter> &true; ist
+
+ Array
+ (
+ [name] => default output handler
+ [type] => 0
+ [flags] => 112
+ [level] => 1
+ [chunk_size] => 0
+ [buffer_size] => 16384
+ [buffer_used] => 2048
+ )
+
+ [1] => Array
+ (
+ [name] => URL-Rewriter
+ [type] => 0
+ [flags] => 112
+ [level] => 2
+ [chunk_size] => 0
+ [buffer_size] => 16384
+ [buffer_used] => 1024
+ )
+
+)
+]]>
+
+
+
+
+
+
+ &reftitle.seealso;
+
+
+ ob_get_level
+ ob_list_handlers
+ ob_get_length
+ ob_start
+
+
+
+
+
+
diff --git a/reference/outcontrol/functions/ob-list-handlers.xml b/reference/outcontrol/functions/ob-list-handlers.xml
new file mode 100644
index 000000000..25f88a64c
--- /dev/null
+++ b/reference/outcontrol/functions/ob-list-handlers.xml
@@ -0,0 +1,219 @@
+
+
+
+
+
+
+ ob_list_handlers
+ Listet alle verwendeten Ausgabe-Handler auf
+
+
+
+ &reftitle.description;
+
+ arrayob_list_handlers
+
+
+
+ Listet alle verwendeten Ausgabe-Handler auf.
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ Diese Funktion gibt ein Array mit den verwendeten Ausgabe-Handlern zurück
+ (falls vorhanden).
+
+
+ Wenn output_buffering aktiviert
+ ist und output_handler nicht
+ gesetzt ist oder kein Callback oder &null; an ob_start
+ übergeben wurde, wird "default output handler"
+ zurückgegeben. Das Aktivieren von
+ output_buffering und das Setzen
+ von output_handler entspricht der
+ Übergabe einer
+ internen (eingebauten) Funktion an
+ ob_start.
+
+
+ Wenn ein Callable an ob_start übergeben
+ wurde, wird der
+ vollständig qualifizierte Name
+ des Callables zurückgegeben. Wenn das Callable ein
+ Objekt ist, das __invoke()
+ implementiert, wird der
+ vollständig qualifizierte Name
+ der __invoke()-Methode des
+ Objekts zurückgegeben. Handelt es sich bei der Callable um eine
+ Closure, wird "Closure::__invoke"
+ zurückgegeben.
+
+
+
+
+ &reftitle.examples;
+
+
+ <function>ob_list_handlers</function>-Beispiel
+
+ $string);
+var_dump(ob_list_handlers());
+ob_end_flush();
+
+// Callback-Funktion als Objekt erster Klasse
+$firstClassCallable = userDefinedFunction(...);
+
+ob_start([$firstClassCallable, '__invoke']);
+var_dump(ob_list_handlers());
+ob_end_flush();
+
+// Interne (eingebaute) Funktion
+ob_start('print_r');
+var_dump(ob_list_handlers());
+ob_end_flush();
+
+// Benutzerdefinierte Funktion
+function userDefinedFunction($string, $flags) { return $string; };
+
+ob_start('userDefinedFunction');
+var_dump(ob_list_handlers());
+ob_end_flush();
+
+class MyClass {
+ public static function staticHandle($string) {
+ return $string;
+ }
+
+ public static function handle($string) {
+ return $string;
+ }
+
+ public function __invoke($string) {
+ return $string;
+ }
+}
+
+// Klasse und statische Methode
+ob_start(['MyClass','staticHandle']);
+var_dump(ob_list_handlers());
+ob_end_flush();
+
+// Objekt und nicht-statische Methode
+ob_start([new MyClass,'handle']);
+var_dump(ob_list_handlers());
+ob_end_flush();
+
+// Aufrufbares Objekt
+ob_start(new MyClass);
+var_dump(ob_list_handlers());
+ob_end_flush();
+?>
+]]>
+
+ &example.outputs;
+
+
+ string(22) "default output handler"
+}
+array(1) {
+ [0]=>
+ string(22) "default output handler"
+}
+array(1) {
+ [0]=>
+ string(7) "print_r"
+}
+array(1) {
+ [0]=>
+ string(19) "userDefinedFunction"
+}
+array(1) {
+ [0]=>
+ string(17) "Closure::__invoke"
+}
+array(1) {
+ [0]=>
+ string(17) "Closure::__invoke"
+}
+array(1) {
+ [0]=>
+ string(17) "Closure::__invoke"
+}
+array(1) {
+ [0]=>
+ string(21) "MyClass::staticHandle"
+}
+array(1) {
+ [0]=>
+ string(15) "MyClass::handle"
+}
+array(1) {
+ [0]=>
+ string(17) "MyClass::__invoke"
+}
+]]>
+
+
+
+
+
+
+ &reftitle.seealso;
+
+
+ ob_end_clean
+ ob_end_flush
+ ob_get_flush
+ ob_start
+
+
+
+
+
+
+
diff --git a/reference/outcontrol/functions/output-reset-rewrite-vars.xml b/reference/outcontrol/functions/output-reset-rewrite-vars.xml
new file mode 100644
index 000000000..4529c7932
--- /dev/null
+++ b/reference/outcontrol/functions/output-reset-rewrite-vars.xml
@@ -0,0 +1,132 @@
+
+
+
+
+
+
+ output_reset_rewrite_vars
+ Setzt die Werte des URL-Rewriters zurück
+
+
+
+ &reftitle.description;
+
+ booloutput_reset_rewrite_vars
+
+
+
+ Diese Funktion entfernt alle Rewrite-Variablen, die zuvor mit der Funktion
+ output_add_rewrite_var gesetzt wurden.
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ &return.success;
+
+
+
+
+ &reftitle.changelog;
+
+
+
+
+
+ &Version;
+ &Description;
+
+
+
+
+ 7.1.0
+
+ Vor PHP 7.1.0 verwendeten die mittels
+ output_add_rewrite_var definierten
+ Rewrite-Variablen denselben trans-sid-Ausgabepuffer wie das
+ Session-Modul. Seit PHP 7.1.0 wird ein eigener Ausgabepuffer verwendet
+ und output_reset_rewrite_vars entfernt nur die
+ mittels output_add_rewrite_var definierten
+ Rewrite-Variablen.
+
+
+
+
+
+
+
+
+
+ &reftitle.examples;
+
+
+ <function>output_reset_rewrite_vars</function>-Beispiel
+
+link';
+ob_flush();
+
+output_reset_rewrite_vars();
+echo 'link';
+?>
+]]>
+
+ &example.outputs;
+
+link
+link
+]]>
+
+
+
+
+
+
+ &reftitle.seealso;
+
+
+ output_add_rewrite_var
+ ob_flush
+ ob_list_handlers
+ url_rewriter.tags
+ url_rewriter.hosts
+ session.trans_sid_tags
+ session.trans_sid_hosts
+
+
+
+
+
+
+
diff --git a/reference/outcontrol/output-buffering.xml b/reference/outcontrol/output-buffering.xml
new file mode 100644
index 000000000..466d0cefe
--- /dev/null
+++ b/reference/outcontrol/output-buffering.xml
@@ -0,0 +1,120 @@
+
+
+
+
+ Ausgabepufferung
+
+ Bei der Ausgabepufferung wird die Ausgabe gepuffert (vorübergehend
+ gespeichert), bevor sie an den Browser (in einem Web-Kontext) oder an die
+ Shell (in der Befehlszeile) gesendet und dann verworfen wird.
+ Während die Ausgabepufferung aktiv ist, wird keine Ausgabe vom Skript
+ gesendet und die Ausgabe wird stattdessen in einem internen Puffer
+ gespeichert.
+
+
+
+ Pufferung, die sich auf PHP auswirkt
+
+
+ PHP ist auf die zugrunde liegende Hardware- und Software-Infrastruktur angewiesen, um die Ausgabe zurückzusetzen. Die Pufferung, die von Konsolen auf der Kommandozeile (z.B. mit Zeilenpufferung) oder von Webservern und dem Browser in einem Webkontext (z.B. mit vollständiger Pufferung) implementiert wird, wirkt sich darauf aus, wann die Ausgabe dem Endbenutzer angezeigt wird. Einige dieser Effekte lassen sich durch eine Feinabstimmung der Servereinstellungen und/oder eine Angleichung der Puffergrößen auf verschiedenen Ebenen beseitigen.
+
+
+ PHP relies on the underlying software/hardware infrastructure
+ when flushing output.
+ Buffering implemented by consoles on the command line (e.g. line buffered)
+ or web servers and browser in a web context (e.g. fully buffered)
+ do affect when output is displayed to the end-user.
+ Some of these effects can be eliminated by fine-tuning server settings
+ and/or aligning buffer sizes of the various layers.
+
+
+
+
+ Output Buffering Control In PHP
+
+ PHP provides a fully buffered user-level output buffer
+ with functions to start, manipulate and turn off the buffer
+ (most ob_* functions),
+ and two functions to flush the underlying system buffers
+ (flush and ob_implicit_flush).
+ Some of this functionality can be set and/or configured
+ using the appropriate &php.ini; settings as well.
+
+
+
+
+ Use Cases
+
+ Output buffering is generally useful in situations when the buffered output
+ is modified or inspected, or it is used more than once in a request;
+ or when the controlled flushing of output is desired.
+ Specific use cases include:
+
+
+
+ caching the result of compute/time intensive scripts
+ for example by generating static HTML pages
+
+
+
+
+ re-using the generated output by displaying it, saving it to a file
+ and/or sending it by email
+
+
+
+
+ flushing the head of an HTML page
+ separate from the body allows browsers
+ to load external resources while the script executes
+ potentially more time consuming processes
+ (e.g. database/file access, external network connection).
+ This is only useful if the HTTP status code
+ cannot change after the headers are sent
+
+
+
+
+ extracting information from functions that would otherwise produce output
+ (e.g. phpinfo)
+
+
+
+
+ controlling the output of third-party code by modifying/using parts
+ (e.g. extracting data, replacing words/phrases,
+ adding missing HTML tags),
+ or discarding it entirely under certain conditions (e.g. errors)
+
+
+
+
+ polyfilling certain unavailable web server functionality
+ (e.g. compressing or encoding output)
+
+
+
+
+
+
+
+
diff --git a/reference/outcontrol/user-level-output-buffers.xml b/reference/outcontrol/user-level-output-buffers.xml
new file mode 100644
index 000000000..c87356bf6
--- /dev/null
+++ b/reference/outcontrol/user-level-output-buffers.xml
@@ -0,0 +1,656 @@
+
+
+
+
+ Ausgabepuffer auf Benutzerebene
+
+ Die Ausgabepuffer auf Benutzerebene können über PHP-Code gestartet,
+ manipuliert und beendet werden.
+ Jeder dieser Puffer besteht aus einem Ausgabepuffer und einer zugehörigen
+ Funktion für die Ausgabeverarbeitung.
+
+
+
+ Welche Ausgaben werden gepuffert?
+
+ PHPs Ausgabepuffer auf Benutzerebene puffern alle Ausgaben, nachdem sie gestartet wurden, bis sie ausgeschaltet werden oder das Skript endet. Die Ausgabe im Kontext des PHP-Ausgabepuffers auf Benutzerebene ist alles, was PHP anzeigen oder an den Browser zurücksenden würde. Praktisch gesehen sind die Ausgaben Daten mit einer Länge ungleich Null:
+
+ PHPs Ausgabepuffer auf Benutzerebene puffern nach ihrem Start die gesamte Ausgabe, bis sie deaktiviert werden oder das Skript beendet wird. Die Ausgabe im Kontext von PHPs Ausgabepuffern auf Benutzerebene ist alles, was PHP anzeigen oder an den Browser senden würde. Praktisch ausgedrückt ist die Ausgabe alle Daten mit einer Länge ungleich Null, die :
+
+ Der PHP-Ausgabepuffer auf Benutzerebene puffert alle Ausgaben ab dem Moment des Starts, bis die Pufferung ausgeschaltet oder das Skript beendet wird. Die Ausgabe im PHP-Ausgabepuffer auf Benutzerebene bezieht sich auf alles, was PHP anzeigt oder an den Browser zurückschickt. Praktisch gesehen sind Ausgaben Daten mit einer Länge ungleich Null, wie z.B.
+
+ PHPs Ausgabepuffer auf Benutzerebene speichern alle Ausgaben, nachdem sie gestartet wurden, bis sie abgeschaltet werden oder das Skript beendet wird. Die Ausgabe im Zusammenhang mit dem PHP-Ausgabepuffer auf Benutzerebene ist alles, was PHP anzeigen oder an den Browser zurücksenden würde. Praktisch gesehen sind die Ausgaben Daten mit einer Länge ungleich Null, also:
+
+ Benutzerdefinierte PHP-Ausgabepuffer puffern, sobald sie gestartet wurden, die Ausgabe vollständig, bis sie geschlossen werden oder das Skript beendet wird. Die Ausgabe im Kontext eines benutzerdefinierten PHP-Ausgabepuffers ist alles, was PHP angezeigt oder an den Browser zurückgeschickt hat. Praktisch gesehen sind die Ausgaben Daten mit einer Länge ungleich Null, die:
+
+
+
+
+
+
+
+ Die PHP-Ausgabepuffer auf Benutzerebene puffern alle Ausgaben, nachdem sie gestartet wurden, bis sie ausgeschaltet werden oder das Skript endet.
+ Die Ausgabe im Zusammenhang mit dem PHP-Ausgabepuffer auf Benutzerebene ist alles, was PHP anzeigen oder an den Browser zurücksenden würde.
+ Praktisch gesehen sind die Ausgaben Daten mit einer Länge ungleich Null:
+
+ Der PHP-Ausgabepuffer auf Benutzerebene puffert alle Ausgaben, nachdem er gestartet wurde, bis er deaktiviert oder das Skript beendet wird.
+ Die Ausgabe des PHP-Ausgabepuffers auf Benutzerebene ist alles, was PHP anzeigen oder an den Browser zurückgeben würde.
+ In der Praxis sind die Ausgaben Daten mit einer Länge ungleich Null:
+
+ PHP's user-level output buffers buffer all output after they are started
+ until they are turned off or the script ends.
+ Output in the context of PHP's user-level output buffer
+ is everything that PHP would display or send back to the browser.
+ In practical terms, output is non-zero length data that is:
+
+
+
+
+
+
+ Data that is written directly to stdout
+ or passed to an SAPI function with a similar functionality
+ will not be captured by user-level output buffers.
+ This includes
+ writing data to stdout with fwrite
+ or sending headers using header
+ or setcookie.
+
+
+
+
+
+ Turning Output Buffering On
+
+ Output buffering can be turned on by using
+ the ob_start function or by setting
+ the output_buffering
+ and output_handler
+ &php.ini; settings.
+ While both can create output buffers,
+ ob_start is more flexible
+ as it accepts user-defined functions as output handlers
+ and the operations allowed on the buffer (flush, clean, remove)
+ can be set as well.
+ Buffers started with ob_start will be active
+ from the line the function was called,
+ while those started with
+ output_buffering
+ will be buffering output from the first line of the script.
+
+
+ PHP is also shipped with a built-in "URL-Rewriter"
+ output handler which starts its own output buffer and only allows
+ up to two instances of it running at any time
+ (one for user-level URL-rewriting
+ and one for transparent session id support).
+ These buffers can be started by calling
+ the output_add_rewrite_var function
+ and/or by enabling the
+ session.use_trans_sid
+ &php.ini; setting.
+
+
+ The bundled zlib extension has its own
+ output buffer which can be enabled by using the
+ zlib.output_compression
+ &php.ini; setting.
+
+
+
+ While "URL-Rewriter" is special
+ in that it only allows up to two instances of it running at any one time,
+ all user-level output buffers use the same underlying buffers
+ used by ob_start
+ with their functionality implemented by a custom output handler function.
+ As such, all of their functionality can be emulated by userland code.
+
+
+
+
+
+ Nesting Output Buffers
+
+ If there is an output buffer active when a new buffer is started,
+ the new buffer will be nested inside the previously active buffer.
+ The inner buffer will behave the same way regardless whether it is nested
+ but output buffered by it will not be buffered by the outer buffer.
+ Only output flushed by the inner buffer will be buffered by the outer buffer.
+
+
+ Most ob_* functions only work
+ with the active output buffer (the last one started)
+ therefore only the active buffer can be flushed, cleaned and turned off.
+ The functions that work with other buffers are
+ ob_list_handlers
+ which returns the list of all output handlers in use
+ and ob_get_status
+ which can return information on the active buffer only
+ or on all buffers in use.
+
+
+ Calling ob_get_level
+ or ob_get_status will return
+ the nesting level of the active output buffer.
+
+
+
+ The value for identical levels between ob_get_level
+ and ob_get_status is off by one.
+ For ob_get_level
+ the first level is 1,
+ whereas for ob_get_status
+ the first level is 0.
+
+
+
+
+
+ Buffer Size
+
+ Buffer sizes are expressed by integers
+ and represent the number of bytes the buffer can store without flushing.
+ When the size of output in the buffer exceeds the size of the buffer,
+ the contents of the buffer are sent to the output handler,
+ its return value is flushed and the buffer is cleared.
+
+
+ With the exception of "URL-Rewriter",
+ the size of output buffers can be set when the buffer is started.
+ If set to 0,
+ the output buffer is only limited by the memory available to PHP.
+ If set to 1,
+ the buffer is flushed after every block of code producing
+ any non-zero length output.
+
+
+ The size of output buffers can be retrieved by calling
+ ob_get_status.
+
+
+ Output buffers started with ob_start
+ will have their buffer sizes set to the integer value passed to
+ the function's second chunk_size parameter.
+ If omitted, it is set to 0.
+
+
+ The output buffer started with
+ output_buffering
+ set to "On" will have its buffer size set to 0.
+ If set to an integer than buffer size will correspond to that number.
+
+
+ "URL-Rewriter"'s buffer size is set to 0,
+ therefore it is only limited by the memory available to PHP.
+
+
+ The size of zlib's output buffer is controlled by the
+ zlib.output_compression
+ &php.ini; setting.
+ If set to "On" the buffer size will be
+ "16K"/16384.
+ If set to an integer then buffer size will correspond to that number in bytes.
+
+
+
+
+ Operations Allowed On Buffers
+
+ The operations allowed on buffers can be controlled
+ by passing one of the
+ buffer control flags
+ to ob_start's third
+ flags parameter.
+ If omitted, all operations are allowed by default.
+ If 0 is used instead,
+ the buffer cannot be flushed, cleaned or removed
+ but it's contents can still be retrieved.
+
+
+ PHP_OUTPUT_HANDLER_CLEANABLE allows
+ ob_clean to clean the contents of the buffer.
+
+
+
+ The absence of the PHP_OUTPUT_HANDLER_CLEANABLE flag
+ will not prevent ob_end_clean
+ or ob_get_clean from clearing the contents of the buffer.
+
+
+
+ PHP_OUTPUT_HANDLER_FLUSHABLE allows
+ ob_flush to flush the contents of the buffer.
+
+
+
+ The absence of the PHP_OUTPUT_HANDLER_FLUSHABLE flag
+ will not prevent ob_end_flush
+ or ob_get_flush from flushing the contents of the buffer.
+
+
+
+ PHP_OUTPUT_HANDLER_REMOVABLE allows
+ ob_end_clean, ob_end_flush,
+ ob_get_clean or ob_get_flush
+ to turn off the buffer.
+
+
+ PHP_OUTPUT_HANDLER_STDFLAGS,
+ the combination of the three flags will allow each of the three operations
+ to be performed on the buffer.
+
+
+
+
+ Flushing, Accessing And Cleaning Buffer Contents
+
+ Flushing sends and discards the contents of the active buffer.
+ Output buffers get flushed when the size of the output
+ exceeds the size of the buffer; the script ends or
+ ob_flush, ob_end_flush
+ or ob_get_flush is called.
+
+
+
+ Calling ob_end_flush
+ or ob_get_flush will turn off the active buffer.
+
+
+
+
+ Flushing buffers will flush the return value of the output handler
+ which can differ from the contents of the buffer.
+ For example, using ob_gzhandler will compress
+ the output and flush the compressed output.
+
+
+
+ The contents of the active buffer can be retrieved by calling
+ ob_get_contents, ob_get_clean
+ or ob_get_flush.
+
+
+ If only the length of the buffer's contents are needed,
+ ob_get_length or ob_get_status
+ will return the length of the contents in bytes.
+
+
+
+ Calling ob_get_clean
+ or ob_get_flush will turn off the active buffer
+ after returning the its contents.
+
+
+
+ The contents of the active buffer can be cleaned by calling
+ ob_clean, ob_end_clean
+ or ob_get_clean.
+
+
+
+ Calling ob_end_clean
+ or ob_get_clean will turn off the active buffer.
+
+
+
+
+
+ Turning Buffers Off
+
+ Output buffers can be turned off by calling
+ ob_end_clean, ob_end_flush,
+ ob_get_flush or ob_get_clean.
+
+
+
+ Output buffers started without the
+ PHP_OUTPUT_HANDLER_REMOVABLE flag
+ cannot be turned off and may generate an E_NOTICE.
+
+
+
+ Every output buffer that has not been closed by the end of the script
+ or when exit is called will be flushed
+ and turned off by PHP's shutdown process.
+ The buffers will be flushed and turned off in reverse order
+ of their starting up.
+ The last buffered started will be first,
+ the first buffer started will be last to be flushed and turned off.
+
+
+
+ If flushing of the buffer's contents is not desired,
+ a custom output handler should be used to prevent flushing during shutdown.
+
+
+
+
+
+ Output Handlers
+
+ Output handlers are callables associated with output buffers
+ that are invoked by calling ob_clean,
+ ob_flush, ob_end_flush,
+ ob_get_flush, ob_end_clean,
+ ob_get_clean or during PHP's shutdown process.
+
+
+
+ The shutdown process will flush the return value of the handler.
+
+
+
+ If omitted or &null; when starting the output buffer
+ the internal "default output handler" will be used
+ which returns the unmodified contents of the buffer when invoked.
+ Output handlers can be used to return a modified version
+ of the buffer's contents and/or have side-effects (e.g. send headers).
+
+
+ PHP comes with two internal output handlers:
+ "default output handler"
+ and "URL-Rewriter" (which is integrated into
+ its own output buffer and only up to two instances of it can be started).
+
+
+ The bundled extensions include four additional output handlers:
+ mb_output_handler, ob_gzhandler,
+ ob_iconv_handler, ob_tidyhandler.
+
+
+
+
+ Working With Output Handlers
+
+ When invoked, output handlers are passed the contents of the buffer
+ and a bitmask indicating the status of output buffering.
+
+
+
+ string
+
+ handler
+
+
+ string
+ buffer
+
+
+ int
+ phase
+
+
+
+
+ buffer
+
+
+ Contents of the output buffer.
+
+
+
+
+ phase
+
+
+ Bitmask of
+
+ PHP_OUTPUT_HANDLER_*
+ constants
+ .
+
+
+
+
+
+
+
+ Calling any of the following functions from within an output handler
+ will result in a fatal error:
+ ob_clean, ob_end_clean,
+ ob_end_flush, ob_flush,
+ ob_get_clean, ob_get_flush,
+ ob_start.
+
+
+
+
+ If the PHP_OUTPUT_HANDLER_DISABLED of a handler is set,
+ the handler will not be invoked by calling
+ ob_end_clean, ob_end_flush,
+ ob_get_clean, ob_get_flush
+ or during PHP's shutdown process.
+ This flag has no effect on when calling ob_clean
+ or ob_flush.
+
+
+
+
+ The working directory of the script can change inside the shutdown function
+ under some web servers, e.g. Apache or the built-in web server.
+
+
+
+
+
+ Flags Passed To Output Handlers
+
+ The bitmask passed to the second phase parameter
+ of the output handler provides information on the invocation of the handler.
+
+
+
+ The bitmask can include more than one flag
+ and the bitwise & operator should be used
+ to check whether a flag is set.
+
+
+
+
+ The value of PHP_OUTPUT_HANDLER_WRITE and its alias
+ PHP_OUTPUT_HANDLER_CONT is 0
+ therefore whether it is set can only be determined
+ by using an
+ equality operator
+ (== or ===).
+
+
+
+ The following flags are set in a specific phase of the handler's lifecycle:
+ PHP_OUTPUT_HANDLER_START is set
+ when a handler is invoked for the first time.
+ PHP_OUTPUT_HANDLER_FINAL
+ or its alias PHP_OUTPUT_HANDLER_END
+ is set when a handler is invoked for the last time,
+ i.e. it is being turned off. This flag is also set
+ when buffers are being turned off by PHP's shutdown process.
+
+
+ The following flags are set by a specific invocation of the handler:
+ PHP_OUTPUT_HANDLER_FLUSH is set
+ when the handler is invoked by calling ob_flush.
+ PHP_OUTPUT_HANDLER_WRITE
+ or its alias PHP_OUTPUT_HANDLER_CONT
+ is set when the size of its contents equals or exceeds the size of the buffer
+ and the handler is invoked while the buffer is being automatically flushed.
+ PHP_OUTPUT_HANDLER_FLUSH is set
+ when the handler is invoked by calling ob_clean,
+ ob_end_clean or ob_get_clean.
+ When ob_end_clean or ob_get_clean
+ is called, PHP_OUTPUT_HANDLER_FINAL is set as well.
+
+
+
+ When ob_end_flush or ob_get_flush
+ is called, PHP_OUTPUT_HANDLER_FINAL is set
+ but PHP_OUTPUT_HANDLER_FLUSH is not.
+
+
+
+
+
+ Output Handler Return Values
+
+ The return value of the output handler is internally coerced into a string
+ following standard PHP type semantics, with two exceptions:
+ arrays and booleans.
+
+
+ Arrays are converted into the string "Array"
+ but the Array to string conversion warning
+ is not triggered.
+
+
+ If the handler returns &false; the contents of the buffer are returned.
+ If the handler returns &true; an empty string is returned.
+
+
+
+ If a handler returns &false; or throws an exception
+ its PHP_OUTPUT_HANDLER_DISABLED status flag is set.
+
+
+
+
+
+ Exceptions Thrown In Output Handlers
+
+ If an uncaught exception is thrown in an output handler
+ the program terminates and the handler is invoked
+ by the shutdown process after which
+ the "Uncaught Exception" error message is flushed.
+
+
+ If the uncaught exception is thrown in a handler
+ invoked by ob_flush,
+ ob_end_flush or ob_get_flush,
+ the contents of the buffer are flushed before the error message.
+
+
+ If an uncaught exception is thrown in an output handler during shutdown,
+ the handler is terminated and neither the contents of the buffer
+ nor the error message is flushed.
+
+
+
+ If a handler throws an exception
+ its PHP_OUTPUT_HANDLER_DISABLED status flag is set.
+
+
+
+
+
+ Errors Raised In Output Handlers
+
+ If a non-fatal error is raised in an output handler
+ the program continues execution.
+
+
+ If the non-fatal error is raised in a handler invoked by
+ ob_flush, ob_end_flush
+ or ob_get_flush,
+ the buffer flushes certain data depending on the return value of the handler.
+ If the handler returns &false; the buffer and the error message are flushed.
+ If the returns anything else the handler return value is flushed
+ but not the error message.
+
+
+
+ If a handler returns &false;
+ its PHP_OUTPUT_HANDLER_DISABLED status flag is set.
+
+
+
+ If a fatal error is raised in an output handler
+ the program terminates and the handler is invoked
+ by the shutdown process after which the error message is flushed.
+
+
+ If the fatal error is raised in a handler
+ invoked by ob_flush,
+ ob_end_flush or ob_get_flush,
+ the contents of the buffers are flushed before the error message.
+
+
+ If a fatal error is raised in an output handler during shutdown
+ the program terminates without flushing the buffer or the error message.
+
+
+
+
+ Output In Output Handlers
+
+ In specific circumstances, output produced in the handler is flushed
+ along with the contents of the buffer.
+ This output is not appended to the buffer and is not part of the string
+ returned by ob_get_flush.
+
+
+ During flush operations (calling ob_flush,
+ ob_end_flush, ob_get_flush
+ and during shutdown)
+ if the return value of a handler is &false;
+ the contents of the buffer are flushed followed by the output.
+ If the handler is not invoked during shutdown
+ the handler throwing an exception or exit being called
+ results in the same behavior.
+
+
+
+ If a handler returns &false;
+ its PHP_OUTPUT_HANDLER_DISABLED status flag is set.
+
+
+
+
+
+ Output Handler Status Flags
+
+ The
+
+ handler status flags
+ of the buffer's flags bitmask
+ are set every time to the output handler is invoked
+ and are part of the flags returned by
+ ob_get_status.
+ If the handler successfully executes and does not return &false;,
+ PHP_OUTPUT_HANDLER_STARTED and
+ PHP_OUTPUT_HANDLER_PROCESSED is set.
+ If the handler returns &false; or throws an exception while executing,
+ PHP_OUTPUT_HANDLER_STARTED and
+ PHP_OUTPUT_HANDLER_DISABLED is set.
+
+
+
+ If the PHP_OUTPUT_HANDLER_DISABLED of a handler is set,
+ the handler will not be invoked by calling
+ ob_end_clean, ob_end_flush,
+ ob_get_clean, ob_get_flush
+ or during PHP's shutdown process.
+ This flag has no effect on when calling ob_clean
+ or ob_flush.
+
+
+
+
+
+