Variablen an ein Formular übergeben

Sie befinden sich: Home > Php > Variablen an ein Formular übergeben

In diesen Artikel möchten wir ihnen erklären, wie sie ein Formular erstellen und die Daten entgegen nehmen. Es wird hierbei auf die Übertragungsmethode GET und POST eingegangen.

Als erstes benötigen wir ein Formular, dieses Formular wird nach den Ausfüllen und absenden an ein PHP Scripte gesendet. somit erreichen wir die Übergabe von Daten an ein Formular. Es gibt hierbei zwei unterschiedliche Übertragungsmethoden. Es wäre einmal die Übertragungsmethode GET, diese Übertragungsmethode übermittelt die Daten über eine Adresse. Die andere Übertragungsmethode heißt POST und wird unsichtbar direkt an das Php Script gesendet. Nachdem wir nun erklärt haben was GET und POST ist, geht es an das Eingemachte und wir erstellen erstmal ein Formular für die Übertragungsmethode GET.

Die Übertragungsmethode GET

Der Datei geben wir den Namen: mein_erstes_get_formular_step1.php

<form action="mein_erstes_get_formular_step2.php" method="get">
Das ist die Variable, die wir an das Script übergeben wollen:
<input type="text" value="" name="variablen_name" /><br />
<input type="submit" value="Formular absenden" name="senden" />
</form>

In diesem einfachen Formular verwenden wir die Übertragungsmethode GET. Um anzugeben welche Übertragungsmethode wir in dem Formular verwenden, muss man im <form> Tag angeben method="get". Somit weiß ihr Browser, dass er das Formular per GET zu übermitteln hat. Die Übertragungsmethode GET wird sehr häufig verwendet, um einzelne Daten zu übermitteln. Wie zum Beispiel beim Aufrufen einer Kategorie in einem Verzeichnis.

Wenn wir das Formular nun absenden, wird an ihrer Adresse nach dem absenden die Variable angehangen. Dies würde so aussehen in der Adressleiste, Ihres Browsers: mein_erstes_get_formular_step2.php?variablen_name=&senden=Formular%20absenden wenn sie keine Daten in das Formular eingeben und das Formular über dem Button "Formular absenden" absenden. man könnte jetzt als Außenstehender, die Adresse in der Adressleiste editieren und falsche Daten ganz einfach an das Script senden. Es besteht genauso eine Einschränkung, dass hier nur eine bestimmte Länge an das Script in der Adressleiste übermittelt werden kann. Merken Sie sich: Daher sollte man, auf die unsicheren Übertragungsmethode GET verzichten. Natürlich ist dies nicht immer möglich und man muss auf die Übertragungsmethode GET zurückgreifen.

So nun wollen wir, die Variablen, die wir an das Script gesendet haben ausgeben. Dazu müssen wir zum Beispiel einfach echo $_GET['variablen_name']; schreiben. Mit der Echo Anweisung geben wir einen Inhalt aus, wenn dieser in einer Variable gespeichert wurde. Das ausgeben von Texten beziehungsweise Variablen haben wir bereits in einen anderen Artikel ausführlich beleuchtet. Wenn sie dies nicht verstanden haben, können Sie hier nochmal den Artikel nachlesen. Man sollte bevor man die Variable ausgibt, prüfen ob ein Inhalt in der variabel vorhanden ist. Da ansonsten wir eine Php Fehlermeldung generieren. Das Beispiel für die Überprüfung der Variablen:

Der Datei geben wir den Namen: mein_erstes_get_formular_step2.php

<?php
/* Als erstes überprüfen wir die Variable, ob
dieser eine Wert haben. Sollte kein Wert in
der Variable abgelegt sein, weisen wir einen
Null Wert zu. Damit wir die Fehlermeldung nicht
bekommen, dass eine Variable nicht definiert ist.

Hinweis: PHP dekodiert $_GET-Werte bereits
automatisch. Ein zusätzlicher urldecode()-Aufruf
führt zu doppelter Dekodierung und kann
Sicherheitsprobleme verursachen.
Daher sollte urldecode() NICHT auf $_GET
angewendet werden. */
if (!isset($_GET['variablen_name'])) {
    $_GET['variablen_name'] = '';
} else {
    $_GET['variablen_name'] = urldecode($_GET['variablen_name']);
}
if (!isset($_GET['senden'])) {
    $_GET['senden'] = '';
} else {
    $_GET['senden'] = urldecode($_GET['senden']);
}
/* Nachdem wir nun überprüft haben ob ein
Wert der Variable zugewiesen ist, können wir
mit dieser Variable weiter arbeiten. Nun prüfen
wir die Variable auf einen Inhalt. Wenn die
Variabel einen Inhalt hat, geben wir diese Variabel
wieder aus. Bevor wir die Variabel ausgeben,
sollten wir alle Sonderzeichen die übermittelt
wurden in HTML Code umwandeln. Dies macht
man mit htmlspecialchars(); */
if ($_GET['senden'] != '' AND $_GET['variablen_name'] != '') {
    echo htmlspecialchars($_GET['variablen_name']);
}
?>

Die Übertragungsmethode POST

Jetzt haben wir ausführlich die Übertragungsmethode GET beschrieben und wollen natürlich auch auf die Übertragungsmethode POST eingehen. Als erstes benötigen wir wieder ein Formular, in diesem Formular geben bei den <form> Tag die method="post" an. Das Beispiel hierfür würde so aussehen:

Der Datei geben wir den Namen: mein_erstes_post_formular_step1.php

<form action="mein_erstes_post_formular_step2.php" method="post">
Das ist die Variable, die wir an das Script übergeben wollen:
<input type="text" value="" name="variablen_name" /><br />
<input type="submit" value="Formular absenden" name="senden" />
</form>

Wenn wir dieses Formular absenden, wird an die Adressleiste nichts angehangen. Somit ist es schwerer das Script, was aufgerufen wird zu manipulieren. Natürlich ist dies nicht unmöglich, aber eine bedeutend sicherer Übertragungsmethode als wie die GET Variante. Das Script was die Daten entgegennimmt würde so aussehen:

<?php
/* Da die Daten, nicht über die Adressleiste
übermittelt wurden, ist es nicht erforderlich
mit urldecode() umzuwandeln. */
if (!isset($_POST['variablen_name'])) {
    $_POST['variablen_name'] = '';
}
if (!isset($_POST['senden'])) {
    $_POST['senden'] = '';
}
/* Nachdem wir nun überprüft haben ob ein
Wert der Variable zugewiesen ist, können wir
mit dieser Variable weiter arbeiten. Nun prüfen
wir die Variable auf einen Inhalt. Wenn die
Variabel einen Inhalt hat, geben wir diese Variabel
wieder aus. Bei der Übertragungsmethode POST ist es
genauso wichtig, alle Sonderzeichen die übermittelt
wurden in HTML Code umgewandelt werden. Dies macht
man mit htmlspecialchars(); */
if ($_POST['senden'] != '' AND $_POST['variablen_name'] != '') {
    echo htmlspecialchars($_POST['variablen_name']);
}
?>

Sie sehen selber, dass es ein paar Unterschiede zwischen den Übertragungsmethode GET und POST gibt. Man kann natürlich auch mit so genannten globalen Variablen arbeiten. Eine globale Variable ist zum Beispiel $variablen_name und dieser wird bei beiden Übertragungsmethode befüllt mit dem Inhalt wie in $_POST['variablen_name'] oder $_GET['variablen_name']. Dazu musste früher die PHP Einstellung register_globals auf "on" stehen.

Wichtig: Die Einstellung register_globals wurde in PHP 5.4 vollständig entfernt und existiert in modernen PHP-Versionen nicht mehr. Verwenden Sie immer die superglobalen Arrays $_GET, $_POST und $_REQUEST, um auf Formulardaten zuzugreifen. Gewöhnen sie sich auf keinen Fall an, mit globalen Variablen in ihrem Scripten zu arbeiten. Denn da dies ein Sicherheitsproblem ist und bei verschiedenem Webhoster einfach nicht funktionieren.

weiter E-Mail mit Php versenden

$_GET vs $_POST: Wann nutzt du was?

Wenn du ein Formular baust, stellst du dir früh die Frage, ob die Daten per GET oder POST übertragen werden sollen. Beide Verfahren landen in PHP zwar in ähnlich aussehenden Superglobals, doch sie unterscheiden sich grundlegend in Sichtbarkeit, Zwischenspeicherung und Sicherheit. Die richtige Entscheidung sparst du dir nicht durch Bauchgefühl, sondern indem du verstehst, wie Browser, Proxy und Server mit den beiden Methoden umgehen.

Idempotenz und Caching

Eine GET-Anfrage ist idempotent. Sie soll keinen Zustand auf dem Server ändern, sondern nur Daten lesen. Browser, Proxies und Suchmaschinen dürfen sie ohne Rückfrage wiederholen oder zwischenspeichern. Eine POST-Anfrage hingegen gilt als zustandsändernd und wird nicht automatisch wiederholt. Genau deshalb fragt dich der Browser nach dem Reload einer POST-Seite, ob du das Formular wirklich erneut absenden willst.

Konkrete Faustregel: Suchformulare und Filter gehören in GET, weil ihre Ergebnisse sich teilen, verlinken und im Browser-Verlauf wiederfinden lassen. Logins, Bestellungen, Lösch-Aktionen und Datei-Uploads gehören in POST, weil sie etwas verändern oder sensible Daten transportieren.

Sichtbarkeit und Limits

Die GET-Parameter hängen sichtbar in der URL, landen damit in Browser-History, Server-Logs und Referer-Headern. Passwörter, Tokens oder persönliche Daten haben dort nichts zu suchen. POST überträgt seine Felder im Request-Body und ist damit aus Logs und Lesezeichen heraus. Sicher ist auch POST erst mit HTTPS, weil sonst jeder im selben Netz mitlesen kann.

Warum du $_REQUEST meiden solltest

PHP bietet mit $_REQUEST eine bequeme Sammelvariable, die $_GET, $_POST und je nach php.ini sogar $_COOKIE zusammenwirft. Genau das ist das Problem. Du verlierst die Kontrolle darüber, woher ein Wert kommt, und ein Angreifer kann einen erwarteten POST-Wert per GET-Querystring oder Cookie unterschieben.

<?php
declare(strict_types=1);

if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    http_response_code(405);
    header('Allow: POST');
    exit('Methode nicht erlaubt');
}

/* Nur $_POST, niemals $_REQUEST verwenden */
$benutzername = trim((string) ($_POST['benutzername'] ?? ''));

Datei-Upload mit $_FILES und move_uploaded_file

Für echte Datei-Uploads reicht $_POST nicht aus. Hochgeladene Dateien landen in $_FILES und der Form-Tag braucht den richtigen Encoding-Typ. Ohne enctype="multipart/form-data" bekommst du nur den Dateinamen, aber keinen Inhalt.

<form action="upload.php" method="post" enctype="multipart/form-data">
    <input type="hidden" name="MAX_FILE_SIZE" value="2097152">
    <input type="file" name="avatar" accept="image/png,image/jpeg" required>
    <button type="submit">Hochladen</button>
</form>

Auf der PHP-Seite prüfst du zuerst den Fehler-Code, danach die MIME-Art und erst dann verschiebst du die Datei mit move_uploaded_file() aus dem temporären Pfad an einen sicheren Speicherort. Niemals den vom Client gemeldeten Dateinamen einfach übernehmen, denn er kann ../-Sequenzen oder gefährliche Endungen enthalten.

<?php
declare(strict_types=1);

if (!isset($_FILES['avatar']) || $_FILES['avatar']['error'] !== UPLOAD_ERR_OK) {
    exit('Upload fehlgeschlagen');
}

$tempPfad = $_FILES['avatar']['tmp_name'];

/* MIME-Typ aus dem tatsaechlichen Dateiinhalt lesen */
$finfo  = new finfo(FILEINFO_MIME_TYPE);
$mime   = $finfo->file($tempPfad);
$erlaubt = ['image/png' => 'png', 'image/jpeg' => 'jpg'];

if (!isset($erlaubt[$mime])) {
    exit('Dateityp nicht erlaubt');
}

$zielname = bin2hex(random_bytes(8)) . '.' . $erlaubt[$mime];
$zielpfad = __DIR__ . '/uploads/' . $zielname;

if (!move_uploaded_file($tempPfad, $zielpfad)) {
    exit('Speichern fehlgeschlagen');
}

Mehr zu diesem Thema findest du im ausführlichen Tutorial über move_uploaded_file() und sichere Datei-Uploads.

filter_var() für Validierung von Eingaben

Eingaben aus Formularen sind grundsätzlich nicht vertrauenswürdig. PHP bringt mit filter_var() ein robustes Werkzeug, das typische Validierungen ohne handgeschriebene Regex erledigt. Die wichtigsten Konstanten sind FILTER_VALIDATE_EMAIL, FILTER_VALIDATE_INT, FILTER_VALIDATE_URL und FILTER_VALIDATE_FLOAT. Für mehrere Felder auf einmal ist filter_var_array() die elegantere Lösung.

<?php
declare(strict_types=1);

$email = filter_var($_POST['email'] ?? '', FILTER_VALIDATE_EMAIL);
$alter = filter_var($_POST['alter'] ?? '', FILTER_VALIDATE_INT, [
    'options' => ['min_range' => 1, 'max_range' => 130],
]);

if ($email === false) {
    exit('Ungueltige E-Mail-Adresse');
}

if ($alter === false) {
    exit('Alter muss zwischen 1 und 130 liegen');
}

Wichtig: filter_var() liefert bei einem ungültigen Wert false zurück und kann bei FILTER_VALIDATE_BOOLEAN sogar null liefern. Prüfe deshalb mit === false, nicht mit !, sonst verwirfst du legitim leere Strings oder den Wert 0. Eine vollständige Einführung findest du im Tutorial filter_var() Eingaben filtern und schützen.

htmlspecialchars beim Echo gegen XSS

Wenn du einen Wert aus dem Formular später in HTML zurückgibst, etwa als Platzhalter im Eingabefeld nach einem Validierungsfehler, musst du ihn escapen. Sonst kann ein Angreifer JavaScript einschleusen. Der Standardweg in PHP ist htmlspecialchars(). Das Tutorial HTML-Zeichen in sichere Zeichen umwandeln erklärt die Optionen im Detail.

<?php
declare(strict_types=1);

function e(string $wert): string
{
    return htmlspecialchars($wert, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
}

$name = (string) ($_POST['name'] ?? '');
?>
<input type="text" name="name" value="<?= e($name) ?>">

Die Flags sind kein Detail. ENT_QUOTES escapt zusätzlich einfache Anführungszeichen, was für Attribut-Werte nötig ist. ENT_SUBSTITUTE ersetzt ungültige UTF-8-Sequenzen durch ein Ersatzzeichen statt eines leeren Strings. Definiere am besten eine kurze Helper-Funktion e() und nutze sie konsequent in jedem Template.

CSRF-Token Pattern

Cross-Site Request Forgery (CSRF) bedeutet, dass eine fremde Seite ein Formular auf deine Seite absendet, während dein Nutzer dort eingeloggt ist. Schutz bietet ein Token, das du in der Session speicherst und in jedes Formular einbettest. Beim Absenden vergleichst du beide Werte mit hash_equals(), um Timing-Angriffe zu vermeiden. Voraussetzung ist eine Session, die du mit session_start() initialisierst.

<?php
declare(strict_types=1);

session_start();

if (empty($_SESSION['csrf_token'])) {
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}

$token = $_SESSION['csrf_token'];

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $eingehend = (string) ($_POST['csrf_token'] ?? '');

    if (!hash_equals($token, $eingehend)) {
        http_response_code(419);
        exit('Sitzung abgelaufen oder ungueltiges Token');
    }
}

Speichere den Token einmal pro Session, nicht pro Formular. Eine Rotation nach Login oder Logout ist sinnvoll, eine Rotation pro Request bringt selten echten Mehrwert und bricht Mehrfach-Tabs.

POST-Redirect-GET Pattern

Wenn ein Formular per POST abgesendet wurde und du danach eine Bestätigungsseite renderst, löst ein Reload des Browsers das Formular noch einmal aus. Die Folge sind doppelte Datensätze, doppelte Bestellungen oder doppelte E-Mails. Das saubere Muster heißt Post-Redirect-Get: Nach erfolgreicher Verarbeitung antwortest du nicht mit dem fertigen HTML, sondern mit einer 303-Weiterleitung auf eine GET-Seite, die die Bestätigung anzeigt.

<?php
declare(strict_types=1);

session_start();

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    /* validieren und speichern */

    $_SESSION['flash'] = 'Nachricht erfolgreich gesendet.';

    header('Location: /kontakt.php?status=ok', true, 303);
    exit;
}

/* Auf der Anzeige-Seite */
$flash = $_SESSION['flash'] ?? null;
unset($_SESSION['flash']);

Der Statuscode 303 (See Other) zwingt den Browser zu einem GET, unabhängig von der ursprünglichen Methode. Für kurze Erfolgs- oder Fehlermeldungen eignen sich Flash-Messages in der Session, die nach dem ersten Auslesen wieder gelöscht werden.

Lifecycle eines Formular-Submits

Damit du den Ablauf vom Browser zurück zur Bestätigung verinnerlichst, hilft ein einfacher Flow. Das folgende Diagramm zeigt die typische Kette aus Submit, Validierung, Speicherung und Redirect.

flowchart TD
    A[Browser sendet POST] --> B{CSRF-Token gueltig?}
    B -- nein --> X[419 Fehlerseite]
    B -- ja --> C{Validierung ok?}
    C -- nein --> D[Formular mit Fehlern]
    C -- ja --> E[Datensatz speichern]
    E --> F[303 Redirect auf GET]
    F --> G[Bestaetigung mit Flash]

Praxisbeispiel: Kontaktformular mit Validation und Flash

Zum Abschluss bringen wir alle Bausteine in einem realistischen Beispiel zusammen. Das Skript zeigt das Formular, validiert die Eingaben, schützt vor CSRF, eskapiert Rückgaben gegen XSS und nutzt Post-Redirect-Get für die Erfolgsmeldung.

<?php
declare(strict_types=1);

session_start();

if (empty($_SESSION['csrf_token'])) {
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}

$fehler = [];
$werte  = ['name' => '', 'email' => '', 'nachricht' => ''];

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $tokenOk = hash_equals(
        $_SESSION['csrf_token'],
        (string) ($_POST['csrf_token'] ?? '')
    );

    if (!$tokenOk) {
        http_response_code(419);
        exit('Sitzung abgelaufen');
    }

    $werte['name']      = trim((string) ($_POST['name'] ?? ''));
    $werte['email']     = trim((string) ($_POST['email'] ?? ''));
    $werte['nachricht'] = trim((string) ($_POST['nachricht'] ?? ''));

    if ($werte['name'] === '' || mb_strlen($werte['name']) > 80) {
        $fehler['name'] = 'Bitte einen Namen mit max. 80 Zeichen angeben.';
    }

    if (filter_var($werte['email'], FILTER_VALIDATE_EMAIL) === false) {
        $fehler['email'] = 'Bitte eine gueltige E-Mail-Adresse eingeben.';
    }

    if (mb_strlen($werte['nachricht']) < 10) {
        $fehler['nachricht'] = 'Bitte mindestens 10 Zeichen schreiben.';
    }

    if ($fehler === []) {
        $_SESSION['flash'] = 'Vielen Dank, deine Nachricht wurde gesendet.';
        header('Location: /kontakt.php?ok=1', true, 303);
        exit;
    }
}

function e(string $wert): string
{
    return htmlspecialchars($wert, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
}

$flash = $_SESSION['flash'] ?? null;
unset($_SESSION['flash']);
?>
<form method="post" action="/kontakt.php" novalidate>
    <input type="hidden" name="csrf_token" value="<?= e($_SESSION['csrf_token']) ?>">
    <input type="text" name="name" value="<?= e($werte['name']) ?>">
    <input type="email" name="email" value="<?= e($werte['email']) ?>">
    <textarea name="nachricht"><?= e($werte['nachricht']) ?></textarea>
    <button type="submit">Senden</button>
</form>

Beachte drei Details. Erstens werden die alten Werte nach einem Fehler ins Formular zurückgespielt, damit der Nutzer nicht alles neu tippen muss. Zweitens werden alle Rückgaben durch e() escaped, ohne Ausnahme. Drittens beendet ein erfolgreicher POST den Request mit exit, damit auf keinen Fall noch HTML aus dem unteren Skript-Teil ausgegeben wird.

Wenn du dieses Grundgerüst verstanden hast, kannst du es problemlos um Felder erweitern, eine zentrale Validator-Klasse anbauen oder die Werte mit filter_var_array() in einem Aufruf prüfen. Wichtig ist, dass jede einzelne dieser Schichten ihren festen Platz behalten muss: Methode prüfen, Token prüfen, validieren, speichern, Flash setzen, Redirect, Anzeige mit Escape.