Include_once vs Require_once in PHP: Key Differences and Usage

In PHP, include_once and require_once both include a file only once to avoid duplicates. The key difference is that require_once causes a fatal error and stops the script if the file is missing, while include_once only raises a warning and continues execution.

Quick Comparison

Here is a quick side-by-side comparison of include_once and require_once based on key factors:

Factor	include_once	require_once
Error on missing file	Warning (non-fatal)	Fatal error (stops script)
Script execution after error	Continues	Stops immediately
Includes file only once	Yes	Yes
Use case	Optional files, non-critical	Essential files, critical
Performance impact	Slightly slower due to check	Slightly slower due to check

Key Differences

include_once and require_once both ensure that a file is included only once during script execution, preventing duplicate code or redeclaration errors. The main difference lies in how they handle missing files.

If the file to include is missing or unreadable, include_once emits a warning but allows the script to continue running. This is useful when the included file is optional or non-critical to the rest of the program.

On the other hand, require_once triggers a fatal error if the file cannot be found or loaded, immediately stopping the script. This behavior is important when the included file contains essential code without which the program cannot function correctly.

Code Comparison

This example shows how include_once works when including a file that exists and when the file is missing.

php

<?php
// file: greetings.php
function sayHello() {
    echo "Hello from included file!\n";
}

// main script
include_once 'greetings.php';
sayHello();

// Trying to include a missing file
include_once 'missing.php';
echo "Script continues after missing include_once.\n";
?>

Output

Hello from included file!
Warning: include_once(missing.php): failed to open stream: No such file or directory in ... on line ...
Warning: include_once(): Failed opening 'missing.php' for inclusion (include_path='...') in ... on line ...
Script continues after missing include_once.

require_once Equivalent

This example shows how require_once behaves with the same files as above.

php

<?php
// file: greetings.php
function sayHello() {
    echo "Hello from required file!\n";
}

// main script
require_once 'greetings.php';
sayHello();

// Trying to require a missing file
require_once 'missing.php';
echo "This line will not be executed.\n";
?>

Output

Hello from required file!
Fatal error: require_once(): Failed opening required 'missing.php' (include_path='...') in ... on line ...

When to Use Which

Choose require_once when the file is essential for your application to run correctly, such as configuration files or core libraries. It ensures the script stops immediately if the file is missing, preventing further errors.

Use include_once when the file is optional or non-critical, like templates or additional features. This lets your script continue running even if the file is not found, allowing graceful degradation.

Key Takeaways

require_once stops the script on missing files; include_once only warns and continues.

Both include files only once to avoid duplicate code loading.

Use require_once for critical files and include_once for optional files.

Error handling behavior is the main difference affecting script flow.

Performance difference is minimal but both check if the file was already included.