Detailed introduction to output_buffering in PHP, outputbuffering

I personally think that Output buffering is a relatively pure 4.0 feature. Although conceptually quite simple, output buffering is extremely powerful and makes it easier for developers to develop advanced and efficient programs.

This article will introduce HTTP headers, how output buffering can help you deal with HTTP headers, and introduce some advanced uses of output buffering.

HTTP Header

For every request established using the HTTP protocol, the response generated by the web server usually consists of two parts - headers and body. For example, if there is a small text file called example.txt in the document root directory of the web server, and the file contains the text Hello, world!, then the HTTP request response to this file will look like this:

Copy code The code is as follows:

HTTP/1.1 200 OK
Date: Sat, 02 Sep 2000 21:40:08 GMT
Server: Apache/1.3.11 (Unix) mod_macro/1.1.1 PHP/4.0.2-dev
Last-Modified: Sat, 02 Sep 2000 21:39:49 GMT
ETag: "12600b-e-39b173a5"
Accept-Ranges: bytes
Content-Length: 14
Connection: close
Content-Type: text/plain
Hello, world!

The first part (the larger part) of this request is the HTTP header. Although the HTTP header is not visible to the user in the browser, it contains information for the browser, such as the document content type, the protocol version used, the date the document was last modified, and so on. There are not many rules for HTTP headers. Usually, its format is as follows:

Copy code The code is as follows:

Field: Value[field: value]

They must be separated from the main body of the document by a blank line.

This HTTP header's information can be added or changed from a PHP script. For example, you can use the header() function:

Copy code The code is as follows:

header("Location: http://www.php.net/"); // Redirect to http://www.php.net/

You can also use the SetCookie() function:

Copy code The code is as follows:

SetCookie("foo", "bar");

You may know that HTTP cookies are implemented using HTTP headers. For example, the HTTP request response for the following PHP file

Copy code The code is as follows:

SetCookie("foo", "bar");
print "Set cookie.";
?>

It will look like this:

Copy code The code is as follows:

HTTP/1.1 200 OK
Date: Sat, 02 Sep 2000 21:43:02 GMT
Server: Apache/1.3.11 (Unix) mod_macro/1.1.1PHP/4.0.2-dev
X-Powered-By: PHP/4.0.2-dev
Set-Cookie: foo=bar
Connection: close
Content-Type: text/html
Set cookie.

The browser reads the HTTP header returned from the server and knows that a cookie called foo (a session cookie in this case) was sent, and its value is bar.

Why use Output Buffering technology

The need for output buffering technology was obvious as early as PHP/FI 2.0. If you have used this version of PHP, you may still remember that you often encountered the Oops, SetCookie called after header has been sent error message, which made you scratch your head and wonder what the reason was.

If you have used the latest version of PHP -- PHP 3.0 or even PHP 4.0 -- then you will know this error message: Oops, php_set_cookie called after header has been sent. Alternatively, you may encounter the Cannot add header information - headers already sent message when trying to call PHP's header() function. In general, output buffering technology users avoid these annoying error messages, while developers can also use it for advanced purposes.

When did these errors occur? These error messages can occur if you try to add or modify header information after the HTTP header has been sent, and if there is a lack of blank lines between the document body and the header. To understand how this happens, let's take a look at how PHP handles HTTP header output and body output.

When the script starts executing, it can send header information and body information at the same time.

Header information (from header() or SetCookie() function) is not sent immediately, instead, it is saved to a list.

This allows you to modify the header information, including the default header (such as the Content-Type header). However, once the script sends any non-header output (for example, using a block or a print() call), then PHP must send all the headers first, then send a blank line, terminating the HTTP header, and only continue after that. Send body data. From this point on, any attempt to add or modify header information is not allowed and will send one of the above error messages.

Although this does not cause much of a problem, sometimes it just terminates the HTTP header before sending any input, thus complicating the script logic. Output buffering technology can solve these problems.

How Output Buffering works

When output buffering is enabled, PHP does not send HTTP headers when the script sends output. Instead, it pipes this output into a dynamically growing cache (only available in PHP 4.0, which has a centralized output mechanism). You can still modify, add header rows, or set cookies, since the headers are not actually sent. In the simplest case, when the script terminates, PHP will automatically send the HTTP header to the browser, and then send the contents of the output buffer. It's simple.

Basic usage

You can use the following four functions, which can help you control output buffering:

Copy code The code is as follows:

ob_start()

Enable output buffering mechanism.

Output buffering supports multiple levels - for example, the ob_start() function can be called multiple times.

ob_end_flush()

Send output buffer and disable output buffering mechanism.

ob_end_clean()

Clear the output buffer without sending, and disable output buffering.

ob_get_contents()

Return the current output buffer into a string. Allows you to process any output emitted by the script.

Also, the output_buffering directive in php.ini can be enabled. If this directive is enabled, each PHP script is equivalent to calling the ob_start() function at the beginning.

Example 1

Copy code The code is as follows:

Example 1

print "Hello, $user ";
SetCookie("Wow", "This cookie has been set even though we've already emitted output!");
?>

Here, even though you have sent the output (in the HTML code block and in the print statement), you can still use the SetCookie() call without error, really thanks to the output buffering mechanism. Please note that using the output buffering mechanism for this purpose will incur a certain performance penalty, so it is best not to enable this mechanism by default. However, for more complex scripts, output buffering can simplify the logic.

Example 2

Copy code The code is as follows:

ob_start();
print "Here's a pretty dumb way to calculate the length of a string.";
$length = strlen(ob_get_buffer());
ob_end_clean();
?>

This example shows an inefficient method of determining string length. Instead of simply using the strlen() function, it first enables the output buffering mechanism, prints out the string, and then determines the length of the output buffer. Finally clear the output buffer (not send), and then disable the output buffering mechanism.

How to enable output_buffering in PHP?

The following settings related to output buffering can be set in PHP.INI:
Name default value scope correction record
output_buffering "0" PHP_INI_PERDIR
output_handler NULL PHP_INI_PERDIR available since PHP 4.0.4
implicit_flush "0" PHP_INI_ALL in PHP
The simple explanation is as follows:
output_buffering boolean/integer
When this option is set to On, it will be used in all scripts Use output controls. If you want to limit the maximum size of the output buffer, set this option to a specified maximum number of bytes (for example, output_buffering=4096). Starting with PHP version 4.3.5, this option is always Off under PHP-CLI.

output_handler string
This option can redirect all output of the script to a function. For example, when output_handler is set to mb_output_handler(), the character's encoding will be modified to the specified encoding. Any processing functions set will automatically handle output buffering.

Note: You cannot use mb_output_handler() and ob_iconv_handler() at the same time, nor can you use ob_gzhandler() and zlib.output_compression at the same time.

Note: Only built-in functions can use this command. For user-defined functions, use ob_start().

implicit_flush boolean
Defaults to FALSE. If you change this option to TRUE, PHP will cause the output layer to automatically refresh after each chunk of information is output. This is equivalent to calling the flush() function in PHP after every use of functions such as print(), echo(), or after every HTML block.

When not using PHP in a web environment, turning this option on has a serious impact on the performance of program execution. It is usually only recommended for debugging. In execution mode of the CLI SAPI, this flag defaults to TRUE.

See ob_implicit_flush().

It will definitely be useful if set, unless the PHP.INI location you modify is not the one used by the system, for example, it is usually C::\WINDOWS\PHP.INI. Of course, it can be set to other places. In addition, console programs are not buffered.

In addition, you can also control the output buffer in the program. Please refer to the "CXIV. Output Control Output Control Function" chapter in the manual. The main functions are as follows:

flush -- Flush the output buffer
ob_clean -- Clean (erase) the output buffer
ob_end_clean -- Clean (erase) the output buffer and turn off output buffering
ob_end_flush -- Flush (send) the output buffer and turn off output buffering
ob_flush -- Flush (send) the output buffer
ob_get_clean -- Get current buffer contents and delete current output buffer
ob_get_contents -- Return the contents of the output buffer
ob_get_flu... ...The rest of the text>>

For the problem of output_buffering option in php configuration file

No impact.
This only controls the output of page content. When it is turned on, the page content is first saved in the buffer. After the page is executed, it is sent to the browser for display. When it is closed, the page content is sent directly to the browser for display.

This option also allows a numerical value, such as 4096, which means that content is sent to the browser once when the buffer content reaches 4096 bytes (or execution is completed).