PHP basic tutorial PHP page buffering mechanism

PHP has many mechanisms and functions. In fact, it is a magician. If it is used repeatedly, magical effects will appear even with simple application. Band of Brothers PHP training

Here we will talk about the ob_start() function.

　 The ob_start() function is used to open the buffer. For example, if there is output before the header() function, including carriage returns, spaces, and line breaks, there will be an error of "Header had all ready send by". In this case, you can use ob_start() to open it first. The data block and echo() output of the buffer PHP code will enter the buffer and will not be output immediately. Of course, opening the buffer has many functions, just use your imagination. The following four points can be summarized:

　1. Used for header( before ();//Output all the content to the browser

　　?>

　 2. The phpinfo() function can obtain client and server-side information, but to save client-side information, the buffer method is the best choice.

　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

　　　?>

　 3. Static page technology

　 ob_start();//Open the buffer

　　?>

　 All output of the php page

　$content =ob_get_contents();//Get the php page output The entire content of

　$fp =fopen("output00001.html", "w"); //Create a file and open it, ready to write

　fwrite($fp, $content); //Put the php page Write all the content into output00001.html, and then...

　fclose($fp);

　?>

　 4. Output code

　Function run_code($code) {

　If($code) {

　ob_start(

}

　 Return $contents;

　}

　 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 to give you a general impression of OutputControl:

　Example 1.

　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 header( 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 execute this program again, we will find that we get an error message: "Header hadall ready send by"! But with ob_start, there will be no error message because when the buffer is turned on area, 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 not be any errors in file header output!

　 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 district. 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: Returns the contents of the internal buffer.

　 Usage: stringob_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: intob_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: voidob_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: voidob_end_clean(void)

Note: This function will not output the contents of the internal buffer but delete it!

　7 , ob_implicit_flush: Turn on or turn off absolute flush

Usage method: void ob_implicit_flush([int flag])

Description: 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().

　　II. In-depth understanding:

　1. About the Flush function :

　This function has 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 .

　　CODE
　for($i = 1; $i
　 // This sentence is very critical. The structure of the cache makes its content only as long as A certain 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 Go and display it on the browser

　 sleep(1); // Let the program "sleep" for a second, which will allow you to see the effect more clearly

　}

　　?>

　 You can see the specific effect here See http://www.php2000.com/~uchinaboy/out.php

The latest PHP chat room of PHP2000 uses this technology. Unfortunately, the source code is not disclosed.

Note: If added at the beginning of the program ob_implicit_flush() turns on absolute refresh, so you can no longer use flush() in the program. The advantage of this is: improve efficiency!

　2. About the ob series functions:

I would like to quote one of my good friend y10k first Example:

　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? Without buffer control Before, it can be said that there was no way, but with buffer control, we can easily solve it:

　CODE
　ob_start(); //Open the buffer
　phpinfo(); //Use 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 the phpinfo of different users Preserving information, I’m afraid there was no way to do it before! In fact, the above is a method of converting 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 and cannot save the result. If it is displayed every time it is called, it will be a waste of CPU. The author's forum The result displayed by the syntax highlighting function is retained by the method of controlling the buffer). If you are interested, you can take a look at http://www.zphp.com/bbs/!

Maybe now you are interested in ob_start() I have a certain understanding of the function. The above example seems simple, but in fact, I have mastered the key points of using 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 "); and our most common approach is to use ob_get_contents() to get the contents of the cache, and then process it...

　. After the processing is completed, we can use various methods 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 some 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:

　. Implemented through a class called template.inc.php of phplib modified by y10k.

　. 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.

　CODE
　ob_start();//Open the buffer

　　?>

　All output of the php page

　  

　 $content =ob_get_contents();//Get all the content 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 into output00001.html, and then...

　fclose($fp);

　?>

　In this way, the so-called static template is It is 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 keyword, and then reprocess it, such as the PHP syntax highlighting described in Example 3. Personally, I think this function is the best part of this function. It can solve a variety of problems, but it requires you to have enough imagination...

　Example 5.

　CODE  

　Function run_code($code ) {

　If($code) {

　　ob_start();

　eval($code);

　$contents =ob_get_contents();

　ob_end_clean(); 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, and this The example uses eval to replace the variables in $code, and then captures the output and processes it again...

　Example 6. Speed ​​up the transmission

　CODE

　ob_start();

　ob_implicit_flush(0 ;  
　if(strpos($HTTP_ACCEPT_ENCODING , 'x-gzip') !== false) return ”x-gzip";

　if(strpos($HTTP_ACCEPT_ENCODING,'gzip') !== false) return ”gzip";

　return 0;

　　}

　functionGzDocOut($level=1,$debug=0){

　$ENCODING = CheckCanGzip();

　if ($ENCODING){

　print “n
n”;

　$Contents =ob_get_contents();

　ob_end_clean();

　if ($debug){

　 $s = ”
Notcompress length: ”.strlen($Contents);

　$s .= ”

　Compressed length: ”.strlen(gzcompress( $ Contents, $ Level));
$ Contents. = $ S;

}

Header ("Content-Encoding: $ Encoding"); 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 The code can be found at weblogs.com When he arrived, he used the function of zlib to compress the transmitted content. The test showed that the effect will be produced for pages above 10k, and the larger the page, the more obvious the effect...