What is the difference between include and require?

Question

Accepted Answer

Both `include` and `require` import (and execute) another PHP file's contents into the current one. The **only difference is how they handle failure**: `require` causes a fatal error if the file is missing, while `include` only emits a warning and continues.

## The key difference: failure behavior

```php
<?php
include "config.php";    // if missing → WARNING, script CONTINUES
require "database.php";  // if missing → FATAL ERROR, script STOPS
```

```text
include → file missing → emits a Warning, execution continues (file's code skipped)
require → file missing → throws a Fatal Error, execution HALTS
```

Use **`require`** for files the application **cannot run without** (core classes, critical config, database setup) — you want it to stop hard if they're missing. Use **`include`** for optional files (e.g. a sidebar template) where a missing file shouldn't crash the page.

## The _once variants (prevent double-inclusion)

```php
require_once "functions.php";   // include the file ONLY if not already included
include_once "helper.php";
```

`require_once`/`include_once` import the file only if it hasn't been already — **essential** to avoid "cannot redeclare function/class" errors when a file might be included multiple times (e.g. a class definition pulled in by several files).

## What inclusion actually does

```php
// included files share the SAME scope and can define functions, classes, variables
// config.php:
$dbHost = "localhost";
// main.php:
require "config.php";
echo $dbHost;   // "localhost" — the variable is available
```

## Modern PHP: autoloading replaces manual includes

```php
// ❌ old style — manually requiring every class file
require_once "User.php";
require_once "Order.php";

// ✅ modern — Composer AUTOLOADING loads classes on demand automatically
require "vendor/autoload.php";   // one line; classes load when used (PSR-4)
$user = new User();               // User.php loaded automatically
```

In modern PHP, you rarely use manual `require` for classes — **Composer's autoloader** loads them on demand. You still use `require "vendor/autoload.php"` once to bootstrap it.

## Why it matters

Understanding `include` vs `require` is basic but important PHP knowledge — they're how PHP files share code, and the distinction matters for correctness.

The key point is the failure behavior: **`require` for essential files** (so the app fails fast and clearly if a critical file is missing) and **`include` for optional ones** (so a missing non-critical file doesn't crash the page).

Knowing the **`_once` variants** is practically essential to prevent the common "cannot redeclare" errors from accidentally including a class or function definition twice.

Equally important is understanding the modern context: while these constructs are foundational, **modern PHP relies on Composer autoloading** (loading classes on demand) rather than manually requiring each file, so in current code you mostly just `require "vendor/autoload.php"` once and let autoloading handle the rest.

Knowing both the include/require mechanics (and when each failure mode is appropriate) and how modern autoloading supersedes manual includes is everyday knowledge for working with PHP codebases old and new.