Quelle est la différence entre include et require ?

Question

Accepted Answer

Les deux `include` et `require` importent (et exécutent) le contenu d'un autre fichier PHP dans le fichier actuel. La **seule différence réside dans la façon dont ils gèrent l'échec** : `require` génère une erreur fatale si le fichier est manquant, tandis que `include` n'émet qu'un avertissement et continue.

## Pourquoi c'est important

```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
```

Utilisez **`require`** pour les fichiers dont l'application **ne peut pas fonctionner sans** (classes essentielles, configuration critique, configuration de base de données) — vous voulez qu'elle s'arrête immédiatement si ces fichiers sont manquants. Utilisez **`include`** pour les fichiers optionnels (par ex. un modèle de barre latérale) où un fichier manquant ne devrait pas bloquer la page.

## Les variantes _once (prévenir les doublons)

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

`require_once`/`include_once` importent le fichier uniquement s'il n'a pas déjà été importé — **essentiel** pour éviter les erreurs « impossible de redéclarer une fonction/classe » quand un fichier pourrait être inclus plusieurs fois (par ex. une définition de classe appelée par plusieurs fichiers).

## Ce que l'inclusion fait réellement

```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
```

## PHP moderne : l'autoloading remplace les includes manuels

```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
```

En PHP moderne, vous utilisez rarement `require` manuel pour les classes — **l'autoloader de Composer** les charge à la demande. Vous utilisez toujours `require "vendor/autoload.php"` une fois pour l'initialiser.

## Pourquoi c'est important

Comprendre `include` vs `require` est une connaissance PHP basique mais importante — c'est ainsi que les fichiers PHP partagent du code, et la distinction est importante pour la justesse.

Le point clé est le comportement en cas d'échec : **`require` pour les fichiers essentiels** (pour que l'application échoue rapidement et clairement si un fichier critique est manquant) et **`include` pour les fichiers optionnels** (pour qu'un fichier non critique manquant ne bloque pas la page).

Connaître les **variantes `_once`** est pratiquement essentiel pour éviter les erreurs courantes « impossible de redéclarer » en incluant accidentellement une définition de classe ou de fonction deux fois.

Tout aussi important est de comprendre le contexte moderne : bien que ces constructs soient fondamentaux, **le PHP moderne s'appuie sur l'autoloading de Composer** (chargement des classes à la demande) plutôt que sur l'ajout manuel de chaque fichier, donc dans le code actuel vous faites généralement juste `require "vendor/autoload.php"` une fois et laissez l'autoloading gérer le reste.

Connaître à la fois la mécanique de include/require (et quand chaque mode d'échec est approprié) et comment l'autoloading moderne remplace les includes manuels est une connaissance quotidienne pour travailler avec les codebases PHP anciens et nouveaux.