In PHP, what is the difference between include(), include_once(), require(), and require_once()?

Introduction / Context:
File inclusion is a central part of structuring PHP applications. Developers use include and require to pull in shared code, configuration, and templates. Understanding the differences between include(), include_once(), require(), and require_once() is important for error handling and for avoiding duplicate inclusion of the same file. Interviewers often ask this question to confirm that candidates can choose the appropriate inclusion mechanism for different scenarios.

Given Data / Assumptions:

• All four constructs are used to insert and execute code from another file.
• The target file path may be correct or may be missing due to misconfiguration.
• Some files, such as configuration or core library files, must be available or the application should stop.
• Other files can be optional, where the application may continue even if they are missing.

Concept / Approach:
include() and require() behave similarly in that they read a specified file and execute it in the current script context. The key difference lies in error handling: include() issues a warning if the file cannot be loaded but allows the script to continue, while require() triggers a fatal error and stops execution. The include_once() and require_once() variants add another layer of behaviour by tracking whether a file has already been included and preventing it from being included more than once, which helps avoid redeclaration errors for functions and classes.

Step-by-Step Solution:
Step 1: When include("file.php") is called and file.php is found, its code is executed at that point in the script. If file.php is missing, PHP emits a warning but continues running the remaining code. Step 2: When require("file.php") is called and file.php is found, its code is also executed. If file.php is missing, PHP emits a fatal error and stops script execution immediately, preventing further code from running. Step 3: include_once("file.php") behaves like include() but checks whether file.php has already been included earlier in the request. If it has, the file is not included again. Step 4: require_once("file.php") behaves like require() with the added guarantee that the file is loaded only once, even if the statement is encountered multiple times. Step 5: Developers typically use require or require_once for critical files such as configuration and core libraries that must be present, and include or include_once for optional components or templates. Step 6: This behaviour matches the description in option a, which distinguishes error handling and single inclusion semantics.

Verification / Alternative check:
You can verify these differences with a small test script that attempts to include a non existent file using include() and require(). With include(), the script will show a warning and continue to execute subsequent echo statements; with require(), the script will terminate at the point of the missing file error. Replacing include with include_once and repeating the call will show that the file is loaded only once when it exists, preventing multiple execution of the same code.

Why Other Options Are Wrong:
Option b is wrong because include() does not stop the script on failure, and include_once() and require_once() are not specific to image files. Option c is incorrect because both include() and require() can load local or remote files depending on configuration, and the *_once forms are not deprecated aliases but actively used constructs. Option d is wrong because require() executes PHP code just like include(); it does not restrict itself to plain text.

Common Pitfalls:
Common pitfalls include using include() for critical files, which can lead to partially running code if those files are missing, and using plain include instead of include_once or require_once for library files, which can cause redeclaration errors. Another issue is relying on include paths or relative paths without understanding how they are resolved, leading to hard to debug failures. Best practice is to use require_once for essential, single load files and include or include_once for nonessential or repeatable inclusion, always with clear and reliable paths.

Final Answer:
include() and require() both load and execute code from another file, but include() only raises a warning if the file is missing while require() stops the script with a fatal error, and include_once() and require_once() add the guarantee that the file is included at most one time in a request.