Abschnitt 13 · Lektion 5
Namensräume
Zwei Klassen, die beide Notiz heißen, verträgt PHP ohne Namensräume nicht. Beim zweiten
class Notiz ist Schluss. Bringt etwa der Import aus einer alten Liste seine eigene Notiz mit,
benennst du in deinem Code eben eine der beiden um. Bei Klassen aus einem Paket geht das nicht, denn
wie fremde Klassen heißen, entscheidest du nicht.
Zwei Klassen dürfen denselben Namen haben
<?php
declare(strict_types=1);
namespace App\Modell;
class Notiz
{
public function __construct(public readonly string $titel)
{
}
} <?php
declare(strict_types=1);
namespace App\Import;
// Derselbe kurze Name, anderer Namensraum. Stuende in keiner der
// beiden Dateien ein namespace, braeche PHP beim zweiten require
// ab: Notiz gibt es dann schon.
class Notiz
{
public function __construct(public readonly string $zeile)
{
}
} <?php
declare(strict_types=1);
require __DIR__ . "/modell.php";
require __DIR__ . "/import.php";
// Ohne use geht es auch, dann steht der volle Name da.
$eine = new \App\Modell\Notiz("Milch kaufen");
$andere = new \App\Import\Notiz(" Milch kaufen ");
echo get_class($eine), "\n";
echo get_class($andere), "\n";
echo "Titel: ", $eine->titel, "\n"; Den Abbruch beim zweiten class Notiz meldet PHP 8.2 und PHP 8.3 als
Cannot declare class Notiz, because the name is already in use. Ab PHP 8.4 heißt er
Cannot redeclare class Notiz, mit der Stelle, an der die erste steht. Im Beispiel kommt es nicht
dazu, denn beide Klassen tragen einen Namensraum.
Ein Namensraum verlängert den Namen. Steht am Anfang einer Datei namespace App\Modell;, heißt
die Klasse Notiz darin mit vollem Namen App\Modell\Notiz. Der Backslash trennt die Teile, so wie
der Schrägstrich Ordner trennt.
Die Zeile muss die erste Anweisung der Datei sein, und sie gilt für alles darunter. Davor darf nur
ein declare stehen, in diesem Kurs declare(strict_types=1). In den Dateien des Kurses stehen die
beiden Zeilen deshalb immer so übereinander.
use kürzt ab und lädt nichts
<?php
declare(strict_types=1);
namespace App\Modell;
class Notiz
{
public function __construct(public readonly string $titel)
{
}
} <?php
declare(strict_types=1);
namespace App\Import;
class Notiz
{
public function __construct(public readonly string $zeile)
{
}
} <?php
declare(strict_types=1);
require __DIR__ . "/modell.php";
require __DIR__ . "/import.php";
// use laedt nichts. Es sagt nur: wenn hier unten Notiz steht,
// meine ich diese. Zweimal derselbe kurze Name geht deshalb
// nicht, und dafuer gibt es as.
use App\Modell\Notiz;
use App\Import\Notiz as RoheNotiz;
$eine = new Notiz("Milch kaufen");
$andere = new RoheNotiz(" Milch kaufen ");
echo get_class($eine), "\n";
echo get_class($andere), "\n";
// Der volle Name steht auch drin, wenn man ihn braucht.
echo Notiz::class, "\n";
echo RoheNotiz::class, "\n"; Volle Namen sind lang und mühsam zu lesen. Deshalb gibt es use. Mit der Zeile
use App\Modell\Notiz; ist ab da mit Notiz diese Klasse gemeint.
use lädt nichts. Es benennt nur für diese eine Datei um. Hast du die Datei mit der Klasse nicht
eingebunden, kommt trotz use ein Class "App\Modell\Notiz" not found.
Derselbe kurze Name geht in einer Datei nur einmal. Zwei use-Zeilen, die beide auf Notiz enden,
scheitern schon beim Einlesen mit
Cannot use App\Import\Notiz as Notiz because the name is already in use. Dafür gibt es as.
use App\Import\Notiz as RoheNotiz; vergibt einen zweiten Namen, der nur in dieser Datei gilt.
Der Zusatz ::class gibt zu jeder Klasse ihren vollen Namen als Text zurück, auch wenn er oben mit
use abgekürzt ist. Im Reiter Debug stehen ebenfalls nur die vollen Namen,
eine=App\Modell\Notiz {titel: …} neben andere=App\Import\Notiz {zeile: …}.
Eingebaute Klassen brauchen einen Backslash
<?php
declare(strict_types=1);
namespace App\Dienst;
// Eingebaute Klassen liegen im globalen Raum. In einer Datei mit
// Namensraum sucht PHP sie deshalb nur nebenan.
try {
throw new InvalidArgumentException("Titel fehlt");
} catch (\Error $fehler) {
echo "Gesucht wurde: ", $fehler->getMessage(), "\n";
}
// Mit einem Backslash davor ist klar, wo sie steht.
try {
throw new \InvalidArgumentException("Titel fehlt");
} catch (\InvalidArgumentException $fehler) {
echo "Gefangen: ", $fehler->getMessage(), "\n";
}
// Bei Funktionen ist es anders: PHP faellt von selbst auf global
// zurueck, deshalb braucht strlen() keinen Backslash.
echo "Länge: ", strlen("Milch"), "\n"; Eingebaute Klassen wie Exception, InvalidArgumentException, DateTimeImmutable oder PDO
liegen im globalen Namensraum, also in gar keinem. In einer Datei mit namespace App\Dienst; sucht
PHP new InvalidArgumentException(...) deshalb nur als App\Dienst\InvalidArgumentException. Es
findet nichts und bricht ab.
Der führende Backslash heißt „von ganz oben“, und mit new \InvalidArgumentException(...) findet
PHP die richtige. Steht einmal use InvalidArgumentException; am Dateianfang, reicht auch der kurze
Name wieder.
Bei Funktionen ist es anders. strlen(), count() und trim() funktionieren in jedem Namensraum
ohne Backslash, denn hier fällt PHP von selbst auf den globalen Raum zurück, wenn es im Namensraum
nichts findet. Bei Klassen tut es das nicht. Der halbe Code läuft also weiter wie gewohnt, und
gerade das macht den Fehler so überraschend. Mit dem einzeiligen Befehl aus der Befehlsleiste siehst
du beides, erst die 5 aus strlen("Milch"), dann den Abbruch mit Class "App\Exception" not found.
Der Namensraum ist der Ordner
<?php
declare(strict_types=1);
namespace App\Modell;
class Notiz
{
public function __construct(public readonly string $titel)
{
}
} <?php
declare(strict_types=1);
// Dieselbe Rechnung wie in Lektion 9.5, hier nur von der anderen
// Seite betrachtet: der Namensraum ist der Ordner.
spl_autoload_register(function (string $klasse): void {
$rest = substr($klasse, strlen("App\\"));
$datei = __DIR__ . "/src/" . str_replace("\\", "/", $rest) . ".php";
echo " gesucht in: src/", str_replace("\\", "/", $rest), ".php\n";
if (is_file($datei)) {
require $datei;
}
});
$notiz = new \App\Modell\Notiz("Milch kaufen");
echo "Klasse: ", $notiz::class, "\n";
echo "Titel: ", $notiz->titel, "\n"; Technisch hat ein Namensraum mit Ordnern nichts zu tun. Alle Klassen dürften in einer einzigen Datei stehen, jede in einem anderen Namensraum.
Composer braucht fürs Autoloading aber eine Verabredung. PSR-4 legt fest, dass der Namensraum
dem Ordner entspricht und der Klassenname dem Dateinamen. Erst dadurch kann ein Autoloader aus
App\Modell\Notiz den Pfad src/Modell/Notiz.php ausrechnen, ohne irgendeine Liste zu führen. Mit
find src -type f siehst du, dass die Datei im Beispiel wirklich dort liegt.
Hält sich jede Datei an diese Verabredung, bleibt in einer Anwendung eine einzige require-Zeile
übrig. Die für den Autoloader.
Was ein Namensraum regelt
Ein Namensraum regelt nur, wie etwas heißt. Er lädt nichts und verbirgt nichts. Wer etwas anfassen
darf, regeln private und public. An jede Klasse in jedem Namensraum kommst du heran, wenn du
ihren vollen Namen hinschreibst.
Für die Aufgabe liegen zwei Klassen namens Notiz in einem Projekt, und der Umwandler zwischen
ihnen fehlt noch.
Zum Mitnehmen
Ein Namensraum ist ein Nachname für Klassen, und mit ihm dürfen zwei Klassen Notiz nebeneinander leben. Nach PSR-4 entspricht er dem Ordner, use kürzt ihn nur ab, und eine eingebaute Klasse wie Exception braucht darin einen Backslash davor.
Jetzt du
Basis Konto, kostenlosZu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.
Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.
In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.
Was in dieser Lektion steckt
-
Artikel mit 4 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.