Hvad er forskellen mellem include og require?

Question

Accepted Answer

Både `include` og `require` importerer (og udfører) indholdet af en anden PHP-fil ind i den nuværende. Den **eneste forskel er, hvordan de håndterer fejl**: `require` forårsager en fatal fejl, hvis filen mangler, mens `include` kun udsender en advarsel og fortsætter.

## Nøgleforskellen: fejlhåndtering

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

Brug **`require`** til filer, som applikationen **ikke kan køre uden** (kerneklasser, kritisk konfiguration, databaseopsætning) — du vil have den til at stoppe hårdt, hvis de mangler. Brug **`include`** til valgfrie filer (f.eks. en sidebjælke-skabelon), hvor en manglende fil ikke skal få siden til at gå i stykker.

## _once-varianterne (forhindrer dobbelt-inklusion)

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

`require_once`/`include_once` importerer filen kun, hvis den ikke allerede er blevet importeret — **væsentlig** for at undgå fejl som "cannot redeclare function/class" når en fil måske bliver inkluderet flere gange (f.eks. en klassedefinition, der bliver hentet ind af flere filer).

## Hvad inklusion faktisk gør

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

## Moderne PHP: autoloading erstatter manuelle 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
```

I moderne PHP bruger du sjældent manuel `require` til klasser — **Composers autoloader** indlæser dem efter behov. Du bruger stadig `require "vendor/autoload.php"` én gang for at starte det.

## Hvorfor det betyder noget

At forstå `include` mod `require` er grundlæggende, men vigtig PHP-viden — det er sådan, PHP-filer deler kode, og distinktionen betyder noget for korrekthed.

Hovedpunktet er fejlhåndteringen: **`require` til væsentlige filer** (så appen fejler hurtigt og tydeligt, hvis en kritisk fil mangler) og **`include` til valgfrie** (så en manglende ikke-kritisk fil ikke får siden til at gå i stykker).

At kende **`_once`-varianterne** er praktisk talt væsentlig for at forhindre de almindelige fejl som "cannot redeclare" fra at komme fra utilsigtet inkludering af en klassedefinition eller funktionsdefinition to gange.

Et lige så vigtigt punkt er at forstå den moderne kontekst: selvom disse konstruktioner er grundlæggende, **moderne PHP er afhængig af Composer autoloading** (indlæsning af klasser efter behov) i stedet for manuelt at kræve hver fil, så i aktuel kode bruger du mest bare `require "vendor/autoload.php"` én gang og lader autoloading håndtere resten.

At kende både include/require-mekanikken (og hvornår hver fejltilstand er passende) og hvordan moderne autoloading erstatter manuelle includes er daglig viden for arbejde med PHP-kodebaser både gamle og nye.