PHP detailed explanation of the difference between include_once and include

includeIf two files are imported with the same function name, a redefinition error will occur. This error can be avoided by using include_once, generally _once is used more. The difference between include and _once should be determined based on the actual situation.

include and requireDifference
When the file to be included does not exist, include generates a warning (Warning), and the program following the statement will continue to execute; while require causes a Fatal error (Fatal error), the program terminates here.

include_once and require_once
should be used when the same file may be included more than once during script execution and you want to ensure that it is only included once to avoid function redefinition , variables reassignment and other issues.

1.include is loaded when used. This function is usually placed in the processing section of Process Control
2.require is loaded at the beginning. This function Usually placed at the front of the PHP program
3._once suffix indicates that the loaded one is not loaded

There are a lot of searches on the Internet about this issue. There is no big research on include and include_once. The difference is that include does not care about you. Whether the file has been introduced before, it is still imported. include_once checks whether the file has been introduced before. If it has been introduced, it will no longer be introduced.
It is generally recommended to use require_once, so the author is recommended to check include and require. There are many differences online. Here are two simple ones:
Incloude introduces a file sending error or the file does not exist. include will issue a warning and continue to execute the program, while require will generate a fatal error and terminate the program.
The require_once() statement includes and runs the specified file during script execution. This behavior is similar to the require() statement, the only difference is that if the code in the file is already included, it will not be included again. The role of the require_once() function is almost the same as require(). The
include_once() statement includes and runs the specified file during script execution. This behavior is similar to the include() statement, the only difference is that if the code in the file is already included, it will not be included again. As the name of this statement implies, it will only be included once. The function of clude_once() function is almost the same as include().
The function of require_once is to check whether the file has been loaded before. If it has not been loaded, load it. If it has been loaded, it will not load it again. For example, if a file defines a type, an error will occur if the file is loaded twice. require_once will avoid this error.

I have been using include_once since I learned the difference between include and include_once, thinking that it only loads once to avoid duplication. Loading, and it seems that I can't determine whether it has been loaded repeatedly. It turns out that I have been wrong all along.

In fact, there are advantages. If the project is developed by several people, include_once is better.

include_once execution sequence

Try to parse the absolute path of the file, if it can be parsed successfully , then check EG(included_files), return if it exists, continue if it does not exist

Open the file, get the open path of the file

Take the opened path and search in EG(included_files), whether Exists, if it exists, return, if it does not exist, continue

Compile file (compile_file

Recently, we have had several discussions about the removal of apc.include_once_override, and this APC configuration item has always been It has not been implemented well.

Here, I would like to share with you the reasons for this problem and some inspirations for us.

About using include or include_once (The following, 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. The most common reason in the past was that include_once needs to query the loaded file list to confirm whether it exists, and then Reload.

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

We know that PHP determines whether a file has been loaded. You need to get the opened_path of this file, which means, for example:

The above is the detailed content of PHP detailed explanation of the difference between include_once and include. For more information, please follow other related articles on the PHP Chinese website!