What’s difference between require, include, require_once and include_once in PHP?

PHP provides four constructs to include external files into your script. Each serves a distinct purpose based on error handling and duplication prevention:

1. require vs include

• require:
  • Behavior: Includes a file and throws a fatal error (E_COMPILE_ERROR) if the file is missing.
  • Use Case: Critical files (e.g., configuration files, class definitions).
  • Example:

require 'config/database.php'; // App cannot run without this file

• include:
  • Behavior: Includes a file and throws a warning (E_WARNING) if the file is missing. The script continues execution.
  • Use Case: Optional components (e.g., templates, non-essential modules).
  • Example:
    

php include 'partials/header.php'; // Optional header; script continues even if missing

2. require_once vs include_once

These variants ensure the file is included only once, preventing duplication (e.g., redeclaring functions/classes).

• require_once:
  • Behavior: Same as require, but checks if the file is already included.
  • Use Case: Loading classes, functions, or configs that must not be redeclared.
  • Example:

require_once 'classes/User.php'; // Prevents multiple class declarations

• include_once:
  • Behavior: Same as include, but skips the file if already included.
  • Use Case: Optional files that should load once (e.g., helper functions).
  • Example:

include_once 'helpers.php'; // Load helpers once, even if called multiple times

Key Differences Summary

Construct	Error Handling	Duplication Check	Typical Use Case
require	Fatal error if missing	No	Essential files (e.g., configs)
include	Warning if missing	No	Optional files (e.g., templates)
require_once	Fatal error if missing	Yes	Classes, functions, critical code
include_once	Warning if missing	Yes	Non-critical code (e.g., helpers)

Examples

Including a Class Safely

// Prevents redeclaring the User class
require_once 'User.php';

$user = new User();

Conditional Inclusion

// Only include the file if a condition is met
if ($isAdmin) {
    require 'admin-panel.php';
}

Returning Values from Included Files

// config.php
return ['db_host' => 'localhost', 'db_user' => 'root'];

// index.php
$config = require 'config.php';
echo $config['db_host']; // Output: localhost

Best Practices

1. Use require for Critical Files: Ensure your app halts if essential files are missing.
2. Use *_once for Functions/Classes: Avoid “Cannot redeclare” errors.
3. Avoid include for Security: Never include files based on user input without validation.
4. Prefer Autoloading for Classes: Use spl_autoload_register() instead of manual includes for classes.

When to Use Each

• require: Database configs, core dependencies.
• include: HTML templates, optional modules.
• require_once: Class definitions, critical libraries.
• include_once: Helper functions, non-essential code.

By choosing the right construct, you ensure code reliability and prevent common errors like missing files or duplicate declarations.