Sprachelemente
Was bedeuten diese einzelnen Satzzeichen, Sternchen, Schrägstriche und Klammern in PHP? Welches sind die wichtigsten PHP Sprachelemente? Was sind Variable, Array, String, Schleifen, Funktionen und Klassen? Auch einige erste PHP Funktionen werden hier tabelarisch aufgeführt und verlinkt auf eigene Seiten, wo sie detailliert behandelt werden.
Namen in PHP
Benennung von PHP Elementen
- Ein Namen von einer Variablen, Konstanten, Funktion oder Klasse beginnt nie mit einer Zahl, er darf aber Zahlen enthalten.
- Leehrschläge, Sonderzeichen und Umlaute sind in Namen verboten.
- Unterstriche im Namen sind erlaubt und das Dollarzeichen, letzteres ist das Kennzeichen von Variablen (z.B. $intVar).
- Gross/kleinschreibung wird unterschieden in Namen, nicht aber in Schlüsselworten (z.B. TRUE === true).
- VERSAL geschriebene Namen sind Konstanten-Namen.
- Superglobale Variablen haben einen Unterstrich nach dem $ im Namen und sind VERSAL geschrieben (z.B. $_POST).
- Kein für PHP reserviertes Schlüsselwort und kein Namen für vordefinierte PHP-Funktionen darf als eigener Namen verwendet werden.
- Die Syntax von PHP hat grosse Änlichkeit mit der von C+ aber auch einige Unterschiede.
Einzelne Zeichen
Schrägstriche, Klammern und Satzzeichen
| ; | jede einzelne Anweisung wird mit einem Semikolon ; abgeschlossen. |
| // | kommentiert den Rest der Zeile aus, alles folgende auf dieser Zeile wird nicht dargestellt |
| # | kommentiert auch den Rest der Zeile aus, alles folgende auf dieser Zeile wird nicht dargestellt |
|
/* */ |
kommentiert alles dazwischen liegende aus, über mehrere Zeilen hinweg
Kommentare sind sehr sinnvoll und sollten ausgiebig genutzt werden, damit später das Script noch nachvollzogen werden kann und die Fehlersuche erleichtert wird |
| Mehr zu den Kommentaren: | Coding Guide |
| \
|
Maskierungszeichen, Escape-Zeichen, macht Sonderzeichen zu normalen Zeichen:
|
|
"\n" "\t" "\"" "\\" "\$" |
Innerhalb von doppelten Anführungszeichen:
Zeilenumbruch Tabulator " \ $ |
| ." ". |
Mehrere Leerschläge in doppelten Anführungszeichen (als String) werden von PHP ins HTML eingefügt,
aber von HTML wird nur einer angezeigt. So kann ich meinen HTML-Code,
den ich per PHP schreibe, strukturieren durch Einrücken.
("\s" funktioniert nicht) |
|
'\'' '\\' |
innerhalb von einfachen Anführungszeichen nur:
' \ |
| < >
echo "<h2>Titel</h2>"; |
erzeugt HTML
in einem String |
| " "
|
entweder der Wert einer Variablen oder ein String (siehe echo).
"sowas" alles zwischen den Anführungszeichen wird wörtlich gemeint Zahlen für Rechenoperationen dürfen nicht angeführt werden, sie werden sonst zu Zeichen! Beim $Variablennamen in Gänsefüsschen wird deren Wert ausgegeben. |
| ' '
|
Einfache Anführungszeichen sind im String auch verwendbar.
Achtung, sie ersetzen aber $VariablenNamen nicht durch ihren Wert. Also Variablen in einfachen Anführungszeichen werden nicht geparst. |
| Mehr zu Anführungszeichen: | Strings ausgeben |
| ( )
if ($xyz < 444) echo "string"; 5 * (3 + 8) |
klammert Parameter/Teilausdrücke zusammen Siehe Funktion
(Bedingungen von if-Abfragen) Siehe Kontrollen Veränderung der Priorität von Operatoren |
| { }
if ($abc == true) { echo "string <br>"; print "string"; } |
klammert Anweisungen zu einem Block zusammen
Beachten: Die Bedingung und der Anweisungsblock werden nicht mit Semikolon abgeschlossen, sondern nur die einzelnen Anweisungen. Siehe Kontrollen und Funktion |
| ? | Anhängen einer Variablen an Link
oder als Teil eines PHP-Scripts, bei dessen Anfang <?php oder Ende ?> oder gefolgt von einem Doppelpunkt als ein Ternärer Operator ?: (siehe unten) |
| & | Anhängen einer zweiten und jeder weiteren Variablen an einen Link Siehe Variable an Seite |
| :
|
Alternative Schreibweise von Schleifen
an Stelle der geschweiften Klammern : für die öffnende Klammer Siehe Kontrollen |
| ->
:: |
Objekt-Operator
Bereichsauflösungsoperator (siehe bei Klassen weiter unten) |
| =
=~ ^ |
Zuordnungsoperator z.B. ordnet dem Namen einer Variablen einen Wert zu (siehe unten)
weiterer Operator nur in Perl; Siehe RegEx und preg_match() Anfang eines Strings in einer Regulären Expression (RegEx) |
Operatoren
Operatoren in PHP
| Zuweisungs- und Verkettungs- Operatoren | |
|---|---|
| = | Wertzuweisung zu einer Variablen |
| .= | Punkt vor = ist Erweiterung der Variablen
Eine zuvor benannte Variable wird durch den neuen Wert ergänzt. Ohne Punkt würde der Wert der Variablen überschrieben. Siehe Variablen |
| => | assoziative Schlüssel zuordnen Siehe Assoziative Arrays |
| .
$f = $f1 . $f2; $Adresse = $Str.", ".$Nr; |
Punkt
verkettet Strings und Variablen miteinander (In Javascript ist es das +) |
| ,
echo "string",$string; |
Komma
Aneinanderreiung: mehrere Anweisungs-Argumente trennen |
| Vergleichende Operatoren (geben immer 'true' oder 'false' aus) | |
| ==
|
ist gleich, vergleicht nur Werte nicht die Datentypen, 10 eier == 10 birnen ist 'true'
false == 0 ist auch 'true' |
| !=
|
ist ungleich
|
| ===
|
ist identisch, gibt 'false' aus wenn die Datentypen nicht auch noch übereinstimmen
false === 0 ist 'false' |
| <=
>= < > |
ist kleiner oder gleich
ist grösser oder gleich ist kleiner ist grösser |
| Mehr zu vergleichenden Operatoren bei Kontrollstrukturen: | if, else, switch Kontrollen |
| Logische Operatoren (verbinden Parameter z.B. if-Abfragen) | |
| &&
and |
und |
| ||
or |
oder |
| xor | entweder oder (nicht beides) |
| ! | nicht |
| Mehr zu logischen Operatoren bei Kontrollstrukturen: | if, else, switch Kontrollen |
| Ternärer Operator | |
| ? : | Verkürzt geschriebene if-else Abfrage |
| Mathematische Operatoren | |
| +
- * / % |
plus
minus multipliziert dividiert modolos, findet den Rest einer Division, 16 % 6 ist 4 , 16:6=2 Rest 4 |
| Mehr zu mathematischen Operatoren: | Zahlen |
| ++
$VarX = 1; $VarX = 1++; echo $X; |
Increment, erhöht einen Variablen-Wert um 1,
liefert die Ausgabe 2 |
| $VarX = 1;
echo ++$X; |
Achtung vorangestellt erfolgt die Erhöhung vor der Verarbeitung ...
liefert die Ausgabe 2 |
| $VarX = 1;
echo $X++; echo $X |
... hinten angehängt erfolgt die Erhöhung erst nach der Verarbeitung!
liefert hingegen zuerst die Ausgabe 1, erst dannach die Ausgabe 2 |
| -- | Decrement, verringert den Variablen-Wert um 1, wie oben |
| Mehr zu Inkrement und Dekrement: | Schleifen |
Datentypen
Datentypen in PHP
| Daten können diverse Eigenschaften haben welche einem Typ entsprechen. Z.B kann ein Wert auf 2 Stellen nach dem Komma definiert sein (double), oder als 'aus Buchstaben bestehend' (string) | |
| string | Zeichenkette. String |
| integer, int | Ganzzahlen. Mathe |
| float, double, real | Fliesskommazahlen |
| Object | Ein Bild, ein Sound, ein Video, eine Funktion ... |
| Array | Indexierte Variablenwerte |
| Boolean | TRUE oder FALSE |
| Resource | Resource dient dazu um Variablen zu definieren/identifizieren, die aus externen Datenquellen (Datenbanken) herangezogen werden |
| NULL | Null ist kein Wert, entspricht auch nicht dem Wert 0 oder dem Wert LEER, bei Null ist einfach nix vorhanden |
| mixed | gemischte Datentypen. Z.B. Strings und Zahlen gemischt |
| Den Typ finden und ändern | |
|---|---|
| Der Datentyp wird einer Variablen eigentlich automatisch mit ihrem Wert zugewiesen | |
| gettype($name); | gibt den Datentyp der Variablen $name aus |
| var_dump($name); | gibt nicht nur den Datentyp von Variablen (auch von Arrays und Objekten) aus, sondern auch noch deren Werte (und das ohne print Befehl). |
| $name = (int) $name; | Durch Casting den Datentyp einer Kopie der Variablen $name (zu integer) ändern
Es kann nur in die obersten 5 Datentypen geändert werden (string bis Array). |
| bool zu integer integer zu bool |
Bei der Umwandlung von Boolschen Werten in die Integer Werte entsteht aus
false eine 0 und aus true eine 1.
Umgekehrt entsteht aus einer 0 ein false und aus jeder anderen Zahl ein true.
Will ich Rückgabewerte von Funktionen ausgeben oder wiederverwenden, kann dies zu Fehlern führen, da das echo einer 0 ein leerer String ist! |
Variable
$variable in PHP
| $o
$Ywert |
Ein Variablenname begint konventionell immer mit einem Dollarzeichen. |
| Variablen sind sofort verwendbar, der Datentyp wird bei der Wertzuweisung automatisch festgelegt (nicht zuvor deklarieren) | |
| $name = "Marcel"; | Der Zuweisungsoperator des Wertes einer Variablen ist =
der Buchstabenwert kommt in Anführungszeichen daher |
| $name .= " Biefer"; | Die selbe Variable wird durch einen Punkt vor dem = erweitert |
| Wert zuweisen ohne Anführungszeichen | |
|---|---|
| $X = 10;
$Y = 2*$X; |
Soll mit dem Variablen-Wert gerechnet werden hat er keine Anführungszeichen |
| $Adresse = $Str.", ".$Nr; | Variablennamen müssen nicht in Anführungszeichen stehen, sie werden totzdem ausgegeben, hier steht nur das Komma (als String) in Anführungszeichen |
| $a = $b = 1000; | mehreren Variablen wird der gleiche Wert zugewiesen |
| Variablen nutzen mit doppelten " " oder einfachen ' ' | |
| $mo = "Montag";
echo "Ich komme $mo zurück."; echo 'Ich komme $mo zurück.'; |
Ausgabe mit " ": Ich komme Montag zurück. Ausgabe mit ' ' ersetzen $VariablenNamen nicht durch ihren Wert: Ich komme $mo zurück. |
| Ein String wird genau so ausgegeben wie getippt, wenn er in 'einfachen Anführungszeichen' steht. Das Script ist schnell, weil nicht geparst wird.
Variable oder Escape-Zeichen werden nur geparst in "doppelten Anführungszeichen". |
|
| Variable Variablennamen | |
| $varia="null"
$i=0; ${$varia.$i}; echo "$varia0"; $varia="eins" $i=1; echo "$varia1"; $varia="zwei" $i=2; echo "$$varia2"; |
|
| Mehr zu Variablen: | Variablen |
| Lokale und Globale Variable | |
| <?php
$globalevariable="Ich bin ausserhal von Funktionen nutzbar " $globalevariable .= "und veränderbar."; // und veränderbar |
Wird eine Variable ausserhalb von Funktionen, z.B gerade nach dem PHP Script-Tag definiert, ist sie zwar global gültig, aber kann noch nicht aus einer Funktionen heraus benutzt und verändert werden. |
| function beispiel() {
$lokalevariable="Ich bin nur in dieser Funktion gültig."; } |
Wird eine Variable in einer Funktion definiert, hat sie nur hier und jetzt Gültigkeit und kann nur hier verändert werden. Aus dieser Funktion heraus kann auch nicht ohne Weiteres auf die obige Variable zugegriffen werden ... |
| function DruckGlobalVar()
{ global $globalevariable; print $globalevariable; } DruckGlobalVar(); // Funktion wird aufgerufen |
mit dem Schlüsselwort 'global' kann eine sogenante globale Variable auch für eine Funktion globalisiert werden, sie ist dann auch aus dieser Funktion heraus nutzbar (und veränderbar!) |
| Mehr zu globalen Variablen: | Variable mit globalem Gültigkeitsbereich |
| An Link angehängte Variable | |
| <a href="empfaenger.php?x=555&y=super!">Go</a>
if ($_GET["x"]=="555") {
|
Variable durch Link übergeben: In einer Datei wird der href Tag mit Variablen "geimpft".
Die erste mit ? alle weiteren mit &
Die empfaenger.php gibt sie durch den Superglobalen array $_GET aus. |
| Variable auf anderer Seite nutzen: | Variable durch Link übergeben |
| Mit Variablen arbeiten | |
| isset(varname); | ist die Variable vorhanden?
|
| Mehr zu Variablen: | Variablen prüfen |
Array
$array in PHP
| $bezeichnung [index] = "eintrag";
$name [schlüssel] = "wert"; |
In einem Array sind mehrere VariablenWerte angeordnet, die unter einem gemeinsamen $Namen zusammengefasst sind, und einzeln durch ihren Index angesprochen werden. |
| [ ] | Wird beim Definieren des Arrays ein leerer Index angegeben, dann wird der Index automatisch in der Reihenfolge der Eingabe durchnummeriert, beginnend mit 0. Dies führt am wenigsten zu Fehlern. |
| $Tiere [0] = "Hahn";
$Tiere [1] = "Katze"; $Tiere [2] = "Hund"; $Tiere [3] = "Pferd"; $Tiere [4] = "Esel"; echo $Tiere [3]; |
Welches Tier war kein Bremer Stadtmusikant? |
| $Tiere = Array ("Hahn", "Katze", "Hund", "Pferd", "Esel") ;
echo $Tiere [3]; |
verkürzte Schreibweise mit automatischer Nummerierung.
Auch hier trägt das 4. Tier den Index 3 - weil bei 0 mit Zählen begonnen wird! |
| $Tiere = array (1 => "Katze", 4 => "Esel", 2 => "Hund", 3 => "Pferd", 0 => "Hahn",) ;
echo $Tiere [3]; |
die Indexzahl bei verkürzter Schreibweise
durch einen Pfeil => zuordnen |
| Mehr zu Arrays: | Numerische Arrays |
| $Tiere ["Ha"] = "Hahn";
$Tiere ["Ka"] = "Katze"; $Tiere ["Hu"] = "Hund"; $Tiere ["Pf"] = "Pferd"; $Tiere ["Es"] = "Esel"; echo $Tiere ["Pf"]; |
einen assoziativen Schlüssel statt Indexzahl zuordnen |
| $Tiere = array ("Ka" => "Katze", "Es" =>
"Esel", "Hu" => "Hund", "Pf" => "Pferd", "Ha" => "Hahn",) ;
echo $Tiere ["Pf"]; |
assoziative Schlüssel zuordnen in verkürzter Schreibweise |
| $bezeichnung [index] [index] = "wert" | und es gibt auch noch mehrdimensionale Arrays - die sind wie Tabellen.
mit 'Spalten' und 'Zeilen': |
| $Tiere ["Hu"] [0] = "Pudel" | |
| Mehr zu Arrays: | Assoziative Arrays |
| Mit Arrays arbeiten | |
|---|---|
| isset(varname);
if (isset($_SESSION["queue_file"])) { echo $_SESSION["queue_file"]; } |
ist die Variable vorhanden?
wenn die Sessionvariable queuefile vorhanden ist, dann gib sie aus (manche Befehle wie exec() erzeugen einen fatalen ERROR, wenn eine Variable nicht vorhanden ist, mit der sie etwas tun sollten.) |
| print_r($Arrayname);
<pre>print_r($Arrayname);</pre> $string=print_r($Arrayname, true); |
untersucht einen Array (oder auch eine Funktion) und gibt dessen Struktur aus.
In <pre>-Tags gesetzt bleibt die Struktur im Browser übersichtlich.
Die Ausgabe kann in eine Variable umgeleitet werden, folgt als zweites Argument TRUE, wird ein String daraus |
| array_push($Arrayname,"Wert","Wert"); | Einträge am Ende hinzufügen |
| array_pop($Arrayname); | Eintrag am Ende wegnehmen |
| array_unshift($Arrayname,"Wert","Wert"); | Einträge am Anfang hinzufügen |
| array_shift($Arrayname); | Eintrag am Anfang wegnehmen |
| array_search("Wert", $Arrayname); | Array durchsuchen, Wert finden |
| in_array("Wert",$Arayname); | Eintrag, abfragen |
| count($Arrayname);
sizeof($Arrayname); |
Einträge zählen
Version aus C++ |
| end($Arrayname); | gibt das letzte Element des Arrays zurück |
| list() | weist die einzelnen Einträge eines Arrays zu bestimmenden Variablen zu | each() | gibt immer den aktuellen Eintrag (Schlüssel-Wert-Paar) eines Arrays zurück und rückt den Zeiger um 1 weiter zum nächsten Eintrag. zum Schrittweisen durchgehen eines Arrays |
| reset() | rückt den Zeiger an den Anfang des Arrays, damit dieser erneut mit each() durchgegangen werden kann |
| foreach()
|
Schleife zum Durchlaufen eines Arrays, Siehe Array assoziativ |
| Arrays sortieren | |
| asort($Arrayname);
arsort($Arrayname); |
Einträge sortieren nach Einträgen - aufsteigend oder absteigend
'r' steht für rückwärts |
| ksort($Arrayname);
krsort($Arrayname); |
Einträge sortieren nach Indexes - aufsteigend oder absteigend
'k' steht für key |
| sort ($Arrayname, SORT_REGULAR);
sort ($Arrayname, SORT_NUMERIC); sort ($Arrayname, SORT_STRING); rsort(dito); |
Sortiert auch: normal
nach Zahlenwert alphbetisch alles auch absteigend |
Superglobale Variablen
$_SUPERGLOBAL in PHP
| echo "$Feldname"; | Formular Eingabe als Variable übergeben: Ein HTML Formular mit method = "get"
oder method = "post" empfängt eine Eingabe des Users und übergibt
diese als Feldname in einem Array an eine PHP-Datei <form action="datei.php" ...> welche die Eingabe ausgibt.
Früher wurde der Feldname (je nach php.ini register_globals 'yes') automatisch zu einer globalen Variablen und stand ohne weiteres so zur Verfügung als $Feldnahme. |
| $_GET["Feldname"];
$_POST["Feldname"]; $_REQUEST[]; |
Aus Sicherheitsgründen muss jetzt der Array eingelesen werden. Wenn nicht bekannt ist, ob das Formular mit HTTP-Methode 'get' oder 'post' verschickt wurde oder ob die Variable gar aus einem Cookie stammt, dann liest 'Request' alle drei Variablenübermittlungsarten. Wird kein Variablenname abgefragt [ ] lehre Klammern, dann stehen alle Variablen des Arrays zur Verfügung. |
| $Feldname = $_POST["Feldname"];
echo "$Feldname"; |
zur Ausgabe der Variablen $Feldname muss der Array also jetzt vorher eingelesen worden sein |
| echo $_POST["Feldname"]; | oder grad wärend dessen Ausgabe einlesen |
| $HTTP_GET_VARS['Feldname'];
|
veraltete (lange) Form des Einlesens
vor PHP 4.1.0 |
| Mehr: | zu GET, POST und REQUEST |
| $_SERVER[];
|
vom Server zur Verfügung gestellte Variablen
|
| $_SERVER['DOCUMENT_ROOT'] | Lokaler Pfad des Webservers zum Hauptverzeichnis |
| <a href="<?php echo $_SERVER['PHP_SELF'] ?>">Dieses Skript</a> | Ein Link der auf sich selber verweist (relativer Pfad vom Documentroot zum aktuellen Script) |
| <form action="<?php echo $_SERVER['PHP_SELF']; ?>"> | Affenformular: An Stelle einer Ziel-Datei kann das Formular seine eigene Adresse bestimmen und
sich somit selbst aufrufen und also selbst verarbeiten. Das Formular wird mit den letzten Eingaben dargestellt.
Formular mit Selbstbezug Formular für Sprachwechsel |
| $_SERVER['QUERY_STRING']
<a href="empfaenger.php?x=555&y=super!">Go</a> |
enthält den Query-String, also das, was einem Link hinter dem Fragezeichen mitgegeben wurde:
x=555&y=super!
|
| Mehr zu $_SERVER: | Pfadangaben |
| $_ENV[]; | Variablen die von der Shell-Umgebung gesetzt wurden
ENV = environement ~ Umgebung |
| $_FILES["varname"]; | Informationen über hochgeladene Datei: Bild hochladen |
| $GLOBALS[]; | ALLE mit dem aktuellen Script verbundenen global gültigen Variablen, auch die nicht selbst erstellten superglobalen Variablen. |
| Mehr zu Superglobalen: | Superglobale Variablen |
Konstante
KONSTANTE in PHP
| define("KONSTANTENNAME", "Wert");
define("KONSTANTENNAME", "Wert",true); |
Das Gegenteil von Variablen sind Konstanten, ihre Definition garantiert, dass sie immer nur den einen unveränderlichen Wert haben. KONSTANTENNAMEN werden traditionell immer gross geschrieben, wird als 3. Argument 'true' notiert, kommt es nicht mehr drauf an (fördert aber Fehler). |
| define("ICH", "Marcel");
print "Hallo ".ICH; |
Eine Konstante muss mit einem String verkettet werden, denn in Anführungszeichen würde sich die Konstante nicht vom String unterscheiden. |
| Mehr über Konstante: | Konstante |
| Magische Konstanten | |
|---|---|
| Es gibt 5 magische Konstanten. Konstanten enthalten normalerweise immer das selbe, die magischen auch, aber variabel in Abhängigkeit ihres Ortes. | |
| __LINE__
|
Zeilennummer des AKTUELLEN scriptes der mit include() eingebundenen Datei oder des laufenden Scripts
|
| __FILE__
|
Pfad und Dateinamen der mit include() eingebundenen Datei oder des laufenden Scripts. Dies ist identisch mit: $SERVER['DOCUMENT_ROOT'].$_SERVER['PHP_SELF'] |
| __FUNCTION__
__CLASS__ __METHOD__ |
namen der aktuellen Funktion (ab php 4.3.0)
namen der aktuellen Klasse (ab php 4.3.0) namen der aktuellen Klassenmethode (ab php 5) |
| echo ">>> ".basename(__FILE__)." ist der Name in welcher die magische Konstante steht."; | Beispiel |
| Mehr über Konstante: | Magische Konstante |
Werte
get_defined_*()
| Alle innerhalb des Zugriffsbereichs des Scriptes gültigen Variablen, Konstanten und Funktionen. dazu gehören die benutzerdefinierten Werte, aber auch die oben beschriebenen Superglobalen Variablen. | |
| get_defined_vars() |
Variablen:
<?php print_r(get_defined_vars()); ?>
oder etwas strukturierter: <?php
Ich verzichte hier auf die schier endlose Ausgabe. <?php
|
| get_defined_constants() | Konstanten |
| get_defined_functions() | Funktionen |
Cookie und Session
Cookie und Session in PHP
| Cookie | Ein Cookie (eigentlich eine Variable mit Wert) wird auf der Festplatte des Users gespeichert, im Browser können Cookies erlaubt oder verboten werden. Ein nicht gelöschtes und nicht abgelaufenes Cookie kann bei einem erneuten Seitenbesuch des Users wieder reaktiviert werden. |
| setcookie ("cookieName",$zuspeichernderWert,$endeGueltigkeit); | Ein Cookie schreiben |
| $cookieNamen=$_COOKIE[cookieNamen];
echo $cookieNamen; |
Eine Cookievariable lesen Kurz- bzw. neue Form (PHP 5)
zur Ausgabe der Variablen $cookieNamen muss der Array vorher eingelesen worden sein |
| $HTTP_COOKIE_VARS[cookieNamen]; | Eine Cookievariable lesen in veralteter Form (PHP 4) |
| Mehr zu Cookies: | Cookie |
|
Alternative zu Cookie:
Session |
Falls das Speichern von Cookies durch den Browser verhindert wird, können auch versteckte Formular-Felder zum Transport von Variablen verwendet werden; die bleiben jedoch nicht erhalten:
<input type = 'hidden' name = '<?php session_name(); ?> value = '<?php session_id(); ?>'>
|
| Session | Eine Session (Sitzung) wird auf dem Server gespeichert. Ich kann damit einzelne User voneinander unterscheiden und deren Variablen zwischenspeichern (z.B. Loggin, Wahrenkorb, etc.) |
| session_start(); | Eine Session fortsetzen oder beginnen. Dies muss vor jeglicher Ausgabe im Browser auf jeder neuen Seite geschehen! |
| session_id(); | gibt den 32Bit Schlüssel zurück. Die Session bleibt solange erhalten, bis der Browser geschlossen wird, solange bleibt auch die id die selbe. |
| session_save_path(); | Gibt einen alternativen Speicherort für eine laufende Session auf dem Server an, überschreibt die Direktive in der Datei php.ini. |
| session_name(); | Die Session wird benannt und kann so nachverfolgt werden. |
| $_SESSION['Variablename'] = "Variablenwert";
$Variablename = $_SESSION['Variablename'] echo "$Variablename"; |
So liest man eine Sessionvariable ein, der Wert einer so registrierten Variablen wird global und bleibt auch für Scripts auf anderen Seiten erhalten und einsetzbar. |
| unset($_SESSION['Variablename']); | Löschen einer SitzungsVariablen wie jede andere Variable. |
| $_SESSION = array(); | Löschen alle SitzungsVariablen durch überschreiben mit einem leeren Array. |
| session_destroy(); | beendet die Session auch ohne dass der Browser geschlossen werden muss |
| session_register("Variablenname"); | Veraltete Art eine Sessionvariable als global zu registrieren. |
| session_unregister("Variablenname"); | Auch veraltet. Löscht SitzungsVariable aus Arbeitsumgebung |
| Mehr zu Sessions: | Session In Kombination mit einem Loginformular. |
Bedingungen und Schleifen
Bedingungen und Schleifen in PHP
| if (gibt 'true' oder 'false' zurück) | |
|---|---|
| <?php
if(Bedingung) { Anweisung; } ?> |
Wenn die Bedingung TRUE ist, wird die Anweisung ausgeführt.
Bei nur einer Anweisung kann der Block - die geschweiften Klammern - auch weggelassen werden. Es ist möglich, nach dem ersten if einfach ein zeites if anzuhängen und dann ein drittes, etc., aber am Ende kann nicht mehr einfach ein else für die noch ungeprüften Fälle angehängt werden, denn das else bezieht sich nur auf das letzte if. Es müssten alle vorherigen Bedingungen aller if-Abfragen in einem letzten if noch einmal negativ abgefragt werden, etwa so: wenn nicht das und das und das, dann. (siehe elseif) |
| if - else | |
| <?php
if(Bedingung) { Anweisung; } else { Anweisung; } ?> |
Wenn die if-Bedingung TRUE ist, wird die Anweisung ausgeführt, ist sie FALSE
(nicht erfüllt), wird die else - Anweisung ausgeführt.
Bei else muss es für die Anweisung auch immer geschweifte Klammern haben! |
| elseif auch else if | |
| <?php
if(Bedingung) { Anweisung; } elseif { Anweisung; } else { Anweisung; } ?> |
beliebig vielen if Abfragen kann so ein einfaches else folgen! (siehe if) |
| if Abfrage mit Operatoren: und oder | |
| if (Gleichung1 Operator Gleichung2) {Anweisung} | Als Operator kommen and bzw. ++ (und), or bzw. || (oder) in Frage (siehe oben Operatoren). |
| if ($var1 == 'x' and $var1 != 'y') {echo $var1;} | In der einen runden Klammer stehen alle Bedingungen. |
| switch mit break | |
| <?php
switch ($Variable) { case Fall 1: Anweisung 1; break; case Fall 2: Anweisung 2; break; case Fall 3: Anweisung 3; break; default: Anweisung 4; } ?> |
Ein switch-Block kann statt mehrfachen if-Verzweigungen eingesetzt werden.
Beachte die Doppelpunkte! |
| ein break nach mehreren Bedingungen wirkt wie oder in der abfrage | |
| <?php
switch ($Variable) { case Fall 1: case Fall 2: case Fall 3: Anweisung 1; break; case Fall 4: Anweisung 2; break; default: Anweisung 3; } ?> |
|
| goto Label | |
| <?php
$count = 0; Sprungmarke2: $count = $count+1; if (10 > $count) { goto Sprungmarke2; } ?> |
Irgendwo im Code wird ein Label benannt,
welches durch einen Doppelpunkt gekennzeichnet ist.
Die if-Abfrage prüft, ob eine Bedingung gegeben ist und folgt dann der Anweisung,
zum Label zu springen. Das Label hat nur bei seiner Deklaration einen Doppelpunkt, in der Anweisung nicht.
Das Label kann oberhalb wie unterhalb der Anweisung stehen. Durch goto kann ich tief verschachtelte if-Abfragen vermeiden und aus Sackgassen raus finden oder Ersatz while-Schleifen basteln. goto gilt bei manchen Gurus als schlechter Stil, der zu Spaghetti-Code verleitet. |
| Mehr if, else und switch | Kontrolle |
| while-Schleife | |
| <?php
$i = 0; while ($i < 10) { echo "$i<br>\n"; ++$i } ?> |
Die while-Schleife prüft zuerst ob die Bedingung erfüllt ist, bevor sie die Anweisung ausführt.
Ist die Bedingung nicht erfüllt, macht sie gar nichts.
Wichtig: Innerhalb des Anweisungsblockes muss eine Veränderung der Ausgangsvariablen statt finden, sonst wird die Schlaufe endlos! |
| do - while-Schleife | |
| <?php
$i = 50; do { echo "$i<br>\n"; --$i } while ($i > 10); ?> |
Die do-while-Schleife befolgt zuerst die Anweisung bedingungslos und prüft erst danach,
ob die Bedingung für einen weiteren Durchgang erfüllt ist. Also einmal tut sie es mindestens.
Semikolon nicht vergessen. |
| for-Schleife | |
| <?php
for (Startwert; Bedingung; Veränderer) { Anweisung; } ?> |
mehrere Bedingungen für eine Anweisung |
| <?php
$Wert = 10; for ( ; $Wert <20; $Wert++) { Anweisung; } ?> |
Die for-Schleife wird nur verwendet, um etwas abzuzählen, um etwas so und so oft getan zu haben.
Zur Simulation, als ob $Wert aus einer Benutzereingabe stammt, wurde er ausserhalb der Klammer initialisiert. Auch einen der anderen Ausdrücke kann man leer lassen, wenn die Semikolon nicht vergessen werden. |
| for-Schleife mit break | |
| <?php
for (Startwert; Bedingung; Veränderer) { if (Bedingung2) {
|
sicherheitshalber wäre eine 'if'-Bedingung mit 'break'-Anweisung einzubauen, um eine Endlosschleife zu vermeiden. |
| foreach-Schleife (zum Arrays abarbeiten) | |
| <?php
foreach($Arrayname as $Index => $Wert) { echo $Index," ist ", $Wert, "<br>"; } ?> |
Die foreach-Schleife durchläuftfür jeden Eintrag eines Arrays eine Schleife, in der eine provisorische Variable kreiert wird, welche im nächsten Durchgang vom nächsten Eintrag überschrieben wird. Der Anweisungsblock innerhalb der Schleife beinhaltet z.B. einen Ausgabebefehl für die Variable. Somit kann eine Liste aller Einträge eines Arrays erstellt werden. |
| Schleifen unterbrechen | |
| break;
|
die Schleife und der Anweisungsblock werden verlassen
|
| continue; | die aktuelle Schleife wird abgebrochen aber die nächste Schleife eingeleitet, wie überspringen dieses Durchlaufs |
| ternärer Operator | |
| is_file( $file )?"":"k" | ternärer Operator |
| alternative Schreibweise | |
| <?php
if (Bedingung): Anweisungen; endif; ?> |
an Stelle der geschweiften Klammern kann für die öffnende Klammer ein Doppelpunkt gesetzt werden und für die schliessende Klammer je nach dem endif, endswitch, endwhile, endfor, endforeach gesetzt werden. |
| Mehr über Schleifen: | Schleife |
Funktionen
Funktion() in PHP
| Vorgegebene Funktionen in PHP | |
|---|---|
| Funktionen werden wie Baumaschinen zum Abarbeiten wiederkehrender Aufgaben in einem Script verwendet.
In PHP sind unzählige Funktionen vordefiniert, der Funktionsumfang ist enorm. PHP ist eigentlich eine Sammlung von Funktionen (PersonalHomePage Tools). |
|
| funktionsname("diesverwende","evmodus"); | Die Funktionen rufe ich (zur Arbeit) auf, indem ich ihren Namen nenne.
Der Name der Funktion steht immer vor einem Klammerpaar, darin sind Argumente angegeben, durch Kommas getrennt, z.B. worauf die Funktion angewendet werden soll, und ev. wie sie angewendet werden soll. Was die in PHP vordefinierten Funktionen genau machen, ist in keinem Anweisungsblock ersichtlich und was für Argumente eine Funktion erwartet muss man auch wissen oder in der umfangreichen Funktionsreferenz nachlesen. |
| $auffang=funktion("Argument");
return $auffang; |
Wird die Funktion von einer Variablen aufgerufen, kann man das Resultat der Variablen übergeben. |
| @funktion(); | Das @ vor dem Funktionsaufruf verhindert die Ausgabe einer Fehlermeldung |
| Eigene Funktionen erstellen | |
| Es ist auch möglich eigene Funktionen zu erstellen (z.B. am Anfang
eines Scripts oder sogar in einer externen Bibliothek).
Einmal definiert, sind auch diese eigenen Funktionen beliebig oft durch ihren
Namen aufrufbar.
Was die Funktion mit den Argumenten tut, wird in einem Anweisungsblock { in geschweiften Klammern } vorher bestimmt. Die runden Klammern müssen nach dem Funktionsnamen() auch dann notiert werden, wenn die Funktion keine Argumente benötigt. In den Klammern wird das Argument übernommen, welches beim Funktionsaufruf mitgegeben wurde, der Argumentname dient innerhalb der Funktion als Variable für den übergebenen Wert. Funktionen können ineinander verschachtelt werden, indem eine zweite Funktion in einem Anweisungsblock aufgerufen wird. Wenn eine Funktion endet, kann sie einen Wert an den aufrufenden Code zurücksenden. |
|
| function Funktionsname($arg1, $arg2)
{ Anweisung1 verarbeitet z.B. $arg1; $variableX = Resultat der Anweisung2; return $variableX; } |
Also zusammenfassend: Definition der eigenen Funktion durch das Schlüsselwort function und die Benennung
(Variablennamen für Argumente festlegen) { Funktionsanweisungsblöcke; return-Wert definieren; } |
| Funktion aufrufen | |
| $VariableY = Funktionsname("Wert1", "Wert2"); |
Aufruf der Funktion durch Funktionsname($Arg);
(in der Klammer die Argumente übergebenen, maximal soviele, wie in der Funktion vorgesehen) Die Variable vor dem Aufruf empfängt den Rückgabewert der Funktion. |
| Mehr zu Funktionen: | Funktion |
Klassen und Objekte
class Klasse und new Object in PHP
| Was ist eine Klasse? | |
|---|---|
| class Klassenname {...} | Eine Klasse ist wie eine Vorlage zur Erstellung von Objekten. Die Klasse beinhaltet Variablen und Funktionen welche die Eigenschaften und die Methoden der Objekte ausmachen. |
| class SheriffSternFabrik
{ public $color; // ohne Vorgabe public $size = "medium"; // mit Vorgabe private $rang; protected $points; public function funktionsname($empf) { $this->rang = $empf; } } |
Eine Klasse wird mit dem Schlüsselwort class deklariert.
In der Klasse werden Variablen und Funktionen erstellt. Die Variablen können bereits mit Werten vorbelegt werden, aber nur mit Zahlen, Strings, Boolean Werten oder Arrays, nicht mit Funktionen. Die Sichtbarkeit bzw. der Zugriff auf die Variablen (Eigenschaften) und auf die Funktionen (Methoden) in der Klasse von ausserhalb der Klasse, kann durch 'public' oder 'private' und 'protected' erlaubt oder verboten und eingeschränkt werden. |
| Was ist ein Objekt? | |
| Ein Objekt ist eine Instanz einer Klasse. | |
| $Objektname = new Klassenname;
Zum Beispiel: $Petersstern = new Sheriffsternfabrik; |
Durch die Anweisung 'new' wird aus einer Klasse ein 'Objekt' instantiiert. |
| Zugriff auf Objekt mit Objekt-Operator -> | |
| $Petersstern->color = "blau"; // färbt blau ein
echo $Petersstern->color; // gibt 'blau' aus |
public
Im angegebenen $Objekt greift der Operator -> auf public Eigenschaften und Methoden() zu. |
| In der Klasse: mit Pseudovariable $this auf das Objekt verweisen. | |
| $this->points = 5; |
private
'private' schützt vor dem Zugriff von ausserhalb der Klasse. Auf diese Eigenschaften und Methoden kann also nur innerhalb der Klasse zugegriffen werden. |
| protected
Auf 'protected' Eigenschaften und Methoden kann doch noch auch via vererbter Klassen zugegriffen werden. |
|
| Konstruktor und Destruktor | |
| function __construct() {...} | Ein Konstruktor (innerhalb der Klasse) beeinflusst das Objekt bei seiner Entstehung, er muss nicht aufgerufen werden und verarbeitet übergebene Werte (z.B. belegt eine Eigenschaft ID). |
| function __destruct() {...} | Ein Destruktor (auch in der Klasse deponiert) wirkt sich bei der Vernichtung also der End-Phase im Lebenszyklus eines Objektes aus. Der Destruktor schliesst z.B. eine Datenbankverbindung (am Ende des Scripts). |
| Klasse erweitern | |
| class neueklasse() extends alteklasse();
Zum Beispiel: class Weihnachtssternfabrik() extends Sheriffsternfabrik(); |
Eine neue Klasse kann aufbauend auf einer alten Klasse erzeugt werden.
Die neue Klasse erbt die Eigenschaften und Methoden der alten und wird mit
zusätzlichen ausgestattet.
Zum Beispiel benötigt ein Weihnachtsstern einen 'Schweiffff' und vor dem Namen den Prefix 'Sankt' oder 'Santa'. |
| altekleasse::eigenschaft alteklasse::methode() | Zugriff auf eine Eigenschaft oder Methode der Elternklasse (alteklasse) mit den doppelten Doppelpunkten (Bereichsauflösungs-Operator). |
| Mehr zur Klasse |
Ein Klasse Beispiel: Beispiel einer Klasse
Beispiel einer Klasse um Datei-Infos anzuzeigen. PHP hat auch eigene Klassen mit eigenen Eigenschaften und Methoden, z.B. >> DateTime(). |
Header
Header in PHP
| Kommunikation zwischen Server (Script) und Browser | |
|---|---|
|
header()
header_info.php |
Der Server schickt Informationen (einen Header) zwecks Vorverständigung an den Browser,
wann immer er etwas ausliefert, diese stehen ganz am Anfang der Lieferung (darum heisst das Header).
Ich kann aber auch absichtlich einen Header überschreiben.
Das funktioniert nur, wenn noch keine Lieferung an den Browser stattgefunden hat, wenn also der Header nicht bereits gesendet wurde! (nicht einmal ein Leerschlag darf ausgegeben worden sein). |
|
Zurückhalten
ob_start() ob_end_flush() |
Damit keine Ausgabe stattfindet, bevor ich willentlich die Lieferung versende, kann ich das 'Output Buffering' benutzen.
Einzelne Teile werden gepuffert (zurückgehalten) bis ich alles zusammengetragen habe und das in einem Rutsch absende (runterspühlen).
Dazu verwende ich die Methoden ob_start() und ob_end_flush().
Es gibt auch die Konfigurationsdirektive 'output_buffering', die in der php.ini bzw. in den Server-Konfigurationsdateien auf 'On' gesetzt werden könnte. |
| Statusmeldung | header("HTTP/1.0 404 Not Found"); // Statusmeldung |
| Cache unterbinden |
header("Cache-Control: no-cache, must-revalidate"); // HTTP/1.1
header("Expires: Mon, 26 Jul 1997 05:00:00 GMT"); // muss in der Vergangenheit liegen Sensible Daten wie Passwörter oder Kreditkartennummern sollten/dürfen nicht zwischen gespeichert werden. Das Cache Verhalten sollte mittels einer Session gesteuert werden: session_cache_limiter() |
| Browser umleiten
Redirect form |
<?php
header("Location: http://www.example.com/"); // absolute URI exit; ?> 'exit' stellt sicher, dass der nachfolgende Code nicht ausgefuehrt wird! Eine Session-ID wird nicht mit dem Location-Header übermittelt, sie muss also durch die Konstante SID hinzugefügt werden. |
| Download zum Speichern anbieten | // eine PDF Datei ausgeben:
header('Content-type: application/pdf'); // neuen Namen vorschlagen: header('Content-Disposition: attachment; filename="downloaded.pdf"'); // original Namen nennen: readfile('original.pdf'); |
| Headers zeigen
headers_list() headers_sent() |
headers_list() gibt ein numerisch indiziertes Array der Header zurück, die gesendet werden. headers_sent() zeigt an, ob diese Header bereits gesendet wurden. |
String ausgeben
"string" in PHP
| echo "Ausgabe"; | echo gibt den in Anführungszeichen gefassten String auf dem Bildschirm aus.
Dies ist eigentlich keine Funktion, und kommt ohne Parameter oder Konditionen aus und kann ohne Klammer genutzt werden. |
| echo "String <p>"; | HTML-Code kann einfach innerhalb des Strings verwendet werden. |
| echo "Hallo \"Lehrling\""; | Der Backslash Maskiert PHP-Sonderzeichen in einem String ab.
Soll etwas in Anführungszeichen ausgegeben werden, dann muss die besondere
Bedeutung von " zuerst so \" ungültig gemacht werden. Die Ausgabe ist: Hallo "Lehrling"
|
| echo "c:\\Programme\\xampp\\
php_sammlung\\echos.php"; |
Auch der Backslash selber kann ausgegeben werden,
\\ wird so \ ausgegeben (alles in einer Zeile!) |
| echo "bla<br>\n"; | erzeugt einen Zeilenumbruch im Source-Code |
| echo "$name";
echo '$name'; |
Doppelte Anführungszeichen geben den Wert der Variablen aus
Einfache Anführungszeichen geben den Variablennamen aus (ungeparst) |
| print "Ausgabe"; | gleich wie echo, gibt aber nicht nur Text aus, sondern gibt an eine aufrufende Variable einen String zurück |
| Mehr zur Textausgabe: | Textketten ausgeben
Mit HereDoc längere Texte ausgeben |
| printf()
printf ("%s", 123); printf ("%.2f", 123); |
erzeugt formatierte Daten - bestimt den Datentyp, meisst für Zahlen
gibt aus: 123 gibt aus: 123.00 |
| sprintf()
|
dito und liefert auch noch einen String zurück |
| String Funktionen | |
|---|---|
| trim(); ltrim(); rtrim();
stripslashes(); addslashes(); strip_tags(); strtoupper(); strtolower(); ucwords(); |
entfernt alle whitespaces vor und/oder nach dem Sting Text säubern
Backslasches werden löscht oder eingefügt entfernt unerwünschte HTML-Tags wandelt in GROSS/klein/Gross- Kleinschreibung um |
| nl2br();
|
Zeilenumbrüche in einer PHP Variablen (\n) in HTML konvertieren (NewLineToBRake). Diese Funktion funktioniert ev. nur vor, nicht mehr nach stripslashes(); Textumbruch |
| wordwrap(); | Wandelt eine lange Zeile in eine Spalte um. Die Spaltenbreite in Zeichen und die Art der Umbruchzeichen können angegeben werden. |
| strstr($String, "Teilstring"); | Filehandler geht dort hin, wo ein Teilstring (Wortlaut) in einem String aufgefunden wird. Gibt String ab dort zurück. |
| substr(); | Filehandler geht dort hin, wo er nach Massangabe (in Anzahl Zeichen) geschickt wird. Gibt String ab dort zurück. |
| str_replace();
substr_replace(); strtr(in,ausA,machO); |
suchen und ersetzen (Wortlaut)
suchen und ersetzen (Massangabe) einzelne Zeichen |
| strtok();
explode(); |
zerlegen eines Strings nach Zeichen, gibt Worte zurück
nach einem Wort, gibt Array zurück |
| void | Funktion ohne Rückgabewert |
| und mehr!!! | Suchen und Ersetzen im String |
| Reguläre Ausdrücke | |
| zur Bearbeitung von Strings, brauchen etwas mehr Zeit zum geparst werden | |
| preg_match("/hates/","hierdrinn"); | Regulärer Ausdruck in einem Sting oder Array suchen |
| preg_replace("replacepattern, replacemit, replacein"); | Regulärer Ausdruck suchen und ersetzen |
| preg_split("spliterer, daszusplitende"); | Mit einem Regulären Ausdruck einen String zerlegen |
| String in einer Variablen suchen und ersetzen (siehe str_replace() weiter oben).
Seit PHP 5.3 ist alles mit e-beginnend veraltet und sollte nicht mehr verwendet werden,
stattdessen sind die mit p-beginnenden Funktionen zu verwenden, welche mit Pearl-kompatiblen RegEx arbeiten.
Reguläre Expressions |
|
| Serialisieren in PHP | |
| serialize() | Wandelt Variablen, Arrays, Funktionen und überhaupt PHP Code in einen String um. Der String kann dann in eine Datei gespeichert werden. |
| file_put_contents("navSerial.php", serialize($navArray)); | Serialisieren ist sehr geeignet zum Auslagern einer Navigation in Form eines Arrays. |
| $navArray = unserialize(file_get_contents('navSerial.php')); | wieder unserialisieren und einlesen des serialisierten Arrays. |
|
$datei = fopen("navSerial.php","w");
fputs($datei,serialize($navArray)); fclose($datei); |
eine etwas altmodischere Variante, zum Speichern in einer Datei |
| $navArray = unserialize(implode('', file('navSerial.php'))); | und die dazugehörige altmodischere Variante, zum Einzulesen einer Datei |
|
$file=fopen("navSerial.php","w");
for ($idx=0;$idx fclose($file); |
auch das zeilenweise hineinschreiben eines numerischen Array geht komplizierter ohne serialize() |
| $navArray=file("navSerial.php"); | wo hingegen das zeilenweise holen einer Datei in einen Array einfach ist. |
Dateien
Datei schreiben in PHP
| require ("dateipfadname"); | greift auf eine Datei zu, bei Fehler wir das Script gestoppt.
So können Scripts (z.B. zentral gelagerte Pfadangaben, Variable und vor allem Funktionen) aus externen Bibliotheken vollständig eingebunden werden. Beim Einbinden einer zweiten Datei, wird diese dort einfach angehängt, die zweite Datei überschreibt nichts so, als würde auf eine andere Seite gewechselt). Enthält die eingebundene Datei allerdings Variablen gleichen Namens wie in der einbindenden Datei vorher schon vorhanden waren, gelten die neuen Variablen. |
| Am Anfang und Ende der eingebundenen Datei müssen PHP-Tags stehen, sonst wird der Inhalt auch ohne echo-Befehl auf dem Browser ausgegeben! | |
| include ("dateipfadname"); | Genau wie 'require', aber bei Fehlern wir das Script weiter geparst, es könnten einander mehrere Fehlermeldungen folgen. | Mehr include()/require() | Datei importieren |
| aus/in externen Dateien lesen/schreiben | |
| file_exists("pfadFilename") | Existiert dieses File? Gibt TRUE oder FALSE zurück
File Info |
| $fp = fopen ("pfadFilename","modus");
|
Um in eine Datei schreiben zu können, muss sie erst geöffnet oder
sogar erstellt werden.
In einer Variablen wird das zu bearbeitende File, der Bearbeitungs-Modus und die Cursorposition automatisch gespeichert. Nennen wir die Variable '$fh' den Filehandler oder '$fp' den Filepointer. Per Modus werden wichtige Parameter gesetzt:
a, a+, c, c+, r, r+, w, w+, x, x+ Die Modi werden tabellarisch auf der Seite Datei lesen verglichen, deren Auswirkungen werden im Detail auf der Seite Datei erstellen, ergänzen beschrieben. |
| Achtung: Die Dateien welche beschrieben werden -oder bei neu zu erstellender Datei, der Ordner in den die Datei geschrieben wird-, müssen immer gechmodet werden! | |
| fgets ($f, anzahlzeichen);
|
zeilenweise wo wird wieviel gelesen
|
| fwrite ($f, "String");
|
wo wird was geschrieben
|
| fputs($f,"String"); | wo wird was geschrieben |
| feof($f) | Wurde das Ende der Datei erreicht? Ist die Cursorposition am EndOfFile? |
| rewind ($f);
|
Cursor an den Dateianfang setzen
|
| fclose ($fh); | Die Datei in welcher der Filehandler steht muss immer geschlossen werden. |
| Mehr über Datei lesen/schreiben | Lesen und schreiben |
| unlink("Dateiname.end"); | löscht die Datei |
Check den Code.