It is recommended not to use include_once (require_once) as much as possible

This article is a detailed analysis and introduction to the reasons not to use (include/require)_once. Friends in need can refer to

About use include or include_once (hereinafter, all include require_once), this discussion has been long, and the conclusion has always been, that is, try to use include instead of include_once. In the past, the most common reason was, include_once needs to query the loaded file list, confirm whether it exists, and then load it again.

Admittedly, 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:

Copy code The code is as follows:

<?php
set_include_path
("/tmp/:/tmp2/");
include_once("2.php");
?>

When PHP sees include_once "2.php", it does not know what the actual path of this file is, and it cannot go from the loaded file list Determine whether it has been loaded, 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 If the parsing is successful, search for EG (include_files). If it exists, it means it has been included and returns. Otherwise, open the file and 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 open file is no longer needed.

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

In most cases, Not a problem, but the problem is when you use APC...

When using APC, APC hijacks the compile_file pointer to the compiled file, thereby getting the compilation result directly from the cache, avoiding the need to modify the actual file open, avoiding the system call to open.

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

But, unfortunately, as I said, APC's include_once_override implementation has not been good, and there will be some Undefined problems, such as:

Copy code The code is as follows:

<?php
set_include_path("/tmp");
function a($arg = array()) {
    include_once("b.php");
}
a();
a();
?>

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

The code is as follows:

<?php
  class B {}
?>

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 a file by ourselves It is only loaded once. You 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 everyone not to use include_once

The above is the detailed content of It is recommended not to use include_once (require_once) as much as possible. For more information, please follow other related articles on the PHP Chinese website!