Hva er forskjellen mellom include og require?

Question

Accepted Answer

Både `include` og `require` importerer (og kjører) innholdet fra en annen PHP-fil inn i den nåværende. **Den eneste forskjellen er hvordan de håndterer feil**: `require` forårsaker en fatal feil hvis filen mangler, mens `include` bare sender ut en advarsel og fortsetter.

## Nøkkelforskjellen: feilhå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
```

Bruk **`require`** for filer som applikasjonen **ikke kan kjøre uten** (kjerneklasser, kritisk konfigurasjon, databaseoppsett) — du vil at den skal stoppe hardt hvis de mangler. Bruk **`include`** for valgfrie filer (f.eks. en sidebarmal) der en manglende fil ikke skal krasje siden.

## Variantene med _once (hindrer dobbel inkludering)

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

`require_once`/`include_once` importerer filen bare hvis den ikke allerede er importert — **essensielt** for å unngå "cannot redeclare function/class"-feil når en fil kan bli inkludert flere ganger (f.eks. en klassedefinisjon hentet av flere filer).

## Hva inkludering faktisk gjø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 inkluderinger

```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 bruker du sjelden manuell `require` for klasser — **Composers autoloader** laster dem ved behov. Du bruker fortsatt `require "vendor/autoload.php"` én gang for å starte det opp.

## Hvorfor det betyr noe

Å forstå `include` vs `require` er grunnleggende men viktig PHP-kunnskap — de er hvordan PHP-filer deler kode, og skillet er viktig for korrekthet.

Hovedpunktet er feilhåndteringen: **`require` for essensielle filer** (slik at appen mislykkes raskt og tydelig hvis en kritisk fil mangler) og **`include` for valgfrie filer** (slik at en manglende ikke-kritisk fil ikke krasjer siden).

Å kjenne **`_once`-variantene** er praktisk talt essensielt for å hindre vanlige "cannot redeclare"-feil fra å ved et uhell inkludere en klassedefinisjon eller funksjon to ganger.

Like viktig er det å forstå den moderne konteksten: selv om disse konstruksjonene er grunnleggende, **stiller seg moderne PHP på Composer autoloading** (laster klasser ved behov) i stedet for manuelt å kreve hver fil, så i moderne kode gjør du stort sett bare `require "vendor/autoload.php"` én gang og lar autoloading håndtere resten.

Å kjenne både include/require-mekanikken (og når hver feilmodus er passende) og hvordan moderne autoloading erstatter manuelle inkluderinger er daglig kunnskap for å arbeide med PHP-kodebaser både gamle og nye.