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 |
| & | Anhängen weiterer Variablen an Link Siehe Variable an Seite |
| :
|
Alternative Schreibweise von Schleifen
an Stelle der geschweiften Klammern : für die öffnende Klammer Siehe Kontrollen |
| :: | Bereichsauflösungsoperator (siehe Klassen weiter unten) |
| Bisher noch nicht in der Lektüre aufgetaucht: | |
|---|---|
| =~
^ |
weiterer Operator nur in Perl; Siehe RegEx und preg_match()
? |
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'
|
| !=
|
ist ungleich
|
| ===
|
ist identisch, gibt 'false' aus wenn die Datentypen nicht auch noch übereinszimmen
|
| <=
>= < > |
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). |
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 Operator: entweder oder und | |
| 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! |
| switch ohne break | |
| <?php
switch ($Variable) { case Fall 1: case Fall 2: case Fall 3: Anweisung 1; break; case Fall 4: Anweisung 2; break; default: Anweisung 3; } ?> |
|
| Mehr if, else und switch | Kontrolle |
| while-Schleife | |
| <?php
$i = 0; while ($i < 10) { echo "$i<br>\n"; ++$i } ?> |
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); ?> |
Prüft die Bedingung erst nachdem Befolgen der Anweisung.
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
= 10 for ( ; $Wert <=20; $Wert++) { Anweisung; } ?> |
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 eine 'if'-Bedingung mit 'break'-Anweisung einbauen um die Endlosschleife zu vermeiden. |
| foreach-Schleife (zum Arrays abarbeiten) | |
| <?php
foreach($Arrayname as $Index => $Wert) { echo $Index," ist ", $Wert, "<br>"; } ?> |
Für jeden Eintrag eines Arrays wird eine Schleife durchlaufen in der eine provisorische Variable kreiert wird, welche im nächsten Durchgang vom nächsten Eintrag überschrieben wird. Der Anweisungsblock innerhalb der Schleife beinhaltet 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 |
| Mehr über Schleifen: | Schleife |
| alternative Schreibweisen | |
| is_file( $file )?"":"k" | ternärer Operator |
| <?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. |
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 | |
| function Funktionsname($argument1, $argument2) {
Anweisung1 verarbeitet $argument1; $variableX = Anweisung2; return $variableX; } |
Es ist auch möglich (z.B. am Anfang eines Scripts oder
sogar in einer externen Bibliothek) eigene Funktionen zu definieren um diese
später auf (Variablen) anzuwenden. Einmal definiert, sind auch diese eigenen
Funktionen beliebig oft durch ihren Namen(und die Argumente in Klammern) aufrufbar.
Was die Funktion tut, wird in einem Anweisungsblock { in geschweiften Klammern bestimmt }. Es können sogar Funktionen ineinander verschachtelt werden, indem eine zweite Funktion in einem Anweisungsblock augerufen wird. 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. Wenn eine Funktion endet, kann sie einen Wert an den aufrufenden Code zurücksenden. |
| Definition der eigenen Funktion durch das Schlüsselwort function und die Funktionsnamenvergabe
(Variablennamen für Argumente festlegen) { Funktionsanweisungsblöcke; returnwertdefinieren; } |
|
| $VariableY = Funktionsname("Wert1", "Wert2"); | Aufruf der Funktion durch Funktionsname(); Die Variable empfängt den Rückgabewert der Funktion. |
| Mehr zu Funktionen: | Funktion |
Klassen und Objekte
class Klasse und Objekte in PHP
| class Klassenname
{ public $varname1; public $varname2; function funktionsname() { Anweisungen; } } |
Eine Klasse wird deklariert
Eine Klasse fasst Variable und Funktionen zusammen. Variablen (Eigenschaften und Methoden) von Klassen müssen durch 'public' deklariert werden. Dadurch werden sie von ausserhalb der Klasse nutzbar. (In PHP 4 wurde dies durch 'var' bestimmt.) Werden sie als 'private' deklariert, kann hingegen nur innerhalb der Klasse auf sie zugegriffen werden und dies auch nur mittels Schlüsselwort $this. 'protected' erlaubt den Zugriff ohne $this von innerhalb der Klasse und vererbten Klassen. |
| class Klassenname
{ public $varname1; public $varname2; function Klassenname() { Anweisungen; } } |
Konstruktoren werden Funktionen genannt, welche den gleichen Namen haben wie die Klasse.
|
| class neueklasse extends alteklasse | Eine neue Klasse kann aufbauend auf einer alten Klasse deren Variablen erben |
| alteklasse::funktionsname() | die doppelten Doppelpunkte (Bereichsauflösungsoperator) lässt mich auf eine Funktion der Elternklasse (alteklasse) zugreiffen |
| $Objektname = new Klassenname; | Durch die Anweisung 'new' wird aus einer Klasse ein 'Objekt' instanziiert.
Variablen und Funktionen einer Klasse werden zu Eigenschaften und Methoden eines Objects.
Beispiel einer Klasse |
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_list() |
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'; |
gibt den Wert der Variablen aus
gibt den String $name aus |
| 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 |
| 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 werden.
In einer Variablen '$fp' wird das zu bearbeitende File, den Bearbeitungsmodus (siehe Tabelle unten) und automatisch die Cursorposition gespeichert. Nennen wir die Variable '$fh' den Filehandler oder '$fp' den Filepointer. Der Versuch eine nicht existierende Datei zu öffnen, kann je nach Mode eine neue Datei erstellen. Und je nach Mode wird eine bestehende Datei überschrieben! |
|||||||||||||||||||||||||||||||||||
|
||||||||||||||||||||||||||||||||||||
| 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.