Wat is het verschil tussen include en require?

Question

Accepted Answer

Zowel `include` als `require` importeren (en voeren uit) de inhoud van een ander PHP-bestand in het huidige bestand in. Het **enige verschil is hoe zij fouten afhandelen**: `require` veroorzaakt een fatale fout als het bestand ontbreekt, terwijl `include` alleen een waarschuwing geeft en doorgaat.

## Waarom het belangrijk is

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

Gebruik **`require`** voor bestanden die de applicatie **niet zonder kan draaien** (kernklassen, kritieke configuratie, databaseopstelling) — je wilt dat het hard stopt als deze ontbreken. Gebruik **`include`** voor optionele bestanden (bijv. een sidebar-template) waarbij een ontbrekend bestand de pagina niet mag laten crashen.

## De _once-varianten (voorkomen dat bestanden dubbel worden opgenomen)

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

`require_once`/`include_once` importeren het bestand alleen als het nog niet is opgenomen — **essentieel** om "cannot redeclare function/class"-fouten te voorkomen wanneer een bestand meerdere keren kan worden opgenomen (bijv. een klassedefinitie die door meerdere bestanden wordt gebruikt).

## Wat opname eigenlijk doet

```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 vervangt handmatige 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 gebruik je zelden handmatige `require` voor klassen — **Composer's autoloader** laadt ze on demand. Je gebruikt nog steeds `require "vendor/autoload.php"` eenmaal om het op te starten.

## Waarom het belangrijk is

Begrip van `include` vs `require` is fundamentele maar belangrijke PHP-kennis — het is hoe PHP-bestanden code delen, en het onderscheid is van belang voor correctheid.

Het kernpunt is het foutafhandelingsgedrag: **`require` voor essentiële bestanden** (zodat de app snel en duidelijk faalt als een kritiek bestand ontbreekt) en **`include` voor optionele** (zodat een ontbrekend niet-kritiek bestand de pagina niet laat crashen).

Kennis van de **`_once`-varianten** is praktisch essentieel om de veelvoorkomende "cannot redeclare"-fouten te voorkomen door per ongeluk een klasdefinitie of functiedefinitie twee keer op te nemen.

Evenals belangrijk is het begrijpen van de moderne context: hoewel deze constructies fundamenteel zijn, **modern PHP vertrouwt op Composer-autoloading** (klassen on demand laden) in plaats van handmatig elk bestand te vereisen, dus in huidige code voer je meestal gewoon `require "vendor/autoload.php"` eenmaal uit en laat autoloading het rest regelen.

De include/require-mechanica kennen (en wanneer elke foutmodus passend is) en begrijpen hoe modern autoloading handmatige includes vervangt is alledaagse kennis voor het werken met PHP-codebases oud en nieuw.