Konstanten gehören zu den grundlegenden Bausteinen jeder PHP-Anwendung. Im Gegensatz zu Variablen lässt sich ihr Wert nach der Definition nicht mehr ändern, was sie ideal für Konfigurationswerte, feste Bezeichnungen und unverfälschbare Einstellungen macht. PHP bietet mehrere Wege, Konstanten zu definieren: die Funktion define(), das Schlüsselwort const und Klassen-Konstanten mit optionaler Sichtbarkeit. Hinzu kommen vordefinierte Konstanten wie PHP_VERSION sowie die sogenannten Magic Constants, die ihren Wert je nach Position im Code ändern. Dieses Tutorial erklärt alle Konstantentypen in PHP, zeigt die Funktion constant() für den dynamischen Zugriff und behandelt Typed Class Constants ab PHP 8.3.
Den Anfang machen die beiden grundlegenden Wege, globale Konstanten zu erstellen, samt ihren jeweiligen Einschränkungen.
Globale Konstanten mit define() und const
PHP stellt zwei Möglichkeiten bereit, globale Konstanten zu definieren. Beide erzeugen einen unveränderlichen Wert, unterscheiden sich jedoch in ihrem Einsatzbereich und ihren Einschränkungen.
<?php
/* Konstante mit define() erstellen */
define('DATENBANK_HOST', 'localhost');
define('MAX_VERSUCHE', 5);
define('APP_DEBUG', false);
echo DATENBANK_HOST;
/* Ausgabe: localhost */
/* Konstante mit const erstellen */
const API_VERSION = '2.1';
const STANDARD_SPRACHE = 'de';
echo API_VERSION;
/* Ausgabe: 2.1 */
Die Funktion define() wird zur Laufzeit ausgeführt und kann daher innerhalb von Bedingungen, Schleifen oder Funktionen stehen. Das Schlüsselwort const hingegen wird zur Kompilierzeit verarbeitet und muss im obersten Scope einer Datei oder innerhalb einer Klasse stehen. Es darf nicht in if-Blöcken, Schleifen oder Funktionen verwendet werden. Beide Varianten akzeptieren skalare Werte wie Strings, Integers, Floats und Booleans. Seit PHP 7.0 erlaubt define() auch Arrays als Konstanten-Wert, const unterstützt Arrays ebenfalls seit PHP 5.6.
<?php
/* define() funktioniert in Bedingungen */
$umgebung = 'produktion';
if ($umgebung === 'produktion') {
define('LOG_LEVEL', 'error');
} else {
define('LOG_LEVEL', 'debug');
}
echo LOG_LEVEL;
/* Ausgabe: error */
/* const kann NICHT in Bedingungen stehen */
/* Der folgende Code wuerde einen Fehler ausloesen: */
/* if (true) { const TEST = 1; } */
Ein wichtiger Unterschied betrifft auch die Namenskonvention. Konstantennamen werden per Konvention in Großbuchstaben mit Unterstrichen geschrieben, beispielsweise MAX_UPLOAD_GROESSE. Seit PHP 8.0 löst der Zugriff auf eine nicht definierte Konstante einen Error aus, während ältere PHP-Versionen lediglich eine Warnung erzeugten und den Konstantennamen als String interpretierten. Die Funktion defined() prüft, ob eine Konstante existiert, bevor auf sie zugegriffen wird.
Klassen-Konstanten (Class Constants)
Klassen-Konstanten werden innerhalb einer Klasse mit dem Schlüsselwort const definiert und gehören fest zur jeweiligen Klasse. Sie eignen sich hervorragend für Werte, die logisch zu einer bestimmten Klasse gehören, etwa HTTP-Statuscodes oder Konfigurationswerte.
<?php
class HttpStatus
{
public const OK = 200;
public const ERSTELLT = 201;
public const NOT_FOUND = 404;
protected const INTERNAL_ERROR = 500;
private const SECRET_CODE = 999;
}
echo HttpStatus::OK;
/* Ausgabe: 200 */
echo HttpStatus::NOT_FOUND;
/* Ausgabe: 404 */
Der Zugriff auf Klassen-Konstanten erfolgt über den Doppelpunkt-Operator ::, gefolgt vom Konstantennamen. Standardmäßig sind Klassen-Konstanten public, also von überall aus zugänglich. Seit PHP 7.1 lässt sich die Sichtbarkeit explizit mit public, protected oder private festlegen. Eine protected-Konstante ist nur innerhalb der Klasse selbst und in abgeleiteten Klassen sichtbar, eine private-Konstante ausschließlich in der definierenden Klasse.
Vererbung von Klassen-Konstanten
Klassen-Konstanten können in abgeleiteten Klassen überschrieben werden, solange ihre Sichtbarkeit dies zulässt.
<?php
class BasisKlasse
{
public const VERSION = '1.0';
public function zeigeVersion(): string
{
return static::VERSION;
}
}
class ErweiterteKlasse extends BasisKlasse
{
public const VERSION = '2.0';
}
$basis = new BasisKlasse();
echo $basis->zeigeVersion();
/* Ausgabe: 1.0 */
$erweitert = new ErweiterteKlasse();
echo $erweitert->zeigeVersion();
/* Ausgabe: 2.0 */
Durch die Verwendung von static::VERSION anstelle von self::VERSION wird die Late Static Binding Funktionalität genutzt. Das bedeutet, dass PHP erst zur Laufzeit entscheidet, welche Klasse gemeint ist. Mit self::VERSION würde immer der Wert der Basisklasse zurückgegeben, unabhängig davon, auf welchem Objekt die Methode aufgerufen wird.
Typed Class Constants (PHP 8.3)
Seit PHP 8.3 können Klassen-Konstanten mit einem Typ versehen werden. Diese Neuerung sorgt für zusätzliche Typsicherheit, insbesondere bei der Vererbung.
<?php
class Einstellungen
{
public const string APP_NAME = 'Meine Anwendung';
public const int MAX_VERSUCHE = 5;
public const float STEUER_SATZ = 19.0;
public const bool DEBUG_MODUS = false;
public const array ERLAUBTE_FORMATE = ['jpg', 'png', 'webp'];
}
echo Einstellungen::APP_NAME;
/* Ausgabe: Meine Anwendung */
echo Einstellungen::MAX_VERSUCHE;
/* Ausgabe: 5 */
Unterstützte Typen sind string, int, float, bool, array, object und auch Union-Types. Der Hauptvorteil zeigt sich bei der Vererbung: Eine abgeleitete Klasse kann eine typisierte Konstante nur mit einem kompatiblen Typ überschreiben. Wird beispielsweise in der Basisklasse public const int MAX = 100 definiert, darf die Kindklasse diesen Wert nicht mit einem String überschreiben. PHP wirft in diesem Fall einen Fehler. Dadurch wird die Integrität von Konstanten über Vererbungshierarchien hinweg sichergestellt.
Die Funktion constant()
Die Funktion constant() ermöglicht den dynamischen Zugriff auf eine Konstante über ihren Namen als String. Das ist besonders nützlich, wenn der Konstantenname erst zur Laufzeit zusammengesetzt wird.
<?php
define('SPRACHE_DE', 'Deutsch');
define('SPRACHE_EN', 'English');
define('SPRACHE_FR', 'Français');
$sprachCode = 'DE';
$konstantenName = 'SPRACHE_' . $sprachCode;
echo constant($konstantenName);
/* Ausgabe: Deutsch */
/* Auch Klassen-Konstanten lassen sich dynamisch abrufen */
class Farben
{
public const ROT = '#FF0000';
public const GRUEN = '#00FF00';
public const BLAU = '#0000FF';
}
$gewaehlte = 'ROT';
echo constant('Farben::' . $gewaehlte);
/* Ausgabe: #FF0000 */
Ohne constant() wäre ein dynamischer Zugriff auf Konstanten nicht möglich, da PHP den Konstantennamen direkt im Code erwartet. Die Funktion wirft einen Error, wenn die angegebene Konstante nicht existiert. Eine vorherige Prüfung mit defined() verhindert diese Fehlermeldung. Die Kombination aus defined() und constant() ist ein gängiges Muster, um sicher auf dynamisch zusammengesetzte Konstantennamen zuzugreifen.
Vordefinierte Konstanten (Predefined Constants)
PHP bringt eine Vielzahl vordefinierter Konstanten mit, die Informationen über die Laufzeitumgebung, das Betriebssystem und die PHP-Version bereitstellen.
<?php
echo PHP_VERSION;
/* Ausgabe: z.B. 8.3.4 */
echo PHP_INT_MAX;
/* Ausgabe: 9223372036854775807 (auf 64-Bit-Systemen) */
echo PHP_EOL;
/* Zeilenumbruch des aktuellen Betriebssystems */
echo PHP_OS;
/* Ausgabe: z.B. Linux oder WINNT */
echo DIRECTORY_SEPARATOR;
/* Ausgabe: / auf Linux, \ auf Windows */
/* Prüfung der PHP-Version */
if (PHP_MAJOR_VERSION >= 8) {
echo 'PHP 8 oder neuer';
}
Die Konstante PHP_EOL liefert den plattformspezifischen Zeilenumbruch und macht Code portabel zwischen verschiedenen Betriebssystemen. PHP_INT_MAX und PHP_INT_MIN geben die Grenzen des Integer-Datentyps an, was bei mathematischen Berechnungen relevant sein kann. DIRECTORY_SEPARATOR enthält den Pfadtrenner des jeweiligen Betriebssystems und sorgt für plattformübergreifend korrekte Dateipfade.
Magic Constants
Magic Constants sind spezielle Konstanten, die ihren Wert je nach Position im Quellcode ändern. Trotz ihres Namens verhalten sie sich nicht wie herkömmliche Konstanten, da ihr Wert vom Kontext abhängt.
<?php
echo 'Datei: ' . __FILE__;
/* Vollstaendiger Pfad der aktuellen Datei */
echo 'Verzeichnis: ' . __DIR__;
/* Verzeichnis der aktuellen Datei */
echo 'Zeile: ' . __LINE__;
/* Aktuelle Zeilennummer */
function protokolliere($nachricht)
{
echo __FUNCTION__ . ': ' . $nachricht;
/* Ausgabe: protokolliere: ... */
}
class Logger
{
public function schreibe($text)
{
echo __CLASS__ . '::' . __METHOD__;
/* Ausgabe: Logger::Logger::schreibe */
}
}
protokolliere('Test');
Die am häufigsten verwendeten Magic Constants sind __FILE__ (vollständiger Dateipfad), __DIR__ (Verzeichnis der Datei), __LINE__ (aktuelle Zeilennummer), __FUNCTION__ (Name der aktuellen Funktion), __CLASS__ (Name der aktuellen Klasse) und __METHOD__ (Name der aktuellen Methode inklusive Klassenname). Sie sind besonders nützlich für Logging, Debugging und das automatische Laden von Dateien. Die Konstante __DIR__ ersetzt dabei das früher gebräuchliche dirname(__FILE__) und liefert das gleiche Ergebnis in einer kürzeren Schreibweise.
Übersicht der Konstantentypen
Das folgende Diagramm zeigt die verschiedenen Arten von Konstanten in PHP und ihre jeweiligen Merkmale.
flowchart TD
A["PHP Konstanten"]
A --> B["define()"]
A --> C["const"]
A --> D["Klassen-Konstanten"]
A --> E["Vordefinierte"]
A --> F["Magic Constants"]
B --> B1["Laufzeit, in Bedingungen"]
C --> C1["Kompilierzeit, in Klassen"]
D --> D1["Sichtbarkeit, Typed"]
Best Practices für Konstanten
Die richtige Verwendung von Konstanten trägt maßgeblich zur Wartbarkeit und Lesbarkeit von PHP-Code bei. Die folgenden Empfehlungen helfen dabei, Konstanten sinnvoll einzusetzen.
Konstantennamen sollten immer in Großbuchstaben mit Unterstrichen geschrieben werden, etwa MAX_UPLOAD_GROESSE oder STANDARD_ZEITZONE. Diese Konvention macht Konstanten im Code sofort erkennbar und unterscheidet sie klar von Variablen. Für zusammengehörige Werte, die logisch zu einer Klasse gehören, sind Klassen-Konstanten gegenüber globalen Konstanten zu bevorzugen. Sie vermeiden Namenskollisionen und bieten mit Sichtbarkeitsmodifikatoren eine bessere Kapselung.
Die Funktion define() eignet sich besonders für Konfigurationsdateien, in denen Konstanten bedingt gesetzt werden müssen. Das Schlüsselwort const ist hingegen die bessere Wahl für feste Werte im globalen Scope und innerhalb von Klassen. Ab PHP 8.3 sollten Klassen-Konstanten wenn möglich typisiert werden, um Fehler bei der Vererbung frühzeitig zu erkennen. Die Funktion defined() sollte stets vor dem Zugriff auf eine Konstante verwendet werden, deren Existenz nicht garantiert ist.
Fazit
Konstanten sind ein unverzichtbarer Bestandteil jeder PHP-Anwendung. Mit define() und const stehen zwei Möglichkeiten für globale Konstanten zur Verfügung, wobei define() flexibler einsetzbar ist und const zur Kompilierzeit verarbeitet wird. Klassen-Konstanten bieten eine saubere Zuordnung von festen Werten zu einer Klasse und unterstützen seit PHP 7.1 Sichtbarkeitsmodifikatoren. Mit PHP 8.3 kamen Typed Class Constants hinzu, die die Typsicherheit bei der Vererbung gewährleisten. Die Funktion constant() ermöglicht den dynamischen Zugriff auf Konstanten per String, während vordefinierte Konstanten wie PHP_VERSION und Magic Constants wie __FILE__ wertvolle Informationen über die Laufzeitumgebung liefern. Für robusten und wartbaren Code empfiehlt es sich, Konstantennamen konsequent in Großbuchstaben zu schreiben, Klassen-Konstanten gegenüber globalen Konstanten zu bevorzugen und ab PHP 8.3 die Typisierung von Klassen-Konstanten zu nutzen.
