Detailed explanation of the difference between PHP flush() and ob_flush()

uffer ---- flush()

buffer is a memory address space. The default size of 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 sent 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()

By default, php buffer is turned on. And the default value of this buffer is 4096, which is 1kb. You can find the output_buffering configuration in the php.ini configuration 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 sent to the browser through tcp. show. 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 is not actually handed over to tcp and passed to the browser, because ob_start() sets the php buffer space 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 also unclear, and their differences are not clearly pointed out. It seems that the functions of both are to refresh 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 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, no content will be sent to the client. The function of ob_flush() is to take out the content originally existing 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 flush(). The client The terminal can immediately get the output of the script.

1. The correct order of flush and ob_flush is, ob_flush first and then flush, as follows:
ob_flush();
flush();
If the operating system of the web server is a windows system, reverse the order or do not use ob_flush( ) will not cause any problems. [To be verified] But 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 clear 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 data cached by the server 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 cached data. If one ob_start() is nested inside another ob_start(), we assume that the outer ob_start() number is A and the inner ob_start() number It's B. They each have a callback function, functionA and functionB. Then when the data in cache B is output, it will be processed by the funcitonB callback function first, and then handed over to the outer functionA callback function for processing, and then it can be output to the client. end.

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 Dots don't seem to be encountered often, so remember to check the manual when you encounter them.

3.ob_end_flush and ob_end_clean
These two functions are somewhat similar, 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 server-side caches are stacked, which means that after you enable ob_start() and before closing it, you can open another cache ob_start() inside it. However, you must also ensure that there are as many operations to turn off the cache as there are operations to turn the cache on.
ob_start() can specify a callback function to process cached data. If one ob_start() is nested inside another ob_start(), we assume that the number of the outer ob_start() is A and the number of the inner ob_start() It's B. They each have a callback function, functionA and functionB. Then when the data in cache B is output, it will be processed by the funcitonB callback function first, and then handed over to the outer functionA callback function for processing, and then it can be output to the client. end.

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 Dots don't seem to be encountered often, so remember to check the manual when you encounter them.

For more detailed explanations of the differences between PHP flush() and ob_flush(), please pay attention to the PHP Chinese website!