Strong statement: Do not use (include/require)_once_PHP tutorial

There has been a long discussion about whether to use include or include_once (hereinafter, all include require_once), and the conclusion has always been that it is better to use include instead of include_once. In the past, the most common reason was that include_once needed to query the loaded File list, confirm if it exists, and then load it.

It is true that this reason is correct, but what I want to talk about today is another reason.

We know that to determine whether a file is loaded, PHP needs to get the open_path of the file, which means, for example:

When PHP sees include_once "2.php", it does not know what the actual path of this file is, and it cannot judge whether it has been loaded from the loaded file list, so In the implementation of include_once, it will first try to parse the real path of the file (for ordinary files, this parsing is just like checking getcwd and the file path, so if it is a relative path, it will generally not succeed). If the parsing is successful, the EG will be searched. (include_files), if it exists, it means it has been included and returns. Otherwise, open the file to get the opened_path of the file. For example, in the above example, this file exists in "/tmp2/2.php".

Then, after getting the opened_path, PHP goes to the loaded file list to find out whether it is included. If not, then compile directly, and there is no need to open the file anymore.

1. Try to parse the absolute path of the file. If the parsing is successful, check EG (included_files) and return if it exists. If it does not exist, continue
2. Open the file and get the open path of the file
3. Take the open path to EG (included_files) to find whether it exists. If it exists, return it. If it does not exist, continue
4. Compile file (compile_file)

This is not a problem in most cases, but the problem lies when you use APC...

When using APC, APC hijacks the compile file pointer of compile_file, thereby obtaining the compilation result directly from the cache, avoiding opening the actual file and avoiding the system call for open.

However, when you use include_once in your code, PHP has already tried to open the file before compile_file, and then enters the compile file hijacked by APC. This will generate an additional open operation. . To solve this problem, APC introduced include_once_override. When include_once_override is turned on, APC will hijack PHP's ZEND_INCLUDE_OR_EVAL opcode handler, determine the absolute path of the file through stat, and then if it is found that it has not been loaded, it will rewrite the opcode to include, make a tricky solution.

However, it is a pity that, as I said, APC's include_once_override has not been implemented well, and there will be some undefined problems, such as:

Then, our b.php is placed in "/tmp /b.php", the content is as follows:

Then when apc.include_once_override is turned on, continuous access will get the following error:

Fatal error - include() : Cannot redeclare class b

Excluding these technical factors, I have always believed that we should use include instead of include_once, because we can completely plan by ourselves and a file will only be loaded once. We can also use automatic loading to do this.

If you use include_once, it only proves that you have no confidence in your code.

So, I suggest you not to use include_once