Differences Between Include and Require in PHP with Examples

In PHP, two of the most commonly used functions for incorporating files into a script are include() and require().

While both functions may seem similar at first glance, they serve distinct purposes, and understanding their differences is essential for writing robust, error-free code.

In this article, we will explore the major differences between include and require in PHP and how to use them effectively with detailed examples.

What is the Purpose of include() and require() in PHP?

Both include() and require() are used in PHP to insert the content of one PHP file into another.

This allows for code modularity and reusability, which makes development more efficient.

However, the behavior of the two functions differs significantly when errors occur.

Include in PHP

The include() function is used to insert the content of a file during script execution. If the file cannot be found or included for some reason, include() will generate a warning but the script will continue to execute.

Syntax of include()

include('filename.php');

When you use include(), PHP attempts to find and load the file specified.

If the file is not found, PHP will issue a warning (E_WARNING), but it will not stop the script from continuing.

Example of include() in PHP

<?php
    echo "Before including the file.";
    include('non_existent_file.php');
    echo "This will still be displayed even if the file is missing.";
?>

In this example, even though the file non_existent_file.php does not exist, the script will display both the “Before including the file” and “This will still be displayed” messages.

Require in PHP

On the other hand, require() is more strict. If the file cannot be found or included, require() will generate a fatal error, which means that the script will halt immediately and no further code will be executed.

Syntax of require()

require('filename.php');

When using require(), if the specified file is missing or cannot be loaded, PHP will throw a fatal error (E_COMPILE_ERROR), and the script will stop executing altogether.

Example of require() in PHP

<?php
    echo "Before requiring the file.";
    require('non_existent_file.php');
    echo "This will never be displayed.";
?>

In this example, since non_existent_file.php does not exist, PHP will stop the script after the require() function is called, and the second echo statement will not be executed.

Differences Between include() and require()

1. Error Handling Behavior

The most significant difference between include() and require() lies in how they handle errors when the specified file is missing:

• include(): Throws a warning but the script continues to execute.
• require(): Throws a fatal error and halts the execution of the script.

2. Script Execution Continuity

• include() allows the rest of the script to run even if the file is missing.
• require() stops the entire script if the file is not found, preventing any further execution.

3. Usage in Optional and Mandatory Files

Given the above differences, developers typically use:

• include() for files that are optional, such as advertisements, sidebars, or non-critical content. Even if these files are missing, the core functionality of the application should continue.
• require() for files that are essential for the proper functioning of the script, such as configuration files, authentication scripts, or database connection files. If these files are missing, the application cannot proceed, so it’s important to stop further execution.

When to Use include()

You should use include() when the file being included is not critical to the execution of the script.

For example, if the file holds auxiliary content that, even if missing, would not affect the overall functioning of the script.

Example: Including Optional Files

<?php
    echo "Start of the script.";
    include('optional_sidebar.php'); // Optional content
    echo "End of the script.";
?>

In this example, if optional_sidebar.php is missing, a warning will be thrown, but both the start and end of the script will be executed.

When to Use require()

Use require() when the file being included is vital to the correct functioning of the script.

This is especially true for files that contain critical information, such as database connections or application configuration settings.

Example: Requiring Essential Files

<?php
    require('config.php'); // Critical file
    // Code that requires config.php to function properly
    echo "This message will only display if config.php is available.";
?>

If config.php is missing, the script will terminate immediately, and none of the subsequent code will be executed.

include_once() and require_once()

In addition to include() and require(), PHP also provides two additional functions, include_once() and require_once().

These functions are similar to their counterparts but with one key difference: they ensure that the file is included or required only once.

Why Use include_once() and require_once()?

Using include_once() or require_once() prevents the file from being loaded multiple times within the same script, which could cause issues such as re-declaring functions or classes.

Example: Using include_once()

<?php
    include_once('header.php'); 
    include_once('header.php'); // This will be ignored because the file has already been included.
?>

Example: Using require_once()

<?php
    require_once('config.php'); 
    require_once('config.php'); // This will be ignored because the file has already been required.
?>

In both cases, the file will only be included or required once, avoiding potential conflicts or errors due to re-inclusion.

Performance Considerations

When using include() and require(), performance is generally not a concern for most applications.

However, in large-scale applications where hundreds of files might be included, the choice between include(), require(), and their _once counterparts can slightly affect performance.

Best Practices

1. Use include() for non-essential files: For example, files that contain sidebars, footers, or other optional components.
2. Use require() for essential files: For example, files that contain database credentials, authentication functions, or core configuration settings.
3. Use _once versions to avoid conflicts: When you need to ensure a file is only included once in the script.

Conclusion

The choice between include() and require() in PHP boils down to the importance of the file being incorporated into the script.

include() allows for graceful failure by issuing a warning and continuing the script, while require() stops execution entirely when the file is missing.

Understanding when to use each function is critical to ensuring your PHP application runs smoothly.