Superglobals

Als Superglobale (superglobals) werden Variablen bezeichnet die in jedem Geltungsbereich verfügbar sind, zu diesen zählen:

Im Gegensatz zu allen anderen Variablen, welche nur innerhalb ihres Geltungsbereichs bekannt sind, also betrachtet und verändert werden können, kann auf superglobale Variablen von überall aus zugegriffen werden.

Einmalig definierte Klassen, Funktionen und Konstanten sind genau wie Superglobale überall verfügbar.

In früheren Versionen von PHP war es so, das per Formular oder Parameterübergabe übermittelte Variablen automatisch registriert wurden und so im Skript zur Verfügung standen. Mit der Zeit erwies sich diese Vorgehensweise aber als potentielles Sicherheitsrisiko. Man kann zwar trotzdem mit register globals sicher programmieren, aber in der Praxis gab es ein paar Skripte die deshalb angegriffen werden konnten. Die Funktion register globals ist also seit längerem in der Standardinstallation von PHP deaktiviert. Das sollte man auch so lassen, den es gibt eigentlich keinen Grund dafür es zu nutzen.

$GLOBALS

$GLOBALS ist ein superglobales assoziatives Array, das Referenzen auf alle Variablen enthält, die derzeit im globalen Gültigkeitsbereich (Scope) des Skripts bekannt sind. Die Namen der jeweiligen Variablen sind die Schlüsselwerte, um auf den Inhalt der jeweils referenzierten Variablen zuzugreifen.

Ausgabe aller bekannten Variablen

Mit print_r($GLOBALS); bekommen sie eine Liste aller bekannten Variablen in lesbarer Form.

<pre>
<?php
print_r($GLOBALS);
?>
<pre>

PHP speichert alle globalen Variablen in $ GLOBALS[Index]. Der Index enthält den Namen der Variablen (assoziativ).

<?php
$a = 20; 
$b = 5;
 
function myFunc() { 
$GLOBALS['c'] = $GLOBALS['a'] + $GLOBALS['b']; 
}
 
myFunc(); 
echo $c; 
?>

$_SERVER

$_SERVER ist eine superglobales asoziatives Array das Informationen zu Header, Pfade und die verschiedenen Wege, das Skript anzusprechen beinhaltet. $_SERVER kennt u.A. folgende Indizien.

Indizien Bedeutung
PHP_SELF Dateiname des aktuell ausgeführten Skripts
AUTH_TYPE Authentifizierungstyp bei gesicherten Sites
CONTENT_LENGTH Länge des gesendeten Inhalts in Byte
CONTENT_TYPE Angabe des Inhaltstyps, z. B. text/html
GATEWAY_INTERFACE Bezeichnung der Schnittstelle, z. B. CGI/1.1
HTTP_ACCEPT Was HTTP akzeptieren soll, normalerweise */*
HTTP_COOKIE Eventiell vorhandene Cookie-Daten
HTTP_REFERER Die letzte Adresse, von welcher der Browser kam
HTTP_USER_AGENT Kennung des Browsers, z. B. Mozilla/4.0
PATH_INFO Informationen zum Pfad des Skripts
PATH_TRANSLATED Physischer Pfad
REMOTE_ADDR Die IP-Adresse des Clients, z. B. 192.168.200.1
REMOTE_HOST Name des Clients, welcher die Anfrage gestartet hat, z. B. www.adiprinz.at
REMOTE_USER Anmeldename des Anwenders bei gesicherten Seiten
REMOTE_IDENT Identifikator
REMOTE_METHOD Die Art der Anfrage, bei einem Seitenaufruf meist GET, bei einem Formular auch POST
QUERY_STRING GET-Daten, z. B. varname=varvalue&session=1234
SCRIPT_NAME Pfad und Name zum Skript, z. B. /cgi-bin/ausgabe.php
SERVER_NAME Name des Hosts, z. B. www.selfas.de
SERVER_PORT Der Serverport, über den das Skript aufgerufen wurde, im WWW meist 80
SERVER_PROTOCOL Protokoll des Servers, z. B. HTTP/1.1
SERVER_SOFTWARE Beschreibung der auf dem Server verfügbaren Software. So meldet sich der Server, z. B. Apache/2.0.13

Beispiele mit $_SERVER

Hier finden sie noch einige einfache Beispiele für die Verwendung von $_SERVER.

<?php
echo "SERVER_NAME: " . $_SERVER['SERVER_NAME'] . "<br />";
echo "SCRIPT_NAME: " . $_SERVER['SCRIPT_NAME'] . "<br />";
echo "SERVER_PORT: " . $_SERVER['SERVER_PORT'] . "<br />";
echo "HTTP_USER_AGENT: " . $_SERVER['HTTP_USER_AGENT'] . "<br />";
echo "REMOTE_ADDR: " . $_SERVER['REMOTE_ADDR'] . "<br />";
?>

$_GET

$_GET ist ein superglobales, assoziatives Array von Variablen, die dem aktuellen Skript mittels der URL übergeben werden. Wenn an eine URL Informationen zum Weiterleiten mitgegeben werden nennt man das eine URI (Uniform Resource Identifier). An die URL wird ein Fragezeichen (?) angefügt, dann folgen Variablen mit Wertzuweisungen. Als Trennzeichen wird das kaufmännischem UND (&) verwendet. Um die URI-Codierung kümmert sich PHP selbst.

<a href='seite2.php?name=Adi Prinz&beruf=IT-Trainer&alter=45'>Seite 2</a>

urlencode()-Funktion

An dieser Stelle werde ich die urlencode()-Funktion vorstellen. Eine URI darf z.B. kein Leerzeichen und einige Sonderzeichen beinhalten. urlencode codiert einen String "Urigerecht"!

<?php
$uri = "seite2.php?name=Adi Prinz&beruf=IT-Trainer&alter=45";
echo urlencode($uri);
?>

Für die Beispiele hier ist urlencode() nicht notwendig!

Das aufgerufene Script

Das aufgerufene Script, in unserem Beispiel seit2.php, empfängt nun Variablen und Wertzuweisungen mittels der URI. Mit der $_GET-Methode können diese Werte ausgelesen werden. Um die URI-Decodierung kümmert sich PHP selbst.

<?php
$name = $_GET['name'];
$beruf = $_GET['beruf'];
$alter = $_GET['alter'];
echo "Name: " . $name . "<br />";
echo "Beruf: " . $beruf . "<br />";
echo "Alter: " . $alter . "<br />";
?>

Fehlerbehandlung

Beim Auslesen der URI mit der $_GET-Methode soll immer zuerst geprüft werden, ob Variablen existieren, bzw korrekt übergeben wurden. Das Script würde sonst eine häßliche Fehlermeldung ausgeben. Eine einfache Fehlerbehandlung könnte so aussehen:

<?php
if (isset($_GET['name'])) {
$name = $_GET['name'];
}
?>

urldecode()-Funktion

Genau das Umgekehrte von urlencode() macht die urldecode ()-Funktion. Auch diese Funktion ist für die Beispiele hier nich notwendig, aber man sollte sie zumindest kennen. urldecode codiert eine URI "Stringgerecht"!

<?php
$uri = urldecode("seite2.php%3Fname%3DAdi+Prinz%26beruf%3DIT-Trainer%26alter%3D45");
echo $uri;
?>

Formulare mit $_GET

Mit HTML-Formularen werden Daten vom Browser zum Server übermittelt. Ein Formular setzt sich aus dem form-Tag und den enthaltenen Formularelementen wie Textfeldern, Checkboxen, Auswahllisten etc. zusammen. Im form-Tag sind zwei Attribute wichtig und zwar action und method . Das Attribut action im form- Tag gibt an, welches Script mit dem Klick auf den Submit-Button geöffnet wird. Das Attribut method legt die Methode fest, die PHP für die Übergabe verwenden soll (POST oder GET). Mit der $_GET-Methode werden Variablen und Wertzuweisungen automatisch an die URI übergeben. Der Variablenname wird mit dem name-Attribut der Steuerelemente definiert, die Wertzuweisung ist das, was der user im Formular schreibt oder klickt.

Ein Beispielformular

<form action="seite2.php" method="get">
Name: <input type="text" name="name"><br>
E-mail: <input type="text" name="email"><br>
<input type="submit" name="submit" value="Senden">
</form>

Das empfangende Script kann nun auf folgende $_GET-Variablen zugreifen:

  • name - User Eingabe
  • email - User Eingabe
  • submit - Senden

Das empfangende Script

Der folgende PHP-Code kann nun zum Testen im body-Element der Seite seite2.php kopiert werden. Auf eine Fehlerbehandlung wurde hier verzichtet.

<?php
$name = $_GET['name'];
$email = $_GET['email'];
$submit = $_GET['submit'];
echo "Name: " . $name . "<br />";
echo "Email: " . $email . "<br />";
echo "Submit: " . $submit . "<br />";
?>

$_POST

$_POST ist ein superglobales, assoziatives Array von Variablen. Die $_POST-Methode schickt unbegrenzte Mengen an Daten zur weiteren Verarbeitung zum Server. Praktisch gesehen dient $_POST dazu, ähnlich wie $_GET, Formulardaten vom Browser zum Server zu übertragen.

Unterschiede und Gemeinsamkeiten von $_GET und $_POST

Die Unterschiede sind technisch gesehen größer als hier angeführt. Für den Einsatz in PHP-basierten Webanwendungen ist lediglich folgendes von Interesse:

  • Die POST-Methode überträgt die Daten im Körper (Body) der Nachricht. Damit sind die Daten ein Teil der Nachricht, welche aus Kopf (Header) und Körper (Body) zusammengesetzt ist. In diesem Fall ist der Platz übrigens nicht beschränkt
  • Die GET-Methode nutzt die URI zur Übertragung der Daten und hängt diese quasi an die URL mit an. Die Länge der URL ist jedoch bestimmten Beschränkungen von Seiten der Browser unterworfen. Daher sollte die Datenmenge möglichst eine Größe von 2 Kilobyte nicht überschreiten. Dies ist im Übrigen schnell erreicht, da neben den eigentlichen Daten auch jedes Trennzeichen und jeder Variablen- bzw. Feldname mit übertragen wird
  • Enthält das Formular Werte, die nicht in der URL angezeigt werden sollen, dann ist die Verwendung von POST anzuraten
  • $_POST sollte verwendet werden, wenn die Länge von Eingabeelementen nicht nach oben begrenzt ist, also immer dann, wenn eine TEXTAREA verwendet wird
  • $_POST ist zwingend notwendig, wenn ein File-Upload durchgeführt werden soll (siehe Kapitel $_FILES), einmal wegen der prinzipiell unbegrenzten Länge, aber auch weil das notwendige Attribut ENCTYPE="multipart/form-data" nur in Verbindung mit POST funktioniert

Ein Beispielformular

Für dieses Beispiel kann dasselbe Formular wie oben verwendet werden, nur das method-Attribut muss von get auf post geändert werden.

<form action="seite2.php" method="post">

Das empfangende Script kann nun auf folgende $_POST-Variablen zugreifen. Im Beispiel werden vorher alle drei $_POST-Variablen auf deren Existenz geprüft.

<?php
if (isset($_POST['name']) && isset($_POST['email']) && isset($_POST['submit'])) { 

echo "Name: " . $_POST['name'] . "<br />";
echo "Email: " . $_POST['email'] . "<br />";
echo "Submit: " . $_POST['submit'] . "<br />";
} else {
echo "Unbekannter Fehler!";
}
?>

Multiple

Es gibt auch Fälle, in denen Mehrfachangaben erwünscht sind. So kann beispielsweise mit dem select-Attribut "multiple" eine Mehrfachauswahl zugelassen werden.

<form action="seite2.php" method="post">
Name: <input type="text" name="name"><br>
E-mail: <input type="text" name="email"><br>
<select name="thema[]" size="4" multiple>
<option   value="Autos">Autos</option>
<option   value="Filme">Filme</option>
<option   value="Essen">Essen</option>
<option   value="Sport">Sport</option>
</select>
<input type="submit" name="submit" value="Senden">
</form>

Mit den eckigen Klammernpaar nach dem name-Attribut im select-Element wird der $_POST-Variablen mitgeteilt, dass ein Array verwendet werden soll.

Das aufgerufene Script kann dann die Auswertung mithilfe einer foreach-Schleife durchführen.

<?php
if ($_POST['thema']) {
echo "Es sind folgende Themen enthalten: " . "<br>";
foreach($_POST['thema'] as $element)   {
echo "$element" . "<br>";
}}
?>

$_COOKIE

$_COOKIE ist ein superglobales, assoziatives Array von Variablen, die auf dem Rechner des Clients in Form von maximal 4 Kilobyte großen Textdateien abgelegt werden und die dazu dienen, Informationen zwischenzuspeichern.

Da das Verfallsdatum der Cookies vom installierenden Webserver explizit festgelegt werden kann, ist ihre Lebensdauer sehr unterschiedlich. Manche sind nur so lange aktiv, wie der Browser geöffnet ist, andere haben eine Lebensdauer von mehreren Monaten oder Jahren. Nachdem das Verfallsdatum eines Cookies erreicht wurde, wird es vom Browser automatisch gelöscht. Ein spezielles Cookie kann nur von dem Server ausgelesen werden, der es angelegt hat. Zwar kann ein Webserver auch Cookies für einen anderen Server anlegen lassen, diese können dann jedoch nur von dem Server ausgelesen werden, für den die Cookies angelegt wurden.

Cookies setzen

Die setcookie()-Funktion definiert ein mit den HTTP Header-Informationen zu übertragendes Cookie. Wie andere Header auch, müssen Cookies vor jeglicher Ausgabe Ihres Skriptes gesendet werden. Das bedeutet, dass diese Funktion aufrufen wird, noch bevor eine Ausgabe, dazu zählen auch html- oder head-Tags sowie jede Art von Whitespaces, übermitteln wird. Am Besten noch vor der Dokumenttypdeklaration. Die Syntax lautet:

setcookie(name, value, expire, path, domain, secure, httponly);

Beim Setzen von Cookies ist nur der Parameter "name" pflicht, alle anderen Parameter sind optional.

  • name - Der Name des Cookies
  • value - Der Wert des Cookies. Dieser Wert wird auf dem Client gespeichert
  • expire - Der Zeitpunkt, wann das Cookie verfällt. Dies ist ein Unix-Timestamp, also die Anzahl Sekunden seit der Unix-Epoche. Dieser Wert kann mittels der Funktion time() oder mktime() und der Anzahl Sekunden bis zum gewünschten Ablauf des Cookies gesetzt werden.
    time()+60*60*24*30 wird das Cookie in 30 Tagen ablaufen lassen. Ist der Parameter nicht gesetzt, verfällt das Cookie am Ende der Session, sobald der Browser geschlossen wird.
<?php
$inhalt = "Ich bin dein Cookie!";
setcookie("mycookie",$inhalt, time()+600);
?>
<!DOCTYPE html>
<html> 
<body> 
<a href="seite2.php">Seite 2</a> 
</body> 
</html> 

Die Funktion erzeugt ein Cookie mit dem Namen mycookie und dem Inhalt aus der Variablen Ich bin dein Cookie!. Der Parameter expires, der die Lebensdauer des Cookies in Sekunden nach dem 1.1.1970 angibt, wird durch die Funktion time() und ein Offset von 600 Sekunden erzeugt. Die Funktion time() gibt dabei den aktuellen Unix-Zeitstempel zurück, sodass auf diese Weise für das Cookie eine Lebensdauer von zehn Minuten festgelegt wird. Wird keine Zeit angegeben, ist das Cookie so lange gültig, bis der Browser geschlossen wird.

Eine Beschreibung weiterer Parameter finden sie hier:

php.net

Cookies aufrufen

Dem verarbeitenden Script (z.B. seite2.php) steht das Cookie in Form einer Variablen zur Verfügung. Für den Aufruf sorgt das Array $_COOKIE. Mit dem Befehl print_r($_COOKIE) werden alle Cookies zurückgegeben.

<?php
echo $_COOKIE["mycookie"] . "<br>";
echo "<pre>";
print_r($_COOKIE);
echo "</pre>";
?>

Mehrere Cookies setzen

Wenn mehrere Cookies gesetzt werden, muss die setcookie()-Funktion dementsprechen oft geschrieben werden.

<?php
$name = "Adi Prinz";
$beruf = "IT-Trainer";
$alter = 45;
setcookie("name", $name, time()+600);
setcookie("beruf", $beruf, time()+600);
setcookie("alter", $alter, time()+600);
?>

Das verarbeitendene Script könnte dann so aussehen, wie im folgenden Beispiel. Die !isset()-Prüfung liefert WAHR, wenn die Cookie-Variable NICHT existiert.

<?php
if (!isset($_COOKIE["namse"]) || !isset($_COOKIE["beruf"]) || !isset($_COOKIE["alter"])) {
echo "Cookie ist nicht vorhanden!";
} else {
echo "Name: " . $_COOKIE["name"] . "<br>";
echo "Beruf: " . $_COOKIE["beruf"] . "<br>";
echo "Alter: " . $_COOKIE["alter"] . "<br>";
}
?>

Cookies aus Arrays

Cookies können auch mit einem Array gesetzt werden. Dadurch werden so viele Cookies gesetzt, wie das Array Elemente hat. Sobald das Cookie aber vom verarbeitendenen Script gelesen wird, werden alle Werte in ein einziges Array mit dem Cookienamen eingelesen.

<?php
setcookie("cookie[three]", "cookiethree");
setcookie("cookie[two]", "cookietwo");
setcookie("cookie[one]", "cookieone");
?>

Das verarbeitendene Script könnte dann ein einzelnes Cookie mit folgender Syntax auslesen.

<?php
echo "Name: " . $_COOKIE['cookie']['three'];
?>

Alle Cookies aus einem Array werden in der Regel mit einer foreach -Schleife ausgelesen.

<?php
if (isset($_COOKIE['cookie'])) {
foreach ($_COOKIE['cookie'] as $name => $value) {
echo "$name : " . $value . "<br>";
}}
?>

Cookies löschen

Natürlich können Cookies auch entfernen werden. Hierbei handelt es sich jedoch weniger um einen üblichen Löschvorgang als vielmehr ein Bearbeiten des Verfallsdatums, welches im Attribut expires festgelegt wurde. Beim Löschen eines Cookies wird die setcookie()-Funktion nochmal geschrieben. Es muss natürlich der korrekte Name des Cookies verwendet werden. Das Verfallsdatum wird dabei irgendwann in der Vergangenheit festgelegt. Im Beispiel wird ein Cookie mit dem Namen myCookie aus dem Browser des Clients entfernt. Der expire-Parameter liegt eine Stunde in der Vergangenheit.

<?php
setcookie ("mycookie", "", time() – 3600);
?>

$_REQUEST

$_REQUEST ist ein superglobales, assoziatives Array, das standardmäßig den Inhalt von $_GET, $_POST und $_COOKIE enthält. Die Variablen in $_REQUEST werden dem Skript mittels der GET-, POST- und COOKIE-Inputmechanismen zur Verfügung gestellt, das heißt, dass alle $_GET-, $_POST- und $_COOKIE-Variablen auch mit $_REQUEST ausgelesen werden können.

Ein Beispielformular

Das Beispielformular bekommt im form-Element das Attribut method="get". Es könnte genauso gut method="post" sein oder komplett entfallen.

<form action="seite2.php" method="get">
Name: <input type="text" name="name"><br>
E-mail: <input type="text" name="email"><br>
<input type="submit" name="submit" value="Senden">
</form>

Das verarbeitendene Script liest die Variablen mit der $_REQUEST-Methode aus.

<?php
echo "Name: " . $_REQUEST['name'] . "<br />";
echo "Email: " . $_REQUEST['email'] . "<br />";
echo "Submit: " . $_REQUEST['submit'] . "<br />";
?>

$_SESSION

Sessions in PHP bieten die Möglichkeit, bestimmte Daten während einer Folge von Aufrufen Ihrer Website festzuhalten. Wenn einem User nur bestimmte Bereiche einer Website zugängig gemacht werden soll, ist Session das richtige Werkzeug.

Dem Besucher wird beim Aufruf Ihrer Website eine eindeutige ID, die sogenannte Session-ID, zugeordnet. Diese wird entweder benutzerseitig in einem Cookie abgelegt oder in der URL übermittelt.

Sessions ermöglichen, eine beliebige Anzahl von Variablen zu registrieren und diese über Anfragen hinweg zu erhalten. Wenn ein Besucher die Website aufruft, überprüft PHP automatisch ob mit der Anfrage schon eine bestimmte Session-ID gesendet wurde. Wenn dies der Fall ist, wird die zuvor gespeicherte Umgebung wiederhergestellt.

Eine Session starten

Eine Session wird mit der session_start()-Funktion eröffnet. Die session_start()-Funktion muss als erstes im PHP-Dokument geschrieben werden, also noch vor HTML. Session-Variablen werden mit dem superglobalen, assoziatives Array $_SESSION erzeugt.

<?php
session_start();
$_SESSION['userName'] = 'aprinz';
$_SESSION['zeit'] = time();
?>
<!DOCTYPE html>
<html> 
<body> 
<p>
<a href="seite2.php">Seite 2</a> 
</p>
<?php
$name = session_name();
$id = session_id();
echo "Session Name: " . $name . "<br>";
echo "Session ID : " . $id;
?>
</body> 
</html> 

Session-Name & Session-ID

session_start() erzeugt eine Session-ID und einen Session-Namen. Beide Informationen werden standardmäßig als Name/Wert-Paar in einem Cookie am Client gespeichert. Name und ID können mit folgenden Funktionen aufgerufen werden:

  • session_name() - liefert den Sessionnamen, Standard ist PHPSESSID
  • session_id() - liefert die Session-ID die von PHP generiert wird z.B. pids3cedea3blgbqsm2ncc8le6

Wie schon erwähnt, werden Session-ID und Session-Name in einem Cookie am Client-Rechner gespeichert, der Programmierer muss sich darum nicht weiter kümmern. $_SESSION-Variablen hingegen werden am Server gespeichert und stehen dem Client für die Dauer der Session zur Verfügung. Wenn nun eine neue Seite aufgerufen wird, und die Seite beginnt wieder mit session_start(), dann erkennt PHP ob eine Session existiert, ansonsten wird eine neue ID und ein neuer Name generiert. Einfach ausgedrückt heißt das, die neue Seite schaut nach, ob ein Session-Cookie existiert und sendet die ID zurück an den Server.

Aufruf einer neuen Web-Seite

Jede neue Seite innerhalb der Session beginnt wieder mit session_start(). Wenn nun die Session-Id vom Server erkannt wird, stehen alle Session-Variablen zur Verfügung.

<?php
session_start();
if (isset($_SESSION['userName']) && isset($_SESSION['zeit'])) {
$userName = $_SESSION['userName'];
$zeit = date('d.m.Y H:i:s', $_SESSION['zeit']);
} else {
$userName = "";
$zeit = "";
}
?>
<!DOCTYPE html>
<html> 
<body> 
<?php
if ($userName == 'aprinz') {
echo "Willkommen, du bist hier richtig! <br>";
echo $zeit;
} else {
echo "Du bist hier falsch!";
}
?>
</body> 
</html> 

Zu bedenken ist auch, dass es Benutzer gibt, deren Browser Cookies nicht zulassen. Für diesen Fall stellt PHP eine andere Methode zur Verfügung, Dafür brauchen wir die Konstante SID.

Die Konstante SID

Das Session-Modul unterstützt beide Methoden. Cookies sind optimal, stehen aber nicht immer zur Verfügung. Als Alternative bietet sich die $_GET-Methode an. Diese Methode hängt den Session-Namen und die Session-ID direkt an die URL an.

<?php
session_start();
$_SESSION['userName'] = 'aprinz';
$_SESSION['zeit'] = time();
?>
<!DOCTYPE html>
<html> 
<body> 
<p>
<a href="seite2.php?<?php echo SID ?>">Seite 2</a> 
</p>
<?php
echo SID;
?>
</body> 
</html> 

URL-basiertes Session-Management hat im Vergleich zu Cookie-basiertem Session-Management zusätzliche Sicherheitsrisiken. Benutzer können eine URL einsehen und die Session-ID kopieren.

Eine SID könnte z.B. so aussehen:

PHPSESSID=3nqpi61cmh5j44lmcubmgbq026 

Eine Session beenden

Eine Session wird automatisch beim Schließen des Browserfensters beendet. Um eine Session manuell zu beendet stellt PHP die Funktion session_destroy() zur Verfügung. Nachdem session_destroy() aufgerufen wurde ist zwar die Session zerstört, die Sessionvariablen existieren nach wie vor. Das löschen von Sessionvariablen kann mit der session_unset()-Funktion erledigt werden.

<?php
session_unset();
session_destroy();
?>

Natürlich kann PHP auch Sessionvariablen löschen, ohne die Session zu beenden. Das könnte dann ungefähr so aussehen:

unset($_SESSION['userName']);

Session Funktionen

Eine Liste der Session Funktionen finden sie hier:

php.net

$_FILES

$_FILES[] ist ein superglobales, assoziatives Array von Elementen, die vom aktuellen Skript via HTTP POST-Methode hochgeladen werden. Damit der User Dateien hochloden kann, muss ein Formular zur Verfügung stehen.

Das HTML Formular

Eine Maske für den Dateiupload kann erstellt werden, indem man ein Formular entwirft, das ungefähr so aussieht:

<form enctype="multipart/form-data" 
action="<?php echo $_SERVER['PHP_SELF']; ?>" method="post">  
<input type="hidden" name="MAX_FILE_SIZE" value="1000000">  
Send this file: 
<input name="datei" type="file">  
<input type="submit" value="Send File">  
</form>

Damit der Browser eine Datei vom Client zum Server überträgt, benötigen Sie ein input-Feld vom Typ file und das Attribut enctype="multipart/form-data" des form-Tags. Zusätzlich ist die Übertragungsmethode POST zwingend erforderlich, damit der Datei-Upload fehlerfrei durchgeführt werden kann. Es können sowohl Text- als auch Binärdaten hochgeladen werden. Die URL sollte auf eine PHP-Datei verweisen. Das versteckte Feld MAX_FILE_SIZE muss dem Dateieingabefeld vorangestellt werden und den Wert der maximal akzeptierten Dateigröße in Bytes enthalten.

Achtung

Die maximale Dateigröße MAX_FILE_SIZE ist für den Browser nur ein Hinweis und es ist leicht, diese Grenze zu umgehen. Also verlassen Sie sich nicht darauf, dass der Browser Ihrem Wunsch auch nachkommt! Wie auch immer, die PHP-Einstellungen für die maximale Dateigröße können nicht getäuscht werden.

Wichtige Konfigurationseinstellungen in der php.ini

  • file_uploads
  • upload_max_filesize
  • upload_tmp_dir
  • post_max_size

Das Array $_FILES

Sobald eine Datei an den Server übertragen wird, wird automatisch das globale Array $_FILES erzeugt. In diesem assoziativen Array sind sämtliche Informationen zur Datei gespeichert. Im Folgenden sind die Inhalte von $_FILES aus unserem Beispielskript aufgelistet. Beachten Sie, dass dies auf der Annahme basiert, dass der Name des Dateiuploads wie in dem obigen Beispielskript datei ist.

Element Syntax Bedeutung
name $_FILES["datei"]["name"] Der ursprüngliche Dateiname auf der Clientmaschine. Der genaue Dateiname mit evtl. vorhandenen Laufwerksbuchstaben, Pfadseparatoren und anderen Sonderzeichen ist betriebssystemabhängig.
type $_FILES["datei"]["type"] Dieses Element enthält den MIME-Type der Datei, so wie er dem Server vom Browser übermittelt worden ist. Dieser Wert kann unter Umständen nicht richtig sein, je nach Einstellung des Browsers. Beim Ermitteln des Typs von hochgeladenen Grafiken sollte stattdessen die Funktion getimagesize() verwendet werden.
size $_FILES["datei"]["size"] Die Größe der hochgeladenen Datei in Byte.
tmp_name $_FILES["datei"]["tmp_name"] Dieses Element enthält den Namen der Datei in einem temporären Verzeichnis auf dem Server. Sie kann von dort mit einem move_uploaded_file()-Aufruf abgeholt werden. Das ist auch notwendig, da die Originaldatei am Ende des Skripts automatisch gelöscht wird.
error $_FILES["datei"]["error"] Dieses Element wurde mit PHP 4.2.0 eingeführt und enthält den Status des Datei-Uploads. Die möglichen Werte und dazugehörigen Konstanten finden Sie weiter unten.

Mithilfe des Elemente $_FILES["datei"]["error"] können Sie kontrollieren, ob und welcher Fehler aufgetreten ist.

Fehlerkonstante Wert Bedeutung
UPLOAD_ERR_OK 0 Es liegt kein Fehler vor, die Datei wurde erfolgreich hochgeladen.
UPLOAD_ERR_INI_SIZE 1 Die hochgeladene Datei überschreitet die in der Anweisung upload_max_filesize in php.ini festgelegte Größe.
UPLOAD_ERR_FORM_SIZE 2 Die hochgeladene Datei überschreitet die in dem HTML-Formular mittels der Anweisung MAX_FILE_SIZE angegebene maximale Dateigröße.
UPLOAD_ERR_PARTIAL 3 Die Datei wurde nur teilweise hochgeladen.
UPLOAD_ERR_NO_FILE 4 Es wurde keine Datei zum Server übertragen, das Feld war leer.

Die für hochgeladene Dateien definierten Variablen sind je nach PHP Version und Konfiguration verschieden. Die Autoglobale $_FILES existiert seit PHP 4.1.0. Dieses Arrays enthält alle Informationen über Ihre hochgeladenen Dateien. Die Verwendung von $_FILES wird bevorzugt. Ist die PHP Anweisung register_globals auf on, stehen auch entsprechende Variablennamen zur Verfügung. Seit PHP 4.2.0 steht register_globals standardmäßig auf off.

Eine Datei hochladen

Das erste Beispiel beinhaltet ein Formular (siehe oben), mit dem ein Dateiupload durchgeführt werden kann. Das Script ruft sich selbst auf. Zuständig dafür ist die Aktion:

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

Sobald der Sende-Button geklickt wird steht $_FILES[] zur Verfügung. In diesem Beispiel wird die Datei in einen Temporären-Ordner auf dem Server geladen und einen neuen Namen bekommen. Diese Datei wird spätetens beim Schliessen des Browsers automatisch gelöscht. Der Dateiupload ist somit noch nicht Vollständig vollzogen. Kopieren sie den folgenden PHP-Code in dieselbe Datei wie das Formular.

<?php
echo "<p>Nach dem Upload werden hier Dateiinformationen ausgegeben</p>";
// Dateiinformationen 
if (isset($_FILES['datei'])) {
echo "Name: " . $_FILES['datei']['name'] . "<br />";
echo "Type: " . $_FILES['datei']['type'] . "<br />";
echo "Size: " . $_FILES['datei']['size'] . "<br />";
echo "Tmp_Name: " . $_FILES['datei']['tmp_name'] . "<br />";
echo "Error: " . $_FILES['datei']['error'];
if ($_FILES['datei']['error'] == UPLOAD_ERR_OK){
echo "<p>Dateiupload erfolgreich!</p>";
}else {
echo "<p>Dateiupload nicht erfolgreich!</p>";
}}
?>

Dasselbe Beispiel noch einmal. Allerdings wird $_FILES['datei'] mit einer foreach-Schleife durchgelaufen.

<?php
echo "<p>Nach dem Upload werden hier Dateiinformationen ausgegeben</p>";
// Dateiinformationen (Ausgabe über Schleife)
if (isset($_FILES["datei"])) {
if ($_FILES['datei']['error'] == UPLOAD_ERR_OK){
echo "<p>Dateiupload erfolgreich!</p>";
}else {
echo "<p>Dateiupload nicht erfolgreich!</p>";
}
foreach ($_FILES["datei"] as $key=>$element) {
echo "[$key] => $element<br>";
}}
?>

Das Script sollte die notwendige Logik zur Entscheidung enthalten, was mit der hochgeladenen Datei geschehen soll. Sie können zum Beispiel $_FILES['datei']['size'] benutzen, um zu kleine bzw. zu große Dateien wegzuwerfen. Sie können $_FILES['datei']['type'] nutzen, um Dateien eines unerwünschten Typs wegzuwerfen. Sie können ihre Logik auch mittels $_FILES['datei']['error'] anhand der Fehlercodes planen. Egal welche Logik sie verwenden, Sie sollten die Datei in dem temporären Verzeichnis entweder löschen, oder an einen anderen Ort verschieben.

Wurde die Datei in dem temporären Verzeichnis nicht verschoben oder umbenannt, wird sie am Ende des Requests gelöscht.

Die Funktion move_uploaded_file()

Die move_uploaded_file()-Funktion verschiebt eine upgeloadete Datei an einen neuen Ort. Die Syntax lautet:

move_uploaded_file($filename, $destination)
  • Diese Funktion prüft, ob die mit filename bezeichnete Datei eine gültige Upload-Datei ist (d.h., dass sie mittels PHP's HTTP POST Upload-Mechanismus upgeloaded wurde). Ist die Datei gültig, wird sie zum in destination bezeichneten Dateinamen verschoben.
  • Wenn filename keine gültige Datei ist, wird keine Aktion ausgeführt, und move_uploaded_file() gibt FALSE zurück.
  • Wenn filename eine gültige Datei ist, jedoch aus irgendeinem Grund nicht verschoben werden kann, wird keine Aktion ausgeführt, und move_uploaded_file() gibt FALSE zurück. Zusätzlich wird eine Warnung ausgegeben.
  • Diese Prüfung ist speziell dort interessant, wo irgendeine Aktion mit upgeloadeten Dateien deren Inhalt dem User zugänglich machen könnte (oder auch anderen Usern auf dem selben System).
  • Sollte die Zieldatei bereits existieren, wird sie überschrieben.

Nach dem Upload befindet sich die Datei auf dem Server gespeichert (temporär). Das zweite Argument der Funktion destination legt den Speicherort fest. Wenn sie keine weiteren Pfadangaben schreiben, wird die Datei im selben Ordner wie das ausführende Script gespeichert.

Sobald eine Datei an den Server gesendet wurde, wird sie in einem temporären Verzeichnis unter einem temporären Namen gespeichert. Diese Datei wird jedoch automatisch gelöscht, wenn das verarbeitende Skript beendet ist. Sie müssen daher diese Datei zum endgültigen Ablageverzeichnis kopieren. Erstellen sie im Ordner ihrer PHP-Datei einen neuen Ordner Uploads . Schreiben sie in der PHP-Datei mit dem Formular das folgende Script:

<?php
echo "<p>Nach dem Upload werden hier Dateiinformationen ausgegeben</p>";
// Dateiinformationen (Ausgabe über Schleife)
if (isset($_FILES["datei"])) {
if ($_FILES['datei']['error'] == UPLOAD_ERR_OK){

move_uploaded_file($_FILES["datei"]["tmp_name"],
"Uploads/" . $_FILES["datei"]["name"]);

echo "<p>Dateiupload erfolgreich!</p>";
}else {
echo "<p>Dateiupload nicht erfolgreich!</p>";
}
foreach ($_FILES["datei"] as $key=>$element) {
echo "[$key] => $element<br>";
}}
?>

Wenn sie diese Beispiel testen, achten sie beim Upload auf die Dateigröße (<1MB). Beim Speichern wird der Originalname übernommen.

$_FILES["datei"]["name"]

Upload mehrerer Dateien

Mehrere Dateien können hochgeladen werden, indem verschiedene Namen für input verwendet werden.

<input name="datei_1" type="file">   
<input name="datei_2" type="file">  

Die Übernahme-Routine muss dann für jeden Namen explizit geschrieben werden:

$_FILES["datei_1"]
$_FILES["datei_2"]

Es ist ebenfalls möglich, mehrere Dateien hochzuladen, und die Informationen automatisch in Arrays zu erhalten. Um dies zu tun, verwenden Sie in dem HTML Formular die gleiche Array-Sende-Syntax wie bei Auswahllisten mit Mehrfachauswahl und Checkboxen.

<input name="datei[]" type="file">   
<input name="datei[]" type="file"> 

Das $_FILES-Array bekommt dann eine zusätzliche Dimension.

$_FILES["datei"][0]
$_FILES["datei"][1]

print_r & var_dump()

Mit der Funktion print_r() können Sie Variablen in lesbarer und vorformatierter Form ausgeben lassen (Am Besten innerhalb von pre>-Tags).

Die Funktion var_dump() gibt strukturierte Informationen über einen oder mehrere Ausdrücke aus, darunter auch den entsprechenden Typ und Wert. Arrays und Objekte werden rekursiv durchlaufen und die jeweiligen Werte eingerückt dargestellt, um die Struktur zu verdeutlichen.

<?php
echo "<p>Nach dem Upload werden hier Dateiinformationen ausgegeben</p>";
// Dateiinformationen (Ausgabe über Schleife)
if (isset($_FILES["datei"])) {
if ($_FILES['datei']['error'] == UPLOAD_ERR_OK){
echo "<pre>";
print_r($_FILES);
var_dump($_FILES);
echo "</pre>";
}}
?>

Häufige Probleme

  • Der mit MAX_FILE_SIZE eingestellte Wert kann nicht größer sein als der des ini-Parameters upload_max_filesize. Der Standardwert ist 2 Megabyte.
  • Ist memory limit aktiviert, könnte eine Erhöhung von memory_limit nötig sein. Stellen Sie sicher, dass der Wert von memory_limit groß genug ist.
  • Wenn max_execution_time zu kurz konfiguriert ist, könnte das Skript den Wert überschritten haben. Stellen Sie sicher, dass der Wert von max_execution_time groß genug ist.
  • Ist post_max_size zu klein konfiguriert, können große Dateien nicht hochgeladen werden. Stellen Sie sicher, dass der Wert von post_max_size groß genug ist.
  • Nicht zu prüfen an welcher Datei Sie arbeiten kann bedeuten, dass Benutzer auf sensible Informationen in anderen Verzeichnissen Zugriff erhalten.
  • Aufgrund der vielen möglichen Arten der Darstellung von Verzeichnissen wird nicht garantiert, dass Dateien mit exotischen Namen (wie z.B. mit enthaltenen Leerzeichen) auch wirklich richtig verarbeitet werden.

$_ENV

$_ENV ist ein superglobales assoziatives Array von Variablen, die dem aktuellen Skript mittels der Environment-Methode übergeben werden.

Aufruf der verfügbaren Umgebungsvariablen

Wenn man mit PHP-Scripten auf der Kommandozeile arbeitet, kann man normalerweise über das globale $_ENV Array auf die Umgebungsvariablen zufreifen.

<?php
echo <pre>
print_r($_ENV);
echo </pre>
?>

Damit print_r($_ENV) ein Ergebnis liefert ist eine Einstellung in der php.ini voraussetzung.

variables_order = "GPCS" # (GET, POST, COOKIE, SESSION)

Wenn variables_order gesetzt ist wie im Beispiel oben, (ohne “E”), wird das $_ENV Array nicht befüllt. Folgende Einstellung füllt das $_ENV Array wieder entsprechend:

variables_order = "EGPCS" # (ENV, GET, POST, COOKIE, SESSION)

Für die Verwendung von PHP in Verbindung mit Webservern ist die Standardeinstellung sicherlich nicht ganz falsch. Die Einstellung verhindert dann, dass sämtliche Umgebungsvariablen jedem PHP-Script zum Auslesen zur Verfügung stehen.

Die Funktion phpinfo()

Mit phpinfo() kann man sich sehr viele Informationen über die momentane Konfiguration von PHP anzeigen lassen. Die Ausgabe wird in einer sehr übersichtlichen Tabelle dargestellt.

<?php
echo phpinfo();
?>