Care este diferența între include și require?

Question

Accepted Answer

Atât `include` cât și `require` importă (și execută) conținutul unui alt fișier PHP în cel curent. **Singura diferență este cum gestionează eșecul**: `require` provoacă o eroare fatală dacă fișierul lipsește, în timp ce `include` doar emit un avertisment și continuă.

## Diferența cheie: comportamentul în caz de eșec

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

Folosiți **`require`** pentru fișiere pe care aplicația **nu poate funcționa fără ele** (clase de bază, configurare critică, setup bază de date) — doriți ca aceasta să se oprească definitiv dacă lipsesc. Folosiți **`include`** pentru fișiere opționale (de ex. un șablon de bară laterală) unde un fișier lipsă nu ar trebui să prăbușească pagina.

## Variantele _once (prevenirea includerii duble)

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

`require_once`/`include_once` importă fișierul doar dacă nu a fost deja inclus — **esențial** pentru a evita erorile "cannot redeclare function/class" atunci când un fișier ar putea fi inclus de mai multe ori (de ex. o definiție de clasă pe care o folosesc mai multe fișiere).

## Ce face de fapt includerea

```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 modern: autoloading-ul înlocuiește include-urile manuale

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

În PHP modern, rar folosiți `require` manual pentru clase — **autoloader-ul Composer** le încarcă pe cerere. Încă mai folosiți `require "vendor/autoload.php"` o dată pentru a-l inițializa.

## De ce contează

Înțelegerea `include` vs `require` este o cunoștință PHP de bază dar importantă — acestea sunt modul în care fișierele PHP partajează cod, iar distincția contează pentru corectitudine.

Punctul cheie este comportamentul în caz de eșec: **`require` pentru fișiere esențiale** (astfel ca aplicația să eșueze repede și clar dacă un fișier critic lipsește) și **`include` pentru cele opționale** (ainsi ca un fișier non-critic lipsă să nu prăbușească pagina).

Cunoașterea variantelor **`_once`** este practic esențială pentru a preveni erorile frecvente "cannot redeclare" din includerea accidentală a unei definiții de clasă sau funcție de două ori.

La fel de important este înțelegerea contextului modern: deși acestea sunt construcții fundamentale, **PHP modern se bazează pe autoloading-ul Composer** (încărcarea claselor pe cerere) mai degrabă decât pe cererea manuală a fiecărui fișier, deci în codul curent faceți mostly doar `require "vendor/autoload.php"` o dată și lăsați autoloading-ul să se ocupe de rest.

Cunoașterea mecanicii include/require (și când fiecare mod de eșec este potrivit) și modul în care autoloading-ul modern înlocuiește include-urile manuale este o cunoștință de zi cu zi pentru lucrul cu coduri PHP vechi și noi.