Hoe werken namespaces in PHP?

Question

Accepted Answer

**Namespaces** organiseren PHP-code en voorkomen **naambotsingen** tussen klassen, functies en constanten — essentieel naarmate applicaties groeien en third-party packages gebruiken. Ze werken als mappen voor klassenamen en integreren met Composer autoloading (PSR-4).

## Het probleem dat namespaces oplossen

```text
Without namespaces, two classes named `User` (yours and a library's) would COLLIDE
("cannot redeclare class"). Namespaces give each a unique fully-qualified name.
```

## Namespaces declareren en gebruiken

```php
<?php
// declare a namespace at the top of the file (matches the directory, PSR-4)
namespace App\Models;

class User {            // fully-qualified name: App\Models\User
    // ...
}
```

```php
<?php
namespace App\Controllers;

use App\Models\User;            // IMPORT a class so you can use its short name
use App\Services\Mailer as MailService;   // import with an ALIAS

class UserController {
    public function index() {
        $user = new User();      // short name works thanks to the `use` import
        // or use the fully-qualified name: new \App\Models\User();
    }
}
```

Een bestand declareert zijn `namespace`, en andere bestanden `use` (importeren) klassen om naar hen te verwijzen met korte naam. De volledig gekwalificeerde naam (`\App\Models\User`) is wereldwijd uniek.

## Namespaces worden toegewezen aan mappen (PSR-4)

```text
Namespace            File path
App\Models\User   →  src/Models/User.php
App\Services\Mailer → src/Services/Mailer.php
→ PSR-4 autoloading: the namespace structure mirrors the folder structure, so
  Composer can find and load each class automatically (no manual require).
```

## Functies, constanten en de globale namespace importeren

```php
use function App\Helpers\format;     // import a function
use const App\Config\VERSION;        // import a constant

\strlen("x");    // a leading \ = the GLOBAL namespace (built-in functions)
```

## Waarom het belangrijk is

Namespaces zijn essentieel voor het organiseren van moderne PHP-code en vormen de basis van hoe het hele ecosysteem werkt.

Het is belangrijk om ze te begrijpen omdat ze het kritieke probleem van **naambotsingen** oplossen — zonder namespaces zouden uw klassen met elkaar en met de vele third-party packages die een echte applicatie gebruikt botsen (twee `User`-klassen kunnen niet naast elkaar bestaan), waardoor grote applicaties en package-ecosystemen onmogelijk zouden zijn.

Namespaces geven elke klasse een unieke volledig gekwalificeerde naam, en de **`use`-imports** laten u schoon naar klassen verwijzen met korte namen.

Het belangrijkste is dat namespaces integreren met **Composer autoloading via PSR-4**, waarbij de naamspace-structuur de mappenstructuur weerspiegelt zodat klassen automatisch on-demand worden geladen — dit is de basis van moderne PHP-projectstructuur en afhankelijkheidsbeheer.

Omdat elk modern PHP-framework, package en applicatie is georganiseerd met namespaces (en u kunt Composer packages niet gebruiken zonder ze te begrijpen), is het weten hoe u namespaces declareert, klassen met `use` importeert en hoe ze aan mappen worden toegewezen voor autoloading fundamentele, dagelijkse kennis voor elke moderne PHP-ontwikkelaar.

Namespaces, Composer en PSR-4 autoloading bepalen samen hoe hedendaagse PHP-projecten zijn gestructureerd.