In einem übernommenen Projekt gilt plötzlich jedes Formular als ausgefüllt. Die Ursache steckt in einer Datei, die vor der eigentlichen Logik läuft und Standardwerte in $_POST schreibt, damit nirgends eine Warnung auftaucht. Ab diesem Moment beantwortet isset($_POST['newsletter']) nicht mehr die Frage, ob der Besucher etwas geschickt hat. Genau dafür gibt es PHP filter_has_var(). Wie man Eingaben mit filter_input() liest, filtert und validiert, zeigt das Tutorial Eingabe filtern und schützen. Hier geht es um die Frage davor: Ist das Feld überhaupt mit der Anfrage angekommen?
Alle Beispiele liefen mit PHP 8.4 unter Windows und Linux, die Formularfälle per echter HTTP-Anfrage gegen den eingebauten Entwicklungsserver und unter Linux zusätzlich gegen Apache.
Was PHP filter_has_var() prüft
Wenn eine Anfrage eintrifft, liest PHP die Felder einmal ein und legt sie an zwei Stellen ab. Die eine ist das bekannte Array $_POST, das jedes Skript lesen, ergänzen und leeren darf. Die andere ist eine interne Kopie der Filter-Erweiterung, die kein Skript verändern kann. PHP filter_has_var() fragt diese Kopie. Die Antwort ist ein einfaches true oder false: Kam ein Feld mit diesem Namen vom Client, oder nicht. Den Wert selbst sieht die Funktion nicht an.
Der Unterschied zu isset() entsteht erst, wenn ein Skript an $_POST etwas ändert. Das Diagramm zeigt die beiden Wege:
flowchart TD
A[Anfrage] --> B[PHP liest die Felder ein]
B --> C[interne Kopie der Filter]
B --> D[Array $_POST]
D --> E[Skript ändert $_POST]
C --> F{filter_has_var}
E --> G{isset}
F --> H[Antwort aus der Anfrage]
G --> I[Antwort aus dem Ist-Stand]
Syntax und Parameter im Original
Die Signatur ist kurz, und der Kommentar enthält die Beschreibung aus dem Handbuch, ergänzt um den Punkt, auf den es ankommt:
filter_has_var(
int $input_type,
string $var_name
): bool
/* input_type - INPUT_GET, INPUT_POST, INPUT_COOKIE,
INPUT_SERVER or INPUT_ENV
var_name - name of a variable to check
return - a boolean: true if the variable
exists in the input received by
PHP, false if not
The function checks the original request data,
not the $_GET or $_POST array as modified at
runtime. It applies no filter, no validation,
no options and no flags. To read and validate
the value, use filter_input() or filter_var(). */
Die fünf Konstanten haben die Werte 0 (INPUT_POST), 1 (INPUT_GET), 2 (INPUT_COOKIE), 4 (INPUT_ENV) und 5 (INPUT_SERVER). Ein INPUT_REQUEST gibt es nicht. Bis PHP 7.4 war es zusammen mit INPUT_SESSION zwar als Konstante definiert, ein Aufruf meldete aber nur INPUT_REQUEST is not yet implemented. Mit PHP 8 sind beide verschwunden. Wer eine andere Zahl übergibt, bekommt ValueError: filter_has_var(): Argument #1 ($input_type) must be an INPUT_* constant. Ein leerer Feldname liefert einfach false.
Die ursprüngliche Anfrage, nicht das Array
Das folgende Skript bekam per POST nur das Feld name mit dem Wert Anna. Danach schreibt es ein neues Feld in $_POST und entfernt das gesendete:
<?php
/* Anfrage: POST name=Anna */
$_POST['neu'] = 'x';
unset($_POST['name']);
var_dump(filter_has_var(INPUT_POST, 'neu'));
/* bool(false) */
var_dump(isset($_POST['neu']));
/* bool(true) */
var_dump(filter_has_var(INPUT_POST, 'name'));
/* bool(true) */
var_dump(filter_input(INPUT_POST, 'name'));
/* string(4) "Anna" */
PHP filter_has_var() ignoriert also beides: das hinzugefügte Feld und das gelöschte. Selbst $_POST = [] änderte im Test nichts, die Funktion meldete weiter true, und filter_input() lieferte weiter den gesendeten Wert. Bei $_GET und Cookies verhielt es sich genauso. Ein Cookie, das das Skript im selben Aufruf mit setcookie() setzt, existiert für INPUT_COOKIE erst bei der nächsten Anfrage.
Das ist eine Stärke, wenn man wissen will, was der Browser tatsächlich geschickt hat, etwa bei der Datei mit den Standardwerten aus der Einleitung. Umgekehrt ist es eine Falle, wenn Code absichtlich Werte in $_POST nachträgt und erwartet, dass die Prüfung sie sieht.
PHP filter_has_var(), isset() und array_key_exists()
Die drei Prüfungen beantworten verschiedene Fragen. Die Tabelle zeigt die gemessenen Antworten für dieselbe Anfrage:
| Fall | filter_has_var() | isset() | array_key_exists() |
Feld gesendet, Wert Anna | true | true | true |
| Feld gesendet, aber leer | true | true | true |
| Feld nicht gesendet | false | false | false |
| vom Skript hinzugefügt | false | true | true |
gesendet, dann unset() | true | false | false |
vom Skript auf null gesetzt | false | false | true |
PHP filter_has_var() beantwortet, ob ein Feld vom Client kam. isset() beantwortet, ob jetzt ein Wert da ist, der nicht null ist. array_key_exists() beantwortet, ob der Schlüssel existiert, auch mit null. Mehr zu isset() und seinen Nachbarn steht im Tutorial Variable mit isset prüfen. Ein leeres Feld zählt bei allen dreien als vorhanden:
<?php
/* Anfrage: POST leer= */
var_dump(filter_has_var(INPUT_POST, 'leer'));
/* bool(true) */
var_dump(empty($_POST['leer']));
/* bool(true) */
$_POST['notiz'] = null;
var_dump(isset($_POST['notiz']));
/* bool(false) */
var_dump(array_key_exists('notiz', $_POST));
/* bool(true) */
Die Geschwindigkeit spielt bei der Wahl keine Rolle. Eine Million Aufrufe dauerten unter Apache 21,7 ms mit filter_has_var() und 10,7 ms mit isset(), unter Windows 32,5 und 15,3 ms. Das sind 20 bis 35 Nanosekunden pro Feld.
Leere Felder, Checkboxen und Array-Felder
Wer prüfen will, ob ein Pflichtfeld ausgefüllt wurde, braucht nach PHP filter_has_var() noch einen Blick auf den Wert, denn ein leeres Textfeld wird mitgeschickt. Bei Checkboxen ist es umgekehrt. Eine Checkbox ohne Haken sendet der Browser gar nicht, mit Haken kommt sie als agb=on. Deshalb ist PHP filter_has_var() hier schon die ganze Pflichtprüfung:
<?php
/* Formular mit <input type="checkbox" name="agb"> */
$fehler = [];
if (!filter_has_var(INPUT_POST, 'agb')) {
$fehler[] = 'Bitte die Teilnahmebedingungen'
. ' bestätigen.';
}
echo count($fehler);
/* ohne Haken 1, mit Haken 0 */
Wie man die Werte mehrerer Checkboxen auswertet, zeigt das Tutorial Checkboxen auswerten mit PHP. Bei einer Mehrfachauswahl mit name="tags[]" heißt das Feld für PHP tags, ohne Klammern. Die Abfrage mit Klammern liefert immer false, und filter_input() gibt das Array nur mit einem Flag heraus:
<?php
/* Anfrage: tags[]=php&tags[]=sql */
var_dump(filter_has_var(INPUT_POST, 'tags'));
/* bool(true) */
var_dump(filter_has_var(INPUT_POST, 'tags[]'));
/* bool(false) */
var_dump(filter_input(INPUT_POST, 'tags'));
/* bool(false) */
$tags = filter_input(
INPUT_POST,
'tags',
FILTER_DEFAULT,
FILTER_REQUIRE_ARRAY
);
echo implode(', ', $tags);
/* php, sql */
Feldnamen mit Punkt oder Leerzeichen schreibt PHP bei POST wie bei GET beim Einlesen um, aus vor.name wird vor_name, und nur unter diesem Namen findet die Funktion das Feld. Ein Datei-Upload steht ausschließlich in $_FILES, für INPUT_POST existiert das Feld nicht. Und schickt ein Formular zwei Felder mit demselben Namen ohne Klammern, gilt das Feld als vorhanden, mit dem Wert des letzten.
Vorhanden und gültig: filter_input() mit Filter und Flags
Die Existenzprüfung ist nur die erste Stufe. Was im Feld steht, prüft danach filter_input() mit einem passenden Filter. Für eine E-Mail-Adresse sieht das so aus:
<?php
if (!filter_has_var(INPUT_POST, 'email')) {
exit('Formular unvollständig');
}
$email = filter_input(
INPUT_POST,
'email',
FILTER_VALIDATE_EMAIL
);
if ($email === false) {
exit('Bitte eine gültige Adresse angeben');
}
echo "Danke, $email";
Ohne das Feld endet das Skript mit dem ersten Hinweis, mit abc mit dem zweiten, mit einer gültigen Adresse kommt der Dank. Warum sich die Trennung lohnt, zeigen die Rückgaben von filter_input() selbst, gemessen mit FILTER_VALIDATE_INT:
| Fall | ohne Filter | FILTER_VALIDATE_INT | dazu FILTER_NULL_ON_FAILURE |
| Feld fehlt | NULL | NULL | false |
| Feld leer | leerer String | false | NULL |
Mit dem Flag FILTER_NULL_ON_FAILURE tauschen NULL und false ihre Bedeutung. Wer vorher mit PHP filter_has_var() fragt, muss sich das nicht merken: Fehlt das Feld, ist die Sache erledigt, und jedes false danach heißt ungültig. Für mehrere Felder auf einmal gibt es filter_input_array(), für Werte, die nicht aus der Anfrage stammen, filter_var() und für ganze Arrays filter_var_array(), das ein eigenes Tutorial hat.
JSON, PUT und request_parse_body()
Schickt JavaScript die Daten mit fetch() als JSON, bleibt $_POST leer. PHP liest nur Formulardaten automatisch ein, der JSON-Text steht unverändert in php://input. Für PHP filter_has_var() gibt es dann kein einziges Feld:
<?php
/* fetch() schickt {"name":"Anna"} als JSON */
var_dump(filter_has_var(INPUT_POST, 'name'));
/* bool(false) */
$roh = file_get_contents('php://input');
$daten = json_decode($roh, true) ?? [];
var_dump(array_key_exists('name', $daten));
/* bool(true) */
Bei einer PUT-Anfrage mit gewöhnlichen Formulardaten bleibt $_POST ebenfalls leer. Seit PHP 8.4 liest request_parse_body() solche Daten ein, und dabei zeigte sich im Test eine Überraschung: Danach meldete auch PHP filter_has_var() das Feld.
<?php
/* PUT mit name=Anna, ab PHP 8.4 */
var_dump(filter_has_var(INPUT_POST, 'name'));
/* bool(false) */
[$felder, $dateien] = request_parse_body();
var_dump(filter_has_var(INPUT_POST, 'name'));
/* bool(true) */
echo $felder['name'];
/* Anna */
Die Funktion sieht offenbar alles, was PHP über den regulären Eingabeweg einliest, auch wenn das erst während des Skripts passiert. Das Handbuch beschreibt dieses Verhalten nicht. Gemessen wurde es mit PHP 8.4.8 und 8.4.17 unter Apache und dem eingebauten Server.
INPUT_SERVER und INPUT_ENV je nach Server
Bei Formularfeldern verhielt sich PHP filter_has_var() auf allen Servern gleich. Bei INPUT_SERVER nicht, denn hier hängt die Antwort davon ab, welche Werte der jeweilige Server über den normalen Eingabeweg meldet:
| Schlüssel | Apache mit mod_php | php -S | Kommandozeile |
REQUEST_METHOD | true | false | gibt es nicht |
HTTP_USER_AGENT | true | true | gibt es nicht |
REMOTE_ADDR | true | false | gibt es nicht |
SCRIPT_NAME, DOCUMENT_ROOT | true | false | true |
REQUEST_TIME | false | false | false |
PATH | true | false | false, obwohl in $_SERVER |
REQUEST_TIME fehlt überall, weil PHP den Wert an der Filter-Erweiterung vorbei in $_SERVER schreibt. Auch REQUEST_METHOD meldet der eingebaute Server nicht über diesen Weg: Mit php -S lieferte filter_input(INPUT_SERVER, 'REQUEST_METHOD') NULL, unter Apache GET. Unter PHP-FPM wurde nicht gemessen. Wer INPUT_SERVER verwendet, prüft das Verhalten auf dem Zielserver oder baut einen Rückfall ein:
<?php
$methode = filter_input(
INPUT_SERVER,
'REQUEST_METHOD'
) ?? $_SERVER['REQUEST_METHOD'] ?? 'GET';
echo $methode;
/* POST, auch unter php -S */
var_dump(filter_has_var(INPUT_ENV, 'PATH'));
/* GPCS: bool(false), EGPCS: bool(true) */
var_dump(getenv('PATH') !== false);
/* bool(true) */
Bei INPUT_ENV entscheidet die Einstellung variables_order. Die Vorgabe der php.ini-production lautet GPCS, ohne das E für Umgebungsvariablen. Dann ist $_ENV leer, und die Funktion findet nichts. Steht EGPCS in der Konfiguration, findet sie PATH. getenv() fand den Wert in beiden Fällen und ist für Umgebungsvariablen der verlässliche Weg.
PHP filter_has_var() auf der Kommandozeile
Auf der Kommandozeile gibt es keine Anfrage. Für INPUT_GET und INPUT_POST antwortet die Funktion dort immer mit false, auch wenn ein Testskript die Superglobals vorher befüllt:
<?php
/* php test.php auf der Kommandozeile */
$_GET['modus'] = 'voll';
var_dump(filter_has_var(INPUT_GET, 'modus'));
/* bool(false) */
var_dump(filter_input(INPUT_GET, 'modus'));
/* NULL */
var_dump(filter_input_array(INPUT_POST));
/* NULL */
Wer Formularlogik automatisch testen will, gibt ihr die Eingabe deshalb als Parameter mit, statt sie aus den Superglobals zu lesen. Im Betrieb übergibt der Aufrufer filter_input_array(INPUT_POST) ?? [] und bekommt damit die ursprüngliche Anfrage, im Test ein selbst gebautes Array:
<?php
function hat_feld(array $eingabe, string $n): bool
{
return array_key_exists($n, $eingabe);
}
$anfrage = filter_input_array(INPUT_POST) ?? [];
var_dump(hat_feld($anfrage, 'email'));
/* CLI ohne Anfrage: bool(false) */
var_dump(hat_feld(['email' => 'a@b.de'], 'email'));
/* bool(true) */
Fazit
PHP filter_has_var() beantwortet eine einzige Frage, und die genau: Kam dieses Feld mit der Anfrage? Was ein Skript danach in $_POST schreibt oder löscht, ändert daran nichts. Für Pflicht-Checkboxen ist die Funktion die ganze Prüfung, für Textfelder die erste Stufe vor filter_input(). Array-Felder fragt man ohne Klammern ab, Uploads über $_FILES.
Die Grenzen liegen dort, wo PHP gar keine Formulardaten einliest: bei JSON, bei PUT ohne request_parse_body() und auf der Kommandozeile. Bei INPUT_SERVER und INPUT_ENV hängt das Ergebnis am Server und an variables_order, dort sind $_SERVER mit Rückfall und getenv() die sicherere Wahl.