Detailed explanation of how php function ob_start() controls browser cache

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

The header function of php is used here. 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. Remove ob_start() in the first line, and then execute this program, there will be an error message: "Header had all ready send by"! Adding ob_start will not prompt an error. 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 there will be no Any file header output errors!

Let’s start today’s topic: Use ob_start() to control the browser’s cache.

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) Note: 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; the same as 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: 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: 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. The default is to close the buffer. After turning on absolute output, each script output Send directly to the browser, no need to call flush()

2. In-depth understanding: 1. About Flush function: Used to refresh the browser's cache.

Example:

for($i = 1; $i // Key statement, the structure of the cache makes its content only when it reaches a certain The size can be output from the browser
// In other words, if the cache content does not reach a certain size, it will not be output before the program execution is completed. 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 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 in the program Add ob_implicit_flush() to the header to turn on absolute flush, and you can no longer use flush() in the program.

2. About ob series functions: For example, the setting information of the server and client can be used, 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, it can be easily solved: example:

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
//by bbs.it-home.org
?>

Using the above method, you can save the phpinfo information of different users. This may not have been possible before! In fact, the above is a method to convert some "processes" into "functions"! PHP's default syntax highlighting function will output directly and cannot save the results. If it is displayed every time it is called, it will be a waste of CPU.

The main points of ob_start(). . 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). . 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, after the cache is written, and then Automatically run commands, such as ob_start("ob_gzhandler"); our most common method is to use ob_get_contents() to get the contents of the cache, and then process it... . When the processing is completed, we can use various methods to output, flush(), ob_end_flush(), and automatic output after the program execution is completed. Of course, if you are using ob_get_contents(), then you have to control the output method yourself.

Let’s learn how to use the ob series functions.

1. Static template technology Introduction: The so-called static template technology uses a certain method to enable users to get the html page generated by PHP on the client side. 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, and sohu. The benefits of technology like this are huge.

There are two ways to achieve static output: . Implemented through a class called template.inc.php of phplib modified by y10k. . Implemented using ob series functions. As for the first method, since it is not the issue to be studied in this article, I will not go into details. Now let’s take a look at the specific implementation of the second method: example:

ob_start();//Open the buffer
?>

php page:

$content = ob_get_contents();//Get all the contents output by the php page
$fp = fopen("output00001.html", "w"); //Create a file and Open and prepare to write
fwrite($fp, $content); //Write all the contents of the php page to output00001.html, and then...
fclose($fp);
//by bbs.it-home.org
?>

2. Capture output The above example is the simplest case. You can also operate on $content before writing. You can try to capture some keywords and then reprocess them, such as PHP syntax highlighting. Example 5:

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 typical that $code itself is an output page containing variables. In this example, eval is used to replace the variables in $code, and then the output results are captured again. Process...

Example 6, speed up transmission

** ------------Start of file----------
** |
 ** | include('gzdoc.php');
** |? >
** |
** |... the page ...
** |
* * |
** | gzdocout();
** |? >
** -------------End of file----------
*/
ob_start();
ob_implicit_flush(0);
function CheckCanGzip(){
global $HTTP_ACCEPT_ENCODING;
if (headers_sent() || connection_timeout() || connection_aborted() ){
return 0;
}
if (strpos($HTTP_ACCEPT_ENCODING, 'x-gzip') !== false) return "x-gzip";
if (strpos($HTTP_ACCEPT_ENCODING ,'gzip') !== false) return "gzip";
return 0;
}
/* $level = compression level 0-9, 0=none, 9=max * /
function GzDocOut($level=1,$debug=0){
$ENCODING = CheckCanGzip();
if ($ENCODING){
print "nn";
$Contents = ob_get_contents();
ob_end_clean();
if ($debug){
$s = "Not compress length: ".strlen($Contents);
$s .= "
Compressed length : ".strlen(gzcompress($Contents,$level));
$Contents .= $s;
}
header("Content-Encoding: $ENCODING");
print " x1fx8bx08x00x00x00x00x00";
$Size = strlen($Contents);
$Crc = crc32($Contents);
$Contents = gzcompress($Contents,$level);
$Contents = substr($Contents, 0, strlen($ Contents) - 4);
print $Contents;
print pack('V',$Crc);
print pack('V',$Size);
exit;
}else{
ob_end_flush();
exit;
}
}
?> And the larger the page, the more obvious the effect.

This is the introduction to the usage of ob_start and other related cache functions in php. I hope it can help everyone.