Summary of commonly used functions in php ob series functions

The common functions of 数OB series functions

Ob_Start (); // Open an output buffer. All output information is no longer sent directly to the browser, but saved in the output buffer.
ob_clean(); //Delete the contents of the internal buffer without closing the buffer (no output).

ob_end_clean(); //Delete the contents of the internal buffer and close the buffer (no output).
ob_get_clean(); //Return the contents of the internal buffer and close the buffer. Equivalent to executing ob_get_contents() and ob_end_clean()
ob_flush(); //Send the contents of the internal buffer to the browser, delete the contents of the buffer, and do not close the buffer.
ob_end_flush(); //Send the contents of the internal buffer to the browser, delete the contents of the buffer, and close the buffer.
ob_get_flush(); //Return the contents of the internal buffer, close the buffer, and then release the contents of the buffer. Equivalent to ob_end_flush() and returns the buffer contents.
flush(); // Output the content released by ob_flush and the content not in the PHP buffer to the browser; refresh the content of the internal buffer and output it.

ob_get_contents(); //Return the contents of the buffer without output.

ob_get_length(); //Returns the length of the internal buffer. If the buffer is not activated, this function returns FALSE.
ob_get_level(); //Return the nesting level of the output buffering mechanism.
ob_get_status(); //Get status of output buffers.

ob_implicit_flush(); //Turn on or off absolute refresh, the default is off, after opening ob_implicit_flush(true), the so-called absolute refresh, means that when an output statement (e.g: echo) is executed, the output is sent directly to the browser, without the need to call flush() or wait until the end of the script to output.

ob_gzhandler //ob_start callback function, uses gzip to compress the contents of the buffer.

ob_list_handlers //List all output handlers in use
output_add_rewrite_var //Add URL rewriter values
output_reset_rewrite_vars //Reset URL rewriter values

The behavior of these functions is affected by the php_ini settings:

output_buffering //When this value is ON, it will be Output control is used in all scripts; if the value is a number, it represents the maximum byte limit of the buffer. When the cached content reaches the upper limit, the current buffer content will be automatically output to the browser.
output_handler //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.
implicit_flush //Same function as ob_implicit_flush, default is Off.

Use PHP's ob_start();

Control your browser cache

The Output Control function allows you to freely control the output of data in the script. It is very useful, especially when you want to output the file header after the data has been output. The output control function does not affect the file header information sent using header() or setcookie(), only the data blocks similar to echo() and PHP code.
Let’s take a simple example first to give everyone a general impression of Output Control:
Example 1.

Program codeProgram code

ob_start(); //Open the buffer
echo "Hellon" ; //Output
header("location:index.php"); //Redirect the browser to index.php
ob_end_flush(); //Output all content to the browser
?>

All pairs of headers Anyone who knows the () function knows that this function will send a file header to the browser, but if there is any output (including empty output, such as spaces, carriage returns, and line feeds) before using this function, an error will be prompted. . If we remove ob_start() in the first line and then execute this program, we will find that we get an error message: "Header had all ready send by"! But with ob_start, there will be no error message. The reason is that when the buffer is opened, the characters after echo will not be output to the browser, but will be retained on the server. They will not be output until you use flush or ob_end_flush, so it will not Any file header output errors!

1. Introduction to related functions:
1. Flush: refresh the contents of the buffer and output.
Function format: flush()
Description: This function is frequently used and is very efficient.
2. ob_start: Open the output buffer
Function format: void ob_start(void)
Description: When the buffer is activated, all non-file header information from the PHP program will not be sent, but will be saved in the internal buffer. In order to output the contents of the buffer, you can use ob_end_flush() or flush() to output the contents of the buffer.
3, ob_get_contents: Return the contents of the internal buffer.
Usage: string ob_get_contents(void)
Description: This function will return the contents of the current buffer. If the output buffer is not activated, it will return FALSE.
4. ob_get_length: Returns the length of the internal buffer.
Usage: int ob_get_length(void)
Description: This function will return the length in the current buffer; like ob_get_contents, if the output buffer is not activated. then returns FALSE.
5. ob_end_flush: Send the contents of the internal buffer to the browser and close the output buffer.
Usage: void ob_end_flush(void)
Description: This function sends the contents of the output buffer (if any).
6. ob_end_clean: Delete the contents of the internal buffer and close the internal buffer
Usage method: void ob_end_clean(void)
Description: This function will not output the contents of the internal buffer but delete it!
7. ob_implicit_flush: Turn on or off absolute refresh
Usage method: void ob_implicit_flush ([int flag])
Note: Anyone who has used Perl knows the meaning of $|=x. This string can open/close the buffer, and The ob_implicit_flush function is the same as that one. The default is to close the buffer. After turning on absolute output, each script output is sent directly to the browser, and there is no need to call flush().

2. In-depth understanding:

1. About Flush Function:
This function appeared in PHP3. It is a very efficient function. It has a very useful function of refreshing the browser's cache. Let's give an example with a very obvious operating effect to illustrate flush.
Example 2.

Program codeProgram code
for($i = 1; $i <= 300; $i++ ) print(" ");
// This sentence is very critical. The structure of the cache makes it The content can only be output from the browser if it reaches a certain size
// In other words, if the cache content does not reach a certain size, it will not be output before the program is executed. After
// testing, I found that the lower limit of this size is 256 characters long. This means that the content received by the cache in the future will
// be sent out continuously.
For($j = 1; $j <= 20; $j++) {
echo $j."
";
flush(); //This will cause the new content in the cache to be squeezed out and displayed Go to the browser
sleep(1); //Let the program "sleep" for a second, which will allow you to see the effect more clearly
}
?>

Note: If you add ob_implicit_flush() to the beginning of the program, open it With absolute refresh, flush() can no longer be used in the program. The benefit of this is: improved efficiency!

2. Regarding the ob series functions:
I would like to quote an example from my good friend y10k first:
Example 3.

For example, you can use the setting information of the server and the client, but this information will be different depending on the client. , what if you want to save the output of the phpinfo() function? Before there was no buffer control, it can be said that there was no solution at all, but with buffer control, we can easily solve it:
Program codeProgram code
ob_start(); //Open the buffer
phpinfo (); //Use the phpinfo function
$info=ob_get_contents(); //Get the contents of the buffer and assign it to $info
$file=fopen('info.txt','w'); //Open the file info .txt
fwrite($file,$info); //Write information to info.txt
fclose($file); //Close the file info.txt
?>

Using the above method, you can put different The user's phpinfo information is saved, which may not have been possible before! In fact, the above is a method to convert some "processes" into "functions"!
Some people may ask: "Is it just like this? Are there other uses?" Of course, there is, for example, the PHP syntax highlighting in the author's forum is related to this (PHP's default syntax highlighting function will output directly, The result cannot be saved. If it is displayed every time it is called, it will be a waste of CPU. The author's forum retains the result displayed by the syntax highlighting function by controlling the buffer). If you are interested, you can take a look

Maybe now you have a certain understanding of the function of ob_start(). The above example seems simple, but in fact you have mastered the key points of using ob_start().
<1>. Use ob_start to open the browser's cache. This ensures that the contents of the cache will not be output before you call flush(), ob_end_flush() (or the program is executed).
<2>. Now you should know the advantages you have: you can use header, setcookie and session after any output content, which is a great feature of ob_start; you can also use the parameters of ob_start to be written in the cache After entering, then automatically run the command, such as ob_start( "ob_gzhandler"); and our most common method is to use ob_get_contents() to get the contents in the cache, and then process it...
<3>. When the processing is completed, We can use various methods to output, flush(), ob_end_flush(), and automatic output after the program is executed. Of course, if you are using ob_get_contents(), then you have to control the output method yourself.

Come on, let’s see what we can do with the ob series functions...

1. Static template technology

Introduction: The so-called static template technology is to use a certain method to make what the user gets on the client side generated by PHP html page. If this HTML page will no longer be updated, then when another user browses this page again, the program will no longer call PHP and related databases. For some websites with a large amount of information, such as sina, 163, sohu. The benefits of technology like this are huge.

There are two ways to achieve static output that I know of:
<1>. Implemented through a class called template.inc.php of phplib modified by y10k.
<2>. Implemented using ob series functions.
For the first method, because it is not the issue to be studied in this article, I will not go into details.
Let’s now take a look at the specific implementation of the second method:
Example 4.

Program codeProgram code
ob_start();//Open the buffer
?>
All of the php page Output
$content = ob_get_contents();//Get all the contents output by the php page
$fp = fopen("output00001.html", "w"); //Create a file and open it, ready to write Enter
fwrite($fp, $content); //Write all the contents of the php page to output00001.html, and then...
fclose($fp);
?>

In this way, the so-called static template is very Easily implemented...

2. Capture output

The above Example 4. is the simplest case. You can also operate on $content before writing...

You can try to capture some keywords , and then reprocess it, such as the PHP syntax highlighting described in Example 3. Personally, I think this function is the biggest essence of this function. It can solve a variety of problems, but it requires you to have enough imagination...

Example 5.

Program codeProgram code
Function run_code($code) {
If($code) {
ob_start();
eval($code);
$contents = ob_get_contents();
ob_end_clean();
}else {
echo "Error! No output ";
     exit();
}
return $contents;
?>
}

The above example is not very useful, but it is very typical. $code itself is an output page containing variables, and this example uses eval replaces the variables in $code, and then captures the output and processes it again...

2. Output cache handle ob_gzhandler

PHP4.0.4 has a new output cache handle ob_gzhandler, which is related to The previous classes are similar, but their usage is different. The following content should be added to php.ini when using ob_gzhandler:

output_handler = ob_gzhandler;

This line of code causes PHP to activate output caching and compress everything it sends out.

If for some reason you don’t want to add this line of code to php.ini, you can also change the default server behavior (not compressed) through the .htaccess file in the directory where the PHP source file is located. The syntax is as follows:

php_value output_handler ob_gzhandler

Or call it from PHP code as follows:

ob_start("ob_gzhandler");

The method of outputting cache handles is indeed very effective and does not place any special load on the server. However, it must be noted that Netscape Communicator has poor support for compressed graphics, so unless you can ensure that all users use IE browser, you should disable compressed JPEG and GIF graphics. In general, this compression works for all other files, but it is recommended that you test it separately for each browser, especially if you use special plug-ins or data viewers. This is especially important.
Notes:
1. The default output_buffering of some web servers is 4069 characters or larger, that is, the output content must reach 4069 characters before the server flushes the output buffer. In order to ensure that the flush is effective, it is best to have the following before the ob_flush() function. Statement:

The code is as follows:

print str_repeat("", 4096); //To ensure that the output_buffering value is reached

2, ob_* series of functions operate the output buffer of PHP itself, so ob_flush only refreshes PHP's own buffer area, and flush is to refresh the apache buffer. Therefore, the correct order to use the two is: ob_flush first, then flush. ob_flush releases data from PHP's buffer, and flush sends all data in/out of the buffer to the browser.
3. Don’t mistakenly think that after using ob_start(), the script’s echo/print and other output will never be displayed in the browser. Because after the PHP script ends, the buffer will be automatically refreshed and the content will be output.

The above has introduced a summary of commonly used functions in the PHP ob series functions, including relevant content. I hope it will be helpful to friends who are interested in PHP tutorials.