Wer PHP-Formulare verarbeitet oder mit Datenbanken arbeitet, muss ständig prüfen, ob eine Variable überhaupt einen brauchbaren Wert enthält. Die beiden wichtigsten Werkzeuge dafür sind empty() und isset(). Obwohl sie ähnlich klingen, verhalten sie sich in entscheidenden Situationen unterschiedlich. Dieses Tutorial erklärt beide Funktionen im Detail, zeigt die häufigsten Stolperfallen und liefert Praxisbeispiele für den Alltag.
Was macht empty() in PHP?
Die Funktion empty() prüft, ob eine Variable leer oder nicht gesetzt ist. Sie gibt true zurück, wenn der Wert als "leer" gilt, und false, wenn ein sinnvoller Inhalt vorhanden ist.
Die Syntax ist denkbar einfach:
empty(mixed $variable): bool
Ein großer Vorteil von empty() gegenüber einem direkten Zugriff auf die Variable: Die Funktion erzeugt keine Warnung, wenn die Variable gar nicht existiert. Während !$variable bei einer nicht definierten Variable eine Undefined variable-Warnung auslöst, gibt empty($variable) in diesem Fall still true zurück. Dadurch lässt sich empty() gefahrlos aufrufen, ohne vorher mit isset() prüfen zu müssen.
<?php
$name = "";
if (empty($name)) {
echo "Kein Name angegeben.";
}
/* Ausgabe: Kein Name angegeben. */
$alter = 25;
if (empty($alter)) {
echo "Kein Alter angegeben.";
} else {
echo "Alter: " . $alter;
}
/* Ausgabe: Alter: 25 */
?>
Welche Werte gelten als empty?
Die Funktion empty() erkennt mehr Werte als leer, als man auf den ersten Blick vermuten würde. Besonders die Behandlung von "0" und 0 überrascht viele Entwickler. Die folgende Tabelle zeigt das vollständige Verhalten im Vergleich mit isset(), is_null() und der Typumwandlung nach bool:
| Wert | empty() | isset() | is_null() | (bool) |
|---|
"" (leerer String) | true | true | false | false |
"0" (String mit Null) | true | true | false | false |
0 (Integer) | true | true | false | false |
0.0 (Float) | true | true | false | false |
null | true | false | true | false |
false | true | true | false | false |
[] (leeres Array) | true | true | false | false |
| nicht gesetzte Variable | true | false | true | false |
"abc" | false | true | false | true |
1 | false | true | false | true |
true | false | true | false | true |
[0] (Array mit Inhalt) | false | true | false | true |
Besonders wichtig ist die Zeile mit "0": Der String mit dem Inhalt Null gilt für empty() als leer. Das ist eine häufige Fehlerquelle bei der Prüfung von Formulareingaben. Wenn ein Nutzer in einem Eingabefeld die Zahl 0 eingibt, liefert empty($_POST['feld']) trotzdem true.
<?php
$eingabe = "0";
if (empty($eingabe)) {
echo "Leer!";
} else {
echo "Hat einen Wert.";
}
/* Ausgabe: Leer! */
/* Besser: strikter Vergleich mit === */
if ($eingabe === "") {
echo "Wirklich leer.";
} else {
echo "Eingabe vorhanden: " . $eingabe;
}
/* Ausgabe: Eingabe vorhanden: 0 */
?>
empty() und isset() im Vergleich
Die Funktionen empty() und isset() ergänzen sich, sind aber keine Gegenteile. isset() prüft lediglich, ob eine Variable definiert ist und nicht null enthält. empty() geht weiter und bewertet zusätzlich den Inhalt der Variable.
| Situation | empty() | isset() |
|---|
| Variable nicht definiert | true | false |
Variable ist null | true | false |
Variable ist "" | true | true |
Variable ist 0 | true | true |
Variable ist "Hallo" | false | true |
In der Praxis lässt sich das so zusammenfassen: isset() beantwortet die Frage "Existiert die Variable?", während empty() die Frage "Hat die Variable einen sinnvollen Wert?" klärt. Beide Funktionen erzeugen keine Warnung bei nicht definierten Variablen.
<?php
/* Variable existiert nicht */
var_dump(isset($x)); // false
var_dump(empty($x)); // true
/* Variable ist null */
$x = null;
var_dump(isset($x)); // false
var_dump(empty($x)); // true
/* Variable ist leerer String */
$x = "";
var_dump(isset($x)); // true
var_dump(empty($x)); // true
/* Variable hat einen Wert */
$x = "PHP";
var_dump(isset($x)); // true
var_dump(empty($x)); // false
?>
Eine wichtige Besonderheit: isset() akzeptiert mehrere Parameter. So lässt sich mit einem einzigen Aufruf prüfen, ob alle benötigten Variablen gesetzt sind. Das ist besonders praktisch bei der Verarbeitung von Formulardaten.
<?php
$vorname = "Max";
$nachname = "Mustermann";
$email = "max@beispiel.de";
if (isset($vorname, $nachname, $email)) {
echo "Alle Felder sind gesetzt.";
}
/* Ausgabe: Alle Felder sind gesetzt. */
/* isset() gibt false zurück, sobald
eine der Variablen null ist */
$telefon = null;
var_dump(isset($vorname, $telefon));
// false
?>
Der Null Coalescing Operator (??)
Seit PHP 7 gibt es den Null Coalescing Operator ??. Er prüft, ob ein Wert existiert und nicht null ist, und liefert in diesem Fall den Wert selbst zurück. Andernfalls wird ein Standardwert verwendet. Das erspart die Kombination aus isset() und dem ternären Operator, die in älterem PHP-Code häufig vorkommt.
<?php
/* Ohne Null Coalescing (PHP 5) */
$name = isset($_GET['name'])
? $_GET['name']
: 'Gast';
/* Mit Null Coalescing (ab PHP 7) */
$name = $_GET['name'] ?? 'Gast';
echo $name;
/* Gibt den GET-Parameter oder 'Gast' aus */
/* Verkettung: erster Treffer gewinnt */
$anzeige = $_GET['anzeigename']
?? $_SESSION['benutzername']
?? 'Unbekannt';
?>
Der Operator ?? verhält sich wie isset(): Er reagiert nur auf null und nicht gesetzte Variablen. Ein leerer String oder die Zahl 0 gelten als gültige Werte und werden nicht durch den Standardwert ersetzt. Wer auch leere Strings abfangen möchte, muss weiterhin empty() oder einen expliziten Vergleich verwenden.
Seit PHP 7.4 gibt es zusätzlich den Null Coalescing Assignment Operator ??=. Er weist einen Standardwert nur dann zu, wenn die Variable bisher null oder nicht gesetzt ist:
<?php
$config = [];
/* Standardwert nur setzen, wenn Key fehlt */
$config['debug'] ??= false;
$config['sprache'] ??= 'de';
$config['limit'] ??= 20;
print_r($config);
/*
Array
(
[debug] =>
[sprache] => de
[limit] => 20
)
*/
?>
Praxisbeispiel: Formulardaten prüfen
Die mit Abstand häufigste Anwendung von empty() und isset() ist die Validierung von Formulareingaben. Das folgende Beispiel zeigt, wie ein Kontaktformular sicher geprüft wird. Dabei wird auch das Problem mit "0" als gültiger Eingabe berücksichtigt.
<?php
$fehler = [];
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
/* Name: Pflichtfeld */
$name = trim($_POST['name'] ?? '');
if (empty($name)) {
$fehler[] = "Bitte Namen eingeben.";
}
/* E-Mail: Pflichtfeld + Format */
$email = trim($_POST['email'] ?? '');
if (empty($email)) {
$fehler[] = "Bitte E-Mail eingeben.";
} elseif (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
$fehler[] = "E-Mail-Adresse ist ungültig.";
}
/*
* Menge: Hier ist "0" ein gültiger Wert.
* empty() würde "0" als leer werten,
* daher strikter Vergleich mit === nutzen.
*/
$menge = $_POST['menge'] ?? '';
if ($menge === '') {
$fehler[] = "Bitte Menge angeben.";
}
/* Nachricht: optional, aber min. 10 Zeichen */
$nachricht = trim($_POST['nachricht'] ?? '');
if (!empty($nachricht) && strlen($nachricht) < 10) {
$fehler[] = "Nachricht: mindestens 10 Zeichen.";
}
if (empty($fehler)) {
echo "Formular erfolgreich verarbeitet!";
} else {
foreach ($fehler as $f) {
echo $f . "\n";
}
}
}
?>
Das Beispiel zeigt drei verschiedene Prüfstrategien: empty() für Pflichtfelder wie Name und E-Mail, bei denen "0" kein sinnvoller Wert ist. Einen strikten Vergleich mit === '' für Felder wie Menge, bei denen die Null eine gültige Eingabe sein kann. Und !empty() als Vorbedingung für optionale Felder, die nur dann validiert werden, wenn sie tatsächlich ausgefüllt wurden.
Typische Stolperfallen mit empty()
Einige Verhaltensweisen von empty() führen regelmäßig zu Fehlern in der Praxis. Die folgenden Fälle sollte jeder PHP-Entwickler kennen, um unnötige Debugging-Stunden zu vermeiden.
Der String "0" gilt als leer
Wie bereits in der Wahrheitstabelle gezeigt, behandelt empty() den String "0" als leeren Wert. Bei Formulareingaben, Bewertungssystemen oder Mengenangaben führt das zu unerwarteten Ergebnissen.
<?php
$bewertung = "0"; /* 0 Sterne */
/* Falsch: wird als leer erkannt */
if (empty($bewertung)) {
echo "Keine Bewertung abgegeben.";
}
/* Ausgabe: Keine Bewertung abgegeben. */
/* Richtig: strikter Vergleich */
if (!isset($bewertung) || $bewertung === "") {
echo "Keine Bewertung abgegeben.";
} else {
echo "Bewertung: " . $bewertung;
}
/* Ausgabe: Bewertung: 0 */
?>
empty() mit Ausdrücken
Seit PHP 5.5 akzeptiert empty() nicht nur Variablen, sondern auch Funktionsaufrufe und Ausdrücke. In älteren PHP-Versionen durfte nur eine Variable übergeben werden, was zu einem Fatal Error führte.
<?php
/* Ab PHP 5.5 erlaubt */
if (empty(trim($_POST['name'] ?? ''))) {
echo "Name ist leer oder Leerzeichen.";
}
/* Vor PHP 5.5 war ein Umweg nötig: */
$name = trim($_POST['name'] ?? '');
if (empty($name)) {
echo "Name ist leer oder Leerzeichen.";
}
?>
empty() vs. !$variable
Der Ausdruck !$variable liefert in den meisten Fällen das gleiche Ergebnis wie empty($variable). Der entscheidende Unterschied: Wenn die Variable nicht existiert, erzeugt !$variable eine Warnung, während empty() still true zurückgibt.
<?php
/* $x ist nicht definiert */
if (!$x) {
/* Warning: Undefined variable $x */
echo "Leer";
}
if (empty($x)) {
/* Keine Warnung */
echo "Leer";
}
?>
In Situationen, in denen die Variable garantiert existiert (etwa nach einer Zuweisung), kann !$variable durchaus verwendet werden. Sobald aber die Existenz der Variable unsicher ist, zum Beispiel bei $_GET- oder $_POST-Parametern, ist empty() die sicherere Wahl.
isset() mit Superglobals verwenden
isset() spielt eine zentrale Rolle bei der Arbeit mit PHP-Superglobals wie $_POST, $_GET und $_SESSION. Bevor ein Wert aus diesen Arrays gelesen wird, sollte immer geprüft werden, ob der Schlüssel überhaupt existiert. Andernfalls erzeugt PHP ab Version 8.0 eine Warnung.
<?php
/* GET-Parameter sicher auslesen */
if (isset($_GET['seite'])) {
$seite = (int) $_GET['seite'];
} else {
$seite = 1;
}
/* Kürzer mit Null Coalescing */
$seite = (int) ($_GET['seite'] ?? 1);
/* Mehrere POST-Felder auf einmal prüfen */
if (isset($_POST['email'], $_POST['passwort'])) {
echo "Login wird verarbeitet...";
}
/* Session-Wert mit Fallback */
session_start();
$sprache = $_SESSION['sprache'] ?? 'de';
?>
Ein häufiger Fehler ist der direkte Zugriff auf $_POST['feld'] ohne vorherige Prüfung. Wenn das Formular nicht abgesendet wurde oder das Feld fehlt, erzeugt PHP eine Warnung. Mit dem ??-Operator lässt sich das in einer einzigen Zeile lösen. Für komplexere Prüfungen, etwa ob ein bestimmter Wert in einem erlaubten Bereich liegt, empfiehlt sich die Kombination aus isset() und einer anschließenden Validierung.
<?php
/*
* Sortierparameter sicher auslesen
* und gegen erlaubte Werte prüfen
*/
$erlaubte_sortierung = ['name', 'datum', 'preis'];
$sortierung = $_GET['sort'] ?? 'datum';
if (!in_array($sortierung, $erlaubte_sortierung)) {
$sortierung = 'datum';
}
echo "Sortiert nach: " . $sortierung;
?>
Wann empty(), wann isset(), wann ??
Die Wahl der richtigen Prüfmethode hängt von der konkreten Situation ab. Die folgende Übersicht fasst die wichtigsten Anwendungsfälle zusammen und hilft bei der Entscheidung.
| Ziel | Empfohlene Methode | Beispiel |
|---|
| Pflichtfeld prüfen | empty() | if (empty($_POST['name'])) |
| Existenz einer Variable prüfen | isset() | if (isset($_GET['id'])) |
| Standardwert setzen | ?? | $s = $_GET['s'] ?? 1 |
| Feld prüfen, wo "0" gültig ist | isset() + === | if (isset($x) && $x !== "") |
| Prüfen, ob ein Wert null ist | is_null() | if (is_null($x)) |
| Standardwert zuweisen | ??= | $x ??= 'Standard' |
Zusammenfassung
empty() und isset() sind grundlegende Werkzeuge für die Variablenprüfung in PHP. empty() eignet sich hervorragend für Pflichtfelder in Formularen, wobei die Sonderbehandlung von "0" als leerer Wert unbedingt beachtet werden muss. isset() ist die richtige Wahl, wenn es nur darum geht, ob eine Variable überhaupt existiert. Der Null Coalescing Operator ?? bietet seit PHP 7 eine elegante Möglichkeit, Standardwerte zu vergeben, und ersetzt in vielen Fällen die umständliche Kombination aus isset() und dem ternären Operator. Wer diese drei Ansätze sicher beherrscht, kann Bedingungen in PHP sauber und fehlerfrei formulieren.
