Formulare Verarbeiten

Formular und Parameterübergabe

Interaktivität und Dynamik sind für einen gelungenen Web-Auftritt maßgebend. Dabei spielen Formulare eine wichtige Rolle. Denn durch sie kann der Besucher aktiv werden. Er kann Daten an den Server schicken, die dann verarbeitet werden.

Formulare haben in erster Linie wenig mit PHP gemein, da sie durch HTML erzeugt werden. PHP kommt erst dann zum Einsatz, wenn die Formulardaten verarbeitet werden. Die Daten werden dabei durch das HTTP-Protokoll entweder per POST oder GET versendet. Auch in Cookies können Daten gespeichert werden.

Erstellen eines Formulars

Ein Formular wird durch die beiden Auszeichnungen <form> und </form> eingeschlossen. Die dazwischen liegenden Elemente des Formulars werden beim Versenden abgearbeitet. Andere HTML-Auszeichnungen, etwa Tabellen, werden zwar dargestellt, aber bei der Versendung nicht beachtet.

Die Methode und das Ziel der Übergabe werden innerhalb des form-Tags angegeben.

  • method legt die Methode der Übergabe fest:
    • POST
    • GET
  • action gibt das Ziel an

Das Ziel kann eine beliebige Web-Adresse oder auch eine Mail-Adresse sein. Bei der Verarbeitung des Formulars werden alle Elementnamen automatisch in Variablen und alle Elementwerte in die Werte der jeweiligen Variable geschrieben.

<html><head><title>Test-Formular</title></head>
<body>
<form method="get" action="form.php">
<input type="text" name="text" size="20" />
<input type="submit" value="Senden" />
</form>
</body></html>

Als Methode wurde hier GET gewählt. Der Inhalt des Formulars wird an die Datei form.php versendet. Durch input wird ein Formularelement erzeugt. Auf welche Elementtypen Du zurückgreifen kannst, wiird in der Folgenden Tabelle gezeigt:

TypAttributeBeschreibung
buttonname, valueSchaltfläche (Ein Button).
checkboxname, value, checked Kontrollkästchen.
filesize, maxlength, accept Eingabefeld für Dateien und Schaltfläche zum Durchsuchen.
hiddenname, valueUnsichtbares Feld, nützlich für Informationen die Automatisch mitgegeben werden sollen.
imagename, src, Bildattribute Bild als Submit-Button.
radioname, value, checked Optionsschalter
resetname, valueSetzt Formulareingaben zurück.
submitname, valueSenden-Button.
textname, value, size, maxlengthEinzeiliges Eingabefeld.
passwordname, value size, maxlengthEinzeiliges Eingabefeld,das die Eingabe als Sternchen(*) ausgibt.

Zwei Elementtypen werden nicht durch input angegeben. Mehrzeilige Textfelder und Optionsmenüs sind durch reine HTML-Auszeichnungen Begrenzt:

  • <textarea> begrenz ein Mehrzeiliges Eingabefeld
  • <select> erstellt eine Auswahlliste; jeder Menüpunkt wird durch <option> maskiert.
  • Mehr über die Syntax von Formularen gibt es hier und hier.

Die Methoden POST und GET

Beide Methoden sind in ihrer grundlegenden Funktion gleich: Sie versenden Daten über das HTTP-Protokoll ab ein Ziel. Jedoch ist die Art und Weise der Übertragung jeweils eine andere.

Verwendest Du GET, um die Formulardaten indirekt über URL an eine Datei weiterzugeben. Die Variablen und ihre Werte werden durch ein ? (Fragezeichen) an die URL geknüpft. Alle folgenden Ausdrücke sind durch ein & (Kaufmännisches UND) getrennt.

http://www.proggen.org/getraenke.php?tag=1&getraenk=mixery_beer

Diese Form der Übertragung birgt den Nachteil, dass der Besucher Wert und Variable leicht verändern und erheblichen Einfluss auf ein Skript ausüben kann.

Mit POST vermeidest Du diesen unerwünschten Nebeneffekt, da ier die Daten direkt an das Skript weitergegeben werden. Sie tauchen in der Adresse nicht auf. Eine Veränderung der Daten gestaltet sich damit schwieriger. Diese Methode sollte da eingesetzt werden, wo größere Datenmengen übergeben werden sollen, da auch die Länge der URL begrenzt sind.

Übrigens erhälst Du bei POST von deinem Browser eine Fehlermeldung mit dem Inhalt, dass alle Formulareingaben erneut gesendet werden, wenn Du die Seite aktualisieren willst. Mit GEt passiert das nicht; daher wird die Methode oft zur Navigationszwecken genutzt,

Auswerten von Formulardaten

Das Auswerten der Formulardaten wird erst mit PHP richtig interessant. Alle Daten, die durch ein Formular übergeben werden, sind sofort im Skript verfügbar und können verarbeitet werden.

Grundlagen

Ein praktisches Beispiel für die Verarbeitung eines Formulars stellt ein Gästebuch dar. Der Besucher soll seine Informationen, wie Name, Email, seine Homepage und den Text in ein Formular eingeben, welches Dann durch ein Skript verarbeitet wird. Zunächst wird das Formular in der Datei guest-book.html aufgebaut.

<html><head><title>G&auml;stebuch</title></head>
<body>
<form method="post" action="new_entry.php">
<input type="hidden" name="eingabe" value="1" />
Name: <input type="text" name="name" size="20" /><br />
E-Mail: <input type="mail" name="email" /><br />
Homepage: <input type="text" name="url" value="HTTP://" size="40" /> <br />
<textarea name="text" rows="10" cols="40"></textarea><br />
<input type="submit" value="Eintragen" />
<input type="reset" value="Zur&uuml;cksetzen" />
</form>
</body></html>

Der Browser zeigt jetzt das Formular an, in das bereits ein Text eingegeben wurde. Alle eingaben werden an die Datei new_entry.php übergeben. Genauso gut kann der Inhalt des Formulars auch an dieselbe Datei geschickt werden. Die Datei kann direkt angegeben werden, oder Du verwendest die globale Server-Variable PHP_SELF. Die form-Auszeichnung muss in diesem Fall dann so abgewandelt werden:

<form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>" >

Anstatt $_SERVER['PHP_SELF'] steht nach der Verarbeitung der Datei dann ihr Dateiname im Attribut ACTION.

Konzentrieren wir uns nun wieder auf unser ursprüngliches Beispiel. Die Date new_entry.php wurde angelegt un wird zum Test wie folgt beschrieben(Datei new_entry.php):

<html><head><title>@@@</title></head>
<body>
<?php
  $name = $_POST['name'];
  $mail = $_POST['email'];
  $url = $_POST['url'];
  $text = $_POST['text'];
 
  if($_POST['eingabe'] == 1)
  {
    echo "Name: $name<br />Email: $mail<br />URL: $url<br />Dein Text: $text";
  }
  else{
    echo "Bitte f&uuml;lle das <a href='localhost/test.php'>Formular</a> ganz aus!";
  }
?>
</body></html>

Dieses kleine Skript zeigt, dass die zuvor eingegebenen Daten übernommen wurden und schon angezeigt werden können. Du kannst diesen Datensatz schon jetzt speichern. Das hat aus Sicherheitsgründen und wegen der fehlenden Formatierung der Zeichenketten aber keinen Sinn. Außerdem sorgen fehlende Fehlerkorrekturen für unvollständige und oder falsche Einträge.

Globale Servervariablen

Im vorigen Beispiel hast Du bereits mit PHP auf die Formularwerte zugegriffen, die per POST vom Formular übergeben wurden. Du erhälst das Formularelement url durch die Anweisung

$url = $_POST['url'];

PHP speichert alle Elemente eines Formulars mit der POST-Methode in einem assoziativen Array mit dem Namen $_POST[], analog dazu $_GET[], wenn Du die Methode GET verwendest. Hier eine Liste der globalen Assoziativen Variablen, welche durch Formulare erzeugt werden können:

NameBedeutung
$_POST[]Formulardaten die mit POST versendet wurden.
$_GET[]Formulardaten welche mit GET gesendet worden sind.
$_COOKIE Gespeicherte Cookies *
$_SERVER[]Verschiedene Servervariablen *
$_ENVVariablen der Serverumgebung *
$_FILESFür Datei-Upload.
$_SESSION[]Sitzungsvariablen*
$_REQUEST[]Enthält die Inhalte von $_GET, $_POST und $_COOKIE

* Bedeutet dass diese Variablen nicht durch Formulare erzeugt werden, aber dennoch der vollständigkeit-halber hier aufgeführt werden.

Da es sich bei den jeweiligen Daten um assoziative Arrays handelt, stehen Dir auch Arrayfunkionen zur Verfügung, um diese Arrays beispielsweise auszulesen. Du kannst diese Arrays aber nicht ändern.

Damit bist Du in der Lage, dynamisch erzeugte Formulare auszulesen oder sich viel Schreibarbeit zu ersparen, wenn die Formulare sehr kompliziert sind. Die Eingabe für unser Gästebuch lässt sich auch in dieser Form ausgeben.

<?php
  if(isset($_POST))
  {
    foreach($_POST as $name=>$element)
    {
      echo strtoupper($name). ": $element <br />";
    }
  }
?>

Zuerst wird geprüft, ob Daten durch POST übergeben wurden. Mit foreach werden die Datensätze ausgelesen und jeweils ausgegeben. Das Ergebnis ist hier zu begutachten:

Fehlerbehandlung und Formatierung

Du bist mit den PHP-Grundlagen fähig, Kontrollstrukturen zu programmieren. Leicht ist es auf jeden Fall, fehlende Werte zu erkennen und gegebenenfalls eine Fehlermeldung im Browser auszugeben. Auch durch JavaScript kann eine solche Fehlerroutine hinzugefügt werden. Die Behandlung durch PHP ist jedoch auf jeden Fall effektiver, da JavaScript durch den Besucher deaktiviert sein könnte. Das Beispiel zeigt, wie eine Fehlerbehandlung mittels PHP aussehen könnte:

<?php
  if(isset($_POST["eingabe"] && ($_POST["eingabe"] == 1)
  {
    $name = htmlentities(addslashes(rtrim($_POST["name"])));
    $mail = htmlentities(addslashes(rtrim($_POST["email"])));
    $url  = htmlentities(addslashes(rtrim($_POST["url"])));
    $text = htmlentities(addslashes(rtrim($_POST["text"])));
    $text = nl2br($text);
 
    if($name && $text)
    {
      echo "Name: $name<br />Email: $mail<br />URL: $url<br />Dein Text: $text";
    } 
    else 
    {
      echo "Name und der Text müssen angegeben werden!";
    }
 
  }
  else
  {
    echo "Bitte verwende das Formular.";
  }
?>

Das Skript enthält eine simple Kontrollfunktion, in der überprüft wird, ob die Werte in $name und $text vorhanden sind. Außerdem wird jeder Datensatz formatiert. Als Erstes werden mit rtrim überflüssige Zeichen entfernt. Außerdem werden mit htmlentities HTML-spezifische Auszeichnungen und Umlaute umgewandelt. Sonderzeichen werden mit addshlashes ebenfalls behandelt, falls die Daten in einer Datenbank gespeichert werden soll.

Formularoptionen und Arrays

Du willst mehr über die Besucher erfahren? Eine weit verbreitete Lösung sind Checkboxen oder Optionsmenüs mit mehreren Auswahlmöglichkeiten.

<SELECT NAME="suchmaschinen" SIZE="5" MULTIPLE>
  <option value="Google">Google</option>
  <option value="Yahoo">Yahoo</option>
  <option value="MSN">MSN</option>
  <option value="Web.de">Web.de</option>
</SELECT

Da Du mehrere Werte auswählen kannst, kommt es bei der bisherigen Verarbeitung durch PHP zu Problemen. Diese äußern sich in unserem Beispiel darin, dass nur der letzte ausgewählte Wert gespeichert wird, denn es existieren mehrere Werte, aber nur eine Variable. Die Lösung kennst Du bereits aus dem Kapitel über Arrays. Nur Arrays sind dazu fähig mehrere Werte aufzunehmen. Bei der Formularübergabe muss also dieser Datentyp anstelle eines einzelnen Wertes benutzt werden.

PHP muss also erkennen, dass es Daten bekommt, die in einem Array zu speichern sind. Erreicht wird das, indem dem ELementnamen eckige Klammern [] angefügt werden.

<select name="suchmaschinen[]" size="5" MULTIPLE>

Für HTML sind die Klammern bedeutungslos. PHP aber interpretiert die Syntax so, dass ein Array erzeugt wird und alle folgenden Werte diesem zugeführt werden. Die Ausgabe erfolgt sehr schnell und leicht über die foreach-Schleife:

<?php
  if($_POST['eingabe']==1)
  {
    if($suche=$_POST['suchmaschinen'])
    {
      foreach($suche as $element)
      {
        echo "$element <br />";
      }
    }
  }
  else { echo "Keine"; }
?>

Parameterübergabe

Im Gegensatz zu POST hält die Methode GET weitere Möglichkeiten bereit, um dynamische Webseiten erst sinnvoll erscheinen zu lassen. Nehmen wir mal an, dass Du eine Basisseite benutzt, welche sich aus Modulen zusammensetzt. Die Module willst Du per include oder reqire in diese Basisdaten laden. Die Basisdatei muss wissen, welche Module der Besucher sehen darf. Hierzu dienen Parameter, welche per URL übertragen werden. Die Parameter, bzw. Variablen, stehen für das zu ladende Modul. Das heißt, dass jeder Link auf der Seite diese Informationen tragen sollte.

Übergabe per Link

Die Syntax wurde bereits Eingangs im Abschnitt zu den Methoden POST und GET kurz erklärt.

Alle Variablen werden an die URL nach einem ? angehängt. Die Trennung der einzelnen Parameter erfolgt durch das Kaufmanns-Und(&). Eine Variable ist durch ein = von ihrem Wert getrennt. Auch wenn kein Wert zugewiesen wird, folg das Gleichheitszeichen der Variablen.

<a href="index.php?variable1=wert1&variable2=wert2&variable3=wert3>Link</a>

Die URL ist dabei maximal 2000 Zeichen lang, damit er von jedem Browser übergeben werden kann.

Ein Beispiel demonstriert, wie spezielle Daten auf diese Art aufgerufen oder verändert werden können:

<html><head><title>Parameter per URL Weitergeben</title></head><body bgcolor="<?php if(!$color=@$_GET['color']) echo "white"; else echo $color;  ?>">
<a href="test.php?page=home&color=white">Home</a><br />
<a href="test.php?page=me&color=red">Ich</a> <br />
<a href="test.php?page=links&color=green">Links</a> <br />
<?php
switch($page=@$_GET['page'])
{
  case "home" : echo "<br /> Hier soll 'home' per include aufgerufen werden";
    break;
  case "me" : echo "<br /> Hier soll 'me' per require aufgerufen werden";
    break;
  case "links" : echo "<br /> Hier soll 'links' per include_once aufgerufen werden";
    break;
}
?>
</body></html>

Nicht nur der Inhalt der Seite ändert sich; ebenso wird die Hintergrundfarbe der Seite verändert:

(De-)Kodierung der URL

Sobald Du keine lücken- und sonderzeichenlose Daten mehr per URL übertragen willst, kommt es ohne deren Kodierung zu Fehlern.

Die Funktionen urlencode() und urldecode() werden Dir alle Sonderzeichen oder auch nicht-URL-spezifische Zeichen ersetzen oder wieder umwandeln. Der folgende Link würde Dir vor der Behandlung Probleme bereiten:

<a href="index.php?oage=Das Bin Ich&color=BGCOLOR="RED"">Ich</a>

urlencode() wandelt die für die URL „untauglichen“ Zeichen in ASCII-Code um. Jedem ASCII-Wert wird ein %(Prozent) Zeichen vorangestellt.

<?php
  $url = urlencode("pages=Das bin ich&color=BGCOLOR=\"RED\"");
?>
<a href="index.php?<?php echo $url; ?>">Das bin ich</a>
Ausgabe
<a href="http://localhost/index.php?pages%3DDas+bin+ich%26color%3DBGCOLOR%3D%22RED%22">Das bin ich</a>

urldecode() ändert diese Zeichenkette wieder in ihren ursprünglichen Zustand.

Die globale Variable $_SERVER["QUERY_STRING"]

Diese globale Variable gibt Dir den Teil der URL zurück, der an das ?(Fragezeichen-) Zeichen angehängt ist. Damit greifst Du nicht auf die automatische Interpretation der Parameter durch PHP zurück, sodass Du diese selbst bearbeiten kannst. $_SERVER['QUERY_STRING'] gibt Dir den Teil der URL als Ganzes zurück.

Dies ist dann vorteilhaft, wenn der Parameterteil der URL geschlossen wiedergegeben werden soll. Angenommen, Du befindest dich in einem Forum von Einer Internetseite in einem bestimmten Beitrag. Du willst auch Deine Meinung zum Thema in ein Formular schreiben. Hier wäre es günstig, wenn Du direkt nach dem Absenden zum gleichen Beitrag geführt wirst und deinen Kommentar nochmal durchlesen kannst. Dass Du wieder zu diesem Beitrag zurückkommst, kann Dir QUERY_STRING möglich machen. In einem unsichtbaren Feld des Formulars werden die Parameter, welche zum Beitrag führen, gespeichert.

Falls Du gleiche Variablennamen für verschiedene Werte verwendest, muss sogar QUERY_STRING eingesetzt werden, denn anderenfalls werden nur die letzte Variable und ihr Wert aus der URL zurückgegeben.

<a href="test.php?name=joerg&name=soeren&name=sven">Namen</a>
<?php
  if($name=@$_GET['name'])
  {
    echo "<br /> Normal: $Name";
    $parameter = $_SERVER['QUERY_STRING']
    echo "<br /> mit globaler Variable: $parameter";
  }
?>
Ausgabe

normal: sven mit globaler Variable: name=joerg&name=soeren&name=sven

Datei-Upload über Formulare

Der Datei-Upload über den Browser erspart Dir den Zugriff auf den FTP-Server. Auch die Kontrolle über die hochzuladenden Dateien wird auf diese Weise sehr leicht.

Der Upload erfolgt über ein Formular, dessen Eingaben mit der Methode POST an eine URL gesendet werden. Der wesentliche Vorgang ist einfach zu beschreiben. Du trägst die lokale abgelegte Datei in das Formular ein oder durchsuchst Deine Festplatte nach der Datei. Die submit-Funktion sendet die Datei an die Zieladresse.

Um eine Datei an den Server zu schicken, muss das Formular den Typ multipart/form-data in der form-Auszeichnung enthalten:

<form enctype="mulitpart/form-data" action="url" method="post">

Das Formular selbst benötigt mindestens ein input-Element vom Typ file und einen submit-Button.

<?php
  $target="localhost/upload/upload.php";
?>
<html><head><title>Dateiupload</title></head><body>
  <form enctype="mulitpart/form-data" action="<?php echo $target; ?>" method="post">
  <input type="file" name="file" /><br />
  <input type="submit" value="Hochladen" />
  </body></html>

Als Ziel muss eine PHP-Datei angegeben werden; die hochgeladene Datei wird nämlich in einem temporären Ordner des Servers abgelegt und sofort gelöscht, wenn der Upload abgeschlossen ist. Das Skript, welches als Ziel angegeben wird, dient Dir zur Verarbeitung der Daten. Zumindest muss die Datei durch das Skript über den Dateizugriff an seinen wahren Bestimmungsort auf dem Server kopiert werden.

Das Zielskript upload.php sollte jedoch noch etwas mehr können. So soll es prüfen, ob die Datei bereits vorliegt, und diese auf Wunsch umbenennen. Doch zunächst solltest Du erfahren, wie Du Informationen über die Datei erhälst.

Nach dem Sendevorgang steht dem aufgerufenen Skript automatisch das assoziative Array $_FILES[] zur Verfügung. Dieses assoziative Array enthält selbst wieder assoziative Arrays, von denen jedes die Informationen über eine gesendete Datei enthält. Den Zugriff auf das erste assoziative Array erhälst Du, indem Du den Namen des Datei-Upload-Elements im Formular einsetzt (Hier file)

  • $_FILES[„file“][„tmp_name“] enthält den Dateinamen der im temporären Ordner liegenden Datei.
  • $_FILES[„file“][„name“] enthält den Originalen Namen der Datei.
  • $_FILES[„file“][„size“] enthält die Dateigröße.
  • $_FILES[„file“][„type“] enthält den Media-Typ der Datei (die unterstützten Typen erfährst Du von deinem Provider oder findest sie in der Konfiguration des Servers.
  • $_FILES[„file“][„error“] kann verwendet werden, um auf Fehler nach dem Upload zu testen. Folgende Werte sind möglich:
    • UPLOAD_ERR_OK(0) kein Fehler.
    • UPLOAD_ERR_INI_SIZE(1): Datei ist größer als der Wert, der in der Datei php.ini unter upload_max_filesize angegeben wurde.
    • UPLOAD_ERR_FORM_SIZE(2): Datei ist größer als im Form-Tag des Formulars angegeben.
    • UPLOAD_ERR_PARTIAL(3): Datei wurde nicht vollständig Hochgeladen.
    • UPLOAD_ERR_NO_FILE(4): Es wurde keine Datei hochgeladen.

Begrenzung der Dateigröße

Zwar ist die Begrenzung im Zielskript sinnvoller, aber dennoch gibt Dir auch das Formular die Möglichkeitm die Dateigröße zu begrenzen. Dazu wird ein unsichtbares Formularelement erstellt. Der Elementname wird mit MAX_FILE_SIZE angegeben. Der zugewiesene Wert einer Ganzzahl entspricht der zulässigen Dateigröße in Byte. Wir der zulässige Wert überschritten, gibt der Browser zwar eine Fehlermeldung aus, die Datei wird aber dennoch hochgeladen.

<input type="hidden" name="MAX_FILE_SIZE" value="1000000">

Bei dieser Variante besteht die Chance des Missbrauchs, denn das Formular kann auf der Seite des Clients selbst geschrieben werden.

Eine wirkungsvollere Methode stellt die Einschränkung über Servereinstellungen selbst dar. In der php.ini existiert ein Eintrag namens upload_max_filesize, dessen Wert in Byte Du beliebig verändern kannst. Ist eine Größe angegeben kann sie auf dem Server nicht überschritten werden und ist damit global festgelegt. Bitte beachte, dass einige Provider diese Einstellung aus Sicherheitsgründen mit einem Wert belegt haben (Standardmäßig sind es 2 Mbyte und meist auch so belassen).

Mehrere Dateien hochladen

Unter Formularoptionen und Arrays wurde beschrieben. wie Du mehrere Werte über Formularelemente mit gleichem Elementnamen verschicken kannst. Das gleiche Prinzip wird auch beim Upload angewendet. Dabei erzeugt PHP wieder ein Arry.

<form enctype="multipart/form-data" action="<?php echo $target; ?>" method="POST">
<input type="file" name="file[]"><br />
<input type="file" name="file[]"><br />
<input type="file" name="file[]"><br />
<input type="submit" value="Hochladen" />
</form>

Das Zielskript sollte jetzt natürlich auch auf Arrays zugreifen

Die Zieldatei

Die Zieldatei, welche im Form-Tag angegeben wurde, soll im Wesentlichen folgende Funktion besitzen:

  • Prüfen, ob es sich wirklich um eine hochgeladene Datei handelt
  • Prüfen der Dateigröße
  • Prüfen, ob Zieldatei schon vorliegt,
  • Kopieren der hochgeladenen Datei aus dem temporären Verzeichnis in das Zielverzeichnis.
  • Fehlerkorrektur
  • Löschen der temporären Datei(Wird von PHP automatisch erledigt).

Ein wichtiges Kriterium für Skripts ist die Wiederverwendbarkeit. Falls sich Änderungen ergeben, wie zum Beispiel durch einen Providerwechsel oder einfach durch die zugelassene Dateigröße, soll ja nicht das gesamte Skript umgeschrieben werden. Deswegen werden diese Werte eingangs deklariert.

<?php
  $ziel = "."; //Zielverzeichniss
  $datei_max = 1024000; // Maximale Dateigröße in Byte
  $datei_ende = ".jpg"; //Zugelassene Dateiendung
  $datei_mime = "image/jpeg"; // Mime-Type der Hochzuladenen Datei.
 

Dann wird die Funktion für die zufällige Auswahl eines neuen Dateinamens vereinbart. Schließlich sollen schon existierende Dateien mit dem gleichen Dateinamen nicht einfach überschrieben werden.

$zielname = tempnam($ziel, "IMG") . $datei_ende;

Diese Funktion wird dann an gewünschter Stelle aufgerufen. Jetzt folgt die eigentliche Programmstruktur, welche die Datei aus dem temporären Ordner in den Zielordner kopiert und auf Fehler überprüft.

  if(!is_uploaded_file($_FILES["file"]["tmp_name"])
  {
    exit("Es handelt sich um keine hochgeladene Datei.");
  }
  if($_FILES["file"]["size"] > $datei_max)
  {
    exit("Die Datei ist gr&ouml;&szlig;er als $datei_max Byte.");
  }
  if($_FILES["file"]["type"] != $datei_mime)
  {
    exit("Der Dateityp ist nicht richtig. Die Datei muss vom Typ $datei_ende sein.");
  }
  if(file_exists($zielname) or !copy($_FILES["file"]["tmp_name"], $zielname))
  {
    exit("Ein Fehler ist beim Kopieren der Datei ".$_FILES["file"]["name"]." Aufgetreten!");
  }
  echo "Die Datei <strong>".basename($zielname)."</strong> wurde erfolgreich Hochgeladen. <br /> <br />";
?>

Am Schluss kannst Du die hochgeladene Datei löschen, was PHP allerdings automatisch erledigt, wenn das Skript beendet wird. Allerdings ist der Code sauberer, wenn man dies nicht automatisch machen lässt.

unlink($_FILES["file"]["tmp_name"]);
?>

Das Skript eignet sich vor allem für den kontrollierten Upload eines bestimmten Dateityps. Eine Anwendung im bereich von Nutzer-spezifischen Anwendungen ist optimal. So könnte zum Beispiel jeder angemeldete Benutzer ein Bild von sich auf Deine Website laden. Der neu erzeugte Dateiname sollte dann nur noch in einer Datenbank gespeichert werden, sonst verlierst Du die Übersicht über die kryptisch anmutenden Dateinamen.


Die Prüfung auf den Dateityp beinhaltet allerdings Risiken, denn es wird lediglich das geprüft, was der Browser an PHP weitergibt. Eine tatsächliche Prüfung findet nicht statt.


Sicherheitshinweis

Der Upload einer Datei birg Risiken. Sobald Dateien unkontrolliert auf den Webserver geladen werden drüfen, sind Benutzer mit bösen Absichten oder einer gefährlichen Unkenntnis nicht weit. So könnten Viren, Trojanische Pferde oder einfach nur Datenmüll versendet werden.

Deshalb solltest Du den Datei-Upload immer absichern.