PHP Konstanten: define() vs const und magische Konstanten

Eine Konstante ist ein Name für einen Wert, der sich während der Laufzeit des Skripts nie ändert. Deklariere sie mit const MAX_USERS = 100; oder define('MAX_USERS', 100); und verwende dann den bloßen Namen, ohne $.

<?php
const SITE_NAME = "Coffee Corner";
define("MAX_ITEMS", 5);

echo SITE_NAME, "\n";
echo "You can order up to " . MAX_ITEMS . " items\n";

$price = 3.5;
const TAX_RATE = 0.2;
echo "Total: ", $price * (1 + TAX_RATE), "\n";

Konventionell werden Konstantennamen in UPPER_SNAKE_CASE geschrieben. Sie sind global: Eine Konstante, die am Anfang einer Datei deklariert wird, ist in jeder Funktion sichtbar, ohne global.

define() vs const

Beide erzeugen eine Konstante, aber zu verschiedenen Zeitpunkten. const wird aufgelöst, wenn PHP die Datei kompiliert, define() läuft wie jeder andere Funktionsaufruf.

<?php
// const accepts expressions made of literals and other constants
const SECONDS_PER_DAY = 24 * 60 * 60;
const GREETING = "Hello, " . "world";

// define() can run conditionally and take a computed name
$env = "dev";
if ($env === "dev") {
    define("DEBUG", true);
}
foreach (["RED" => "#f00", "GREEN" => "#0f0"] as $name => $hex) {
    define("COLOR_" . $name, $hex);
}

echo SECONDS_PER_DAY, "\n";
echo GREETING, "\n";
var_dump(DEBUG);
echo COLOR_GREEN, "\n";

Verwende standardmäßig const, weil es kürzer ist und beim Kompilieren geprüft wird. Verwende define(), wenn die Konstante von einer Bedingung oder einem berechneten Namen abhängt.

Konstanten lassen sich nicht ändern

Einer Konstante etwas zuzuweisen ist ein Parse-Fehler:

<?php
const LIMIT = 10;
LIMIT = 20;

PHP Parse error:  syntax error, unexpected token "=" in /home/index.php on line 3

Dieselbe Konstante zweimal zu definieren ist kein Fehler, aber PHP gibt eine Warnung aus und behält den ersten Wert:

<?php
define("LIMIT", 10);
define("LIMIT", 20);
echo LIMIT; // 10

Warning: Constant LIMIT already defined in /home/index.php on line 3

Wenn ein Wert schon gesetzt sein könnte (zum Beispiel in einer Konfigurationsdatei, die mehrmals geladen wird), prüfst du zuerst mit defined():

<?php
if (!defined("APP_ENV")) {
    define("APP_ENV", "production");
}
if (!defined("APP_ENV")) {
    define("APP_ENV", "testing");   // skipped
}
echo APP_ENV, "\n";

var_dump(defined("APP_ENV"));
var_dump(defined("NOT_THERE"));

// Read a constant whose name is in a string
$name = "APP_ENV";
echo constant($name), "\n";

Konstante Arrays

Eine Konstante kann ein Array enthalten. Du kannst es mit NAME[key] lesen, darüber iterieren und es weitergeben, aber nicht ändern.

<?php
const WEEKDAYS = ["Mon", "Tue", "Wed", "Thu", "Fri"];
define("HTTP_CODES", [200 => "OK", 404 => "Not Found", 500 => "Server Error"]);

echo WEEKDAYS[0], "\n";
echo count(WEEKDAYS), " weekdays\n";
echo HTTP_CODES[404], "\n";

foreach (HTTP_CODES as $code => $text) {
    echo "$code $text\n";
}

Klassenkonstanten

In einer Klasse deklariert const eine Konstante, die zur Klasse gehört. Von außen liest du sie mit ClassName::NAME, von innen mit self::NAME oder static::NAME. Klassenkonstanten können eine Sichtbarkeit haben, final sein und seit PHP 8.3 einen Typ deklarieren.

<?php
class Order
{
    public const STATUS_NEW = "new";
    public const STATUS_PAID = "paid";
    private const MAX_LINES = 50;
    final public const string CURRENCY = "EUR";   // typed, PHP 8.3

    public function __construct(public string $status = self::STATUS_NEW) {}

    public function canAddLine(int $lines): bool
    {
        return $lines < self::MAX_LINES;
    }
}

$order = new Order();
echo $order->status, "\n";
echo Order::STATUS_PAID, "\n";
echo Order::CURRENCY, "\n";
var_dump($order->canAddLine(10));

// Dynamic access by name
$which = "STATUS_PAID";
echo constant("Order::$which"), "\n";

Eine Gruppe zusammengehöriger Klassenkonstanten wie STATUS_NEW und STATUS_PAID schreibt man oft besser als Enum, das außerdem verhindert, dass ungültige Werte weitergereicht werden.

Magische Konstanten: LINE, FILE, DIR und mehr

Magische Konstanten ändern ihren Wert je nachdem, wo sie stehen. Sie werden beim Kompilieren eingesetzt.

<?php
namespace App\Billing;

class Invoice
{
    public function describe(): string
    {
        return "class: " . __CLASS__ . "\n"
            . "method: " . __METHOD__ . "\n"
            . "function: " . __FUNCTION__ . "\n";
    }
}

echo (new Invoice())->describe();
echo "namespace: ", __NAMESPACE__, "\n";
echo "line: ", __LINE__, "\n";
echo "file: ", basename(__FILE__), "\n";
echo "dir is a directory: ", var_export(is_dir(__DIR__), true), "\n";

Am häufigsten wird __DIR__ verwendet, das Verzeichnis der aktuellen Datei. Include-Pfade, die darauf aufbauen, funktionieren egal, aus welchem Verzeichnis das Skript gestartet wurde: require __DIR__ . '/config.php';. Das vollständige Muster steht unter include und require.

Eingebaute Konstanten, die man kennen sollte

PHP definiert viele eigene Konstanten. Diese begegnen dir ständig:

<?php
echo "PHP_VERSION:   ", PHP_VERSION, "\n";
echo "PHP_INT_MAX:   ", PHP_INT_MAX, "\n";
echo "PHP_INT_SIZE:  ", PHP_INT_SIZE, " bytes\n";
echo "PHP_FLOAT_EPSILON: ", PHP_FLOAT_EPSILON, "\n";
echo "M_PI:          ", M_PI, "\n";
echo "PHP_OS_FAMILY: ", PHP_OS_FAMILY, "\n";
echo "E_ALL:         ", E_ALL, "\n";
echo "PHP_EOL is a newline: ", var_export(PHP_EOL === "\n", true), PHP_EOL;

PHP_EOL ist das Zeilenende des Systems, auf dem PHP läuft ("\n" unter Linux und macOS, "\r\n" unter Windows). Es ist für Text gedacht, der in Dateien und ins Terminal geschrieben wird; in HTML-Ausgabe ist ein Zeilenumbruch nicht sichtbar, verwende dort <br>.