Vad är skillnaden mellan include och require?

Question

Accepted Answer

Både `include` och `require` importerar (och exekverar) innehållet från en annan PHP-fil in i den aktuella. **Den enda skillnaden är hur de hanterar fel**: `require` orsakar ett ödesdigert fel om filen saknas, medan `include` endast avger en varning och fortsätter.

## Huvudskillnaden: feltillstånd

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

Använd **`require`** för filer som applikationen **inte kan köras utan** (kärnklasser, kritisk konfiguration, databasinställning) — du vill att den ska stanna helt om de saknas. Använd **`include`** för valfria filer (t.ex. en sidofälmall) där en saknad fil inte bör krascha sidan.

## Varianterna med _once (förhindra dubbelinclusion)

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

`require_once`/`include_once` importerar filen endast om den inte redan har blivit det — **väsentligt** för att undvika fel som "cannot redeclare function/class" när en fil kan inkluderas flera gånger (t.ex. en klassdefinition som hämtas av flera filer).

## Vad inclusion faktiskt 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
```

## Modern PHP: autoloading ersätter manuella 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 modern PHP använder du sällan manuell `require` för klasser — **Composers autoloader** laddar dem på begäran. Du använder fortfarande `require "vendor/autoload.php"` en gång för att starta den.

## Varför det spelar roll

Att förstå `include` mot `require` är grundläggande men viktig PHP-kunskap — det är hur PHP-filer delar kod, och distinktionen är viktig för korrekthet.

Huvudpunkten är feltillståndet: **`require` för väsentliga filer** (så att appen misslyckas snabbt och tydligt om en kritisk fil saknas) och **`include` för valfria** (så att en saknad icke-kritisk fil inte kraschar sidan).

Att känna till **`_once`-varianterna** är praktiskt väsentligt för att förhindra vanliga fel som "cannot redeclare" från att av misstag inkludera en klass- eller funktionsdefinition två gånger.

Minst lika viktigt är att förstå det moderna sammanhanget: även om dessa konstruktioner är grundläggande, **förlitar sig modern PHP på Composer autoloading** (laddar klasser på begäran) snarare än manuellt att kräva varje fil, så i aktuell kod gör du oftast bara `require "vendor/autoload.php"` en gång och låter autoloading hantera resten.

Att kunna både include/require-mekaniken (och när varje feltillstånd är lämpligt) och hur modern autoloading ersätter manuella includes är vardagskunskap för att arbeta med PHP-kodbaser gamla och nya.