PHP deeply understands the usage of refresh buffer function

About how to use ob_flush() and flush() in PHP

Note: The two functions ob_flush() and flush() are generally used together, and the order is First ob_flush(), then flush(), their function is to refresh the buffer.
Here is a detailed explanation of when to use the refresh buffer and why to refresh the buffer.

1. When to refresh the buffer

When the two functions file_get_contents() and file_put_contens() are used in the program, Or when performing similar "read and write" functions in the program or performing output operations to the browser, ob_flush() and flush() will be used to refresh the buffer.

2. Why the buffer should be refreshed

Use file_get_contents() and file_put_content() as examples to explain.

The two functions file_get_contents() and file_put_conents() respectively perform reading data and writing data operations. The data is first read into the memory and then written to the file, because the reading speed is faster than The writing speed should be fast, so when your data is read, it does not mean that the data has been written. At this time, the more read content will be temporarily placed in the buffer (memory). It needs to be emphasized here, In fact, data reading and writing are two very fast actions.

Also use an explanation (when the program performs an output operation to the browser), individual web server programs, especially web server programs under Win32, will still cache the script before sending the results to the browser. Output until the end of the program. If you don't want the program to be output to the browser only after it is executed, then you can also use ob_flush() and flush() to refresh the cache.

In fact, flush() has another use, which is to output before the program ends. That is, part of the results can be output to the browser before a loop ends. This effect is very similar to the asynchronous ajax. transmission effect.
In-depth understanding of the difference between ob_flush and flush
The description of ob_flush/flush in the manual is to refresh the output buffer, and it also needs to be used in conjunction, so it will cause many people to be confused...
Actually, they operate on different objects. In some cases, flush does nothing at all..
ob_* series of functions operate the output buffer of PHP itself.
So, ob_flush refreshes PHP itself. Buffer.
And flush, strictly speaking, this only has practical effect when PHP is installed as apache Module (handler or filter). It refreshes the buffer of WebServer (can be considered specifically apache) .
Under the sapi of apache module, flush will indirectly call the apache api by calling the flush member function pointer of sapi_module: ap_rflush refreshes the output buffer of apache. Of course, the manual also says, There are some other modules of Apache, which may change the result of this action..Some Apache modules, such as mod_gzip, may perform output caching by themselves, which will cause the results generated by the flush() function to not be sent to the client immediately. end browser.
Even the browser will cache the received content before displaying it. For example, the Netscape browser caches content until it receives a newline or the beginning of an html tag, and does not display an entire table until it receives a tag.
Some versions of Microsoft Internet Explorer will only start displaying the page after receiving 256 bytes, so some extra spaces must be sent to allow these browsers to display the page content. Therefore, the correct order to use the two is. First ob_flush, then flush,
Of course, under other sapi, you can not call flush, but to ensure the portability of your code, it is recommended to use it together.

buffer --- - flush()

Buffer is a memory address space. The default size of the Linux system is generally 4096 (1kb), which is one memory page. It is mainly used to store data transfer areas between devices with unsynchronized speeds or devices with different priorities. Through the buffer, the processes can wait less for each other. Here is a more general example. When you open a text editor to edit a file, every time you enter a character, the operating system will not immediately write the character directly to the disk, but first write it to the buffer. When writing When a buffer is full, the data in the buffer will be written to the disk. Of course, when the kernel function flush() is called, it is mandatory to write the dirty data in the buffer back to the disk.
Similarly, when echo and print are executed, the output is not immediately transmitted to the client browser for display through tcp, but the data is written to the php buffer. The php output_buffering mechanism means that a new queue is established before the tcp buffer, and data must pass through the queue. When a php buffer is full, the script process will hand over the output data in the php buffer to the system kernel and pass it to the browser via TCP for display. Therefore, the data will be written to these places in sequence echo/pring -> php buffer -> tcp buffer -> browser
php output_buffering --- ob_flush()
Default Next, the php buffer is enabled, and the default value of the buffer is 4096, which is 1kb. You can find the output_buffering configuration in php.iniConfiguration File. When echo, print, etc. output user data, the output data will be written to php output_buffering. Until output_buffering is full, the data will be Transmitted to the browser for display via tcp. You can also manually activate the php output_buffering mechanism through ob_start(), so that even if the output exceeds 1kb of data, the data will not be actually handed over to tcp and passed to the browser. Because ob_start() will The buffer space is set to be large enough. The data will not be sent to the client browser until the end of the script or the ob_end_flush function is called.

The use of these two functions is probably the most confusing issue for many people. The explanation of the two functions in the manual is not clear, and their differences are not clearly pointed out. It seems that the functions of both are the same. is to flush the output cache. But in the code at the beginning of our article, if flush() is replaced with ob_flush(), the program will no longer execute correctly. Obviously, there is a difference between them. Otherwise, it would be enough to directly state in the manual that one of them is an alias of another function. There is no need to explain them separately. So what is the difference between them?
When caching is not enabled, the content output by the script is in a state of waiting for output on the server side. flush() can immediately send the content waiting for output to the client.

After the cache is turned on, The content output by the script is stored in the output cache. At this time, there is no content waiting for output. If you use flush() directly, it will not send any message to the client. content. The function of ob_flush() is to take out the content that originally existed in the output cache, and set it to the waiting output state, but it will not be sent directly to the client . In this case, you need to use ob_flush() first and then Using flush(), the client can immediately get the output of the script.

1. The correct order of flush and ob_flush, the correct order should be, ob_flush first and then flush, as follows:
ob_flush();
flush();
If the Web server If the operating system is Windows, then there will be no problem if the order is reversed or if ob_flush() is not used. [To be verified ] However, the output buffer cannot be refreshed on Linux systems.
output buffering function
1.bool ob_start ([ callback $output_callback [, int $chunk_size [, bool $erase ]]] )
Activate the output_buffering mechanism . Once activated, the script output is no longer sent directly to the browser, but is temporarily written to the PHP buffer memory area.
php enables the output_buffering mechanism by default, but by calling the ob_start() function, the data output_buffering value is expanded to a large enough value. You can also specify $chunk_size to specify the value of output_buffering. The default value of $chunk_size is 0, which means that the data in the php buffer will not be sent to the browser until the end of the script. If you set the size of $chunk_size, it means that as long as the data length in the buffer reaches this value, the data in the buffer will be sent to the browser.
Of course, you can process the data in the buffer by specifying $ouput_callback. For example, the function ob_gzhandler compresses the data in the buffer and then sends it to the browser.
The third parameter: whether to erase the cache, optional, the default is true, if set to false, the cache will not be cleared before the script execution ends.
2.ob_get_contents
Get a copy of the data in the php buffer. It is worth noting that you should call this function before the ob_end_clean() function is called, otherwise ob_get_contents() returns a null character.
You can use ob_get_contents() to obtain the server-side cached data in the form of a string.
Using ob_end_flush() will output the cached data and close the cache.
Using ob_end_clean() will silently clear the data cached on the server without any data or other actions.
The caches on the server are stacked, which means that after you enable ob_start() and before closing it, you can open another cache ob_start() inside it.
But you must also ensure that the number of operations to turn off the cache is the same as the number of operations to turn on the cache.
ob_start() can specify a callback function to process cache data . If one ob_start() is nested inside another ob_start(), we assume that the outer The ob_start() number of the layer is A, and the ob_start() number of the inner layer is B. They each have a callback function called functionA and functionB. Then when the data in cache B is output, it will be processed by the funcitonB callback function. , and then handed over to the outer functionA callback function for processing, and then can be output to the client.
In addition, the manual says that for some web servers, such as apache, using the callback function may change the current working directory of the program. The solution is to manually modify the working directory back in the callback function, using the chdir function. This does not seem to be encountered often, so remember to check the manual when you encounter it.
3.ob_end_flush and ob_end_clean
These two functions are somewhat similar and both turn off the ouptu_buffering mechanism. But the difference is that ob_end_flush only flushes (flush/send) the data in the php buffer to the client browser, while ob_clean_clean clears (erase) the data in the php bufeer but does not send it to the client browser.
Before ob_end_flush is called, the data in the php buffer still exists, and ob_get_contents() can still obtain a copy of the data in the php buffer.

After calling ob_end_flush(), ob_get_contents() gets an empty string, and the browser cannot receive output, that is, there is no output.

You can use ob_get_contents() to obtain the server-side cached data in the form of a string, and use ob_end_flush() to output the cached data and close the cache.
Using ob_end_clean() will silently clear the data cached on the server without any data or other actions.

The above is the detailed content of PHP deeply understands the usage of refresh buffer function. For more information, please follow other related articles on the PHP Chinese website!