In PHP development, you'll constantly need to reuse code by inserting one file into another. This modular approach is key to building clean, maintainable applications. The two primary statements for this task are include and require, and while they might seem identical, a critical difference in how they handle errors can profoundly impact your application's stability.

This blog post will demystify this common point of confusion. We’ll go deep into what each statement does, provide clear code examples to show their behavior, and give you a simple framework for deciding which one to use every time.

The include Statement: The "Soft Fail" Approach

The include statement is designed for files that are part of your application's structure but are not absolutely essential for its core functionality. Think of components like a footer, a sidebar widget, or an optional ad banner.

Key Behavior: If the file specified by include cannot be found, PHP will issue a warning (E_WARNING) but will continue executing the rest of the script. This means your page will still load, even with an error message, preventing a small mistake from taking down your entire site.

Code Example:

Let's imagine we have a header.php and a main-content.php file.

header.php  

<?php
	echo "<h1>My Awesome Website</h1>";
	echo "<nav><ul><li>Home</li><li>About</li></ul></nav>";
?>

main-content.php  

<?php
   echo "<p>This is the main content of the page.</p>";
?>

Now, let's create a main page that includes both. We'll deliberately misspell the header file to see what happens.

index.php  

<?php
	echo "<h2>Beginning of the script</h2>";

	
	// This will fail because the filename is misspelled
	include 'hedr.php';

	
	// The script will continue to run from here
	include 'main-content.php';

	
	echo "<h2>End of the script</h2>";
?>

Output:

<h2>Beginning of the script</h2>
<b>Warning</b>:  include(hedr.php): failed to open stream: No such file or directory in <b>index.php</b> on line 4
<b>Warning</b>:  include(): Failed opening 'hedr.php' for inclusion (include_path='.;C:\php\pear') in <b>index.php</b> on line 4
<p>This is the main content of the page.</p>
<h2>End of the script</h2>

As you can see, the script issued a warning for the missing file but continued to execute. The main content was still loaded and displayed successfully.

The require Statement: The "Hard Stop" Approach

The require statement is for files that are absolutely critical for your application to function. If these files are missing, your entire application is broken. This includes files with database credentials, core class definitions, or essential utility functions.

Key Behavior: If the file specified by require cannot be found, PHP will throw a fatal error (E_COMPILE_ERROR) and immediately halt all script execution. Nothing below the require statement will be processed.

Code Example:

Let's consider a database_config.php file that is crucial for our application to connect to a database.

database_config.php

<?php
	// Assume this file contains essential database connection details
	$db_host = "localhost";
	$db_user = "root";
?>

Now, let's try to require this file from our main script. We'll pretend the file is missing to see the error.

index.php

<?php
	echo "<h2>Attempting to load critical files...</h2>";

	
	// This will fail because the file is missing
	require 'database_config.php';

	
	// This code will never be reached
	echo "<p>Connected to the database successfully!</p>";
?>

Output:

<h2>Attempting to load critical files...</h2>
<b>Fatal error</b>:  require(): Failed opening required 'database_config.php' (include_path='.;C:\php\pear') in <b>index.php</b> on line 4

The script's execution was terminated as soon as it hit the require statement. The line "<p>Connected to the database successfully!</p>" was never printed.

A Simple Rule for Choosing

The decision between include and require is all about dependency.

• Use require for essential dependencies: If the file is so critical that your program cannot proceed without it, use require. This ensures that a bug or a missing file in your core logic is caught immediately, preventing your application from running in a broken state.
• Use include for non-essential dependencies: If the file is a part of your application's layout or a small feature that can be missing without breaking the core functionality, use include. This allows the rest of your application to function even if there's a problem with a minor component.
•  

The _once Variants: A Best Practice

To prevent the same file from being included or required multiple times within the same script, PHP offers include_once and require_once. These are often the preferred methods.

• include_once works like include, but checks if the file has already been included. If it has, it won't include it again.
• require_once works like require, but also prevents the file from being required more than once.

Using these variants is a great way to prevent "redeclare function" errors and other unexpected issues that can arise from duplicate code loading.

Example:

<?php
	// This is a much safer way to load core files
	require_once 'database_config.php';

	
	// If this file is accidentally included again later, it will be ignored
	require_once 'database_config.php';
?>