PHP - Grundlagen - Einführung 1. Die Vorrausetzungen Ich hoffe, ihr habt es geschafft, einen entsprechenden Webserver für PHP und MySQL einzurichten. Wenn dem noch immer nicht der Fall sein sollte, so lest doch bitte erst mal die Einführung durch, insbesondere den Abschnitt Webserver. 2. Einbindung PHP kann auf unterschiedlichste Art und Weise mit stinknormalem HTML-Code kombiniert werden. Wichtig ist dabei nur, dass der PHP-Code speziell ausgezeichnet werden muss. Dabei gibt es mehrere Möglichkeiten, die aber zum Teil abhängig von der Server- Konfiguration sind. <? ... SMGL Style ... ?> -------------------------------------- <?PHP ... XML-Style 1 ... ?> -------------------------------------- <?php ... XML-Style 2 ... ?> -------------------------------------- <% ... ASP-Style ... %> -------------------------------------- <script language="php" runat="server"> ... ist mir auch neu ... </script> Ich persönlich habe sehr lange die erste Variante benutzt, weil sie die Schreibfaulen unterstützt. Allerdings hat man mich auf zwei Möglichkeiten aufmerksam gemacht, bei dem es zu Problemen kommen kann. Ersten könnte die Option short_open_tag in der php.ini auf Off stehen. Dann funktioniert die <?-Variante nicht mehr. Das zweite Problem kann in Kombination mit XML-Dokumenten auftreten, das Letztere ja gewöhnlich so anfangen: <?xml version="1.0" encoding="..." ?>. Darum werde ich ab sofort auch mit <?php arbeiten. Die letzten beiden habe ich ehrlich gesagt nie zu Gesicht bekommen. Wann ihr wie und wo euren PHP-Code einbaut, bleibt euch überlassen. 3. Kommentare Kommentare werden in PHP genau so eingebunden wie in C, C++ oder Java. Ein einzeiliger Kommentar beginnt mit zwei / also: <?php // Einzeiliger Kommentar ?> Ein mehrzeiliger Kommentar sieht so aus:
Transcript
PHP - Grundlagen - Einführung
1. Die Vorrausetzungen Ich hoffe, ihr habt es geschafft, einen entsprechenden Webserver für PHP und MySQL einzurichten. Wenn dem noch immer nicht der Fall sein sollte, so lest doch bitte erst mal die Einführung durch, insbesondere den Abschnitt Webserver.
2. Einbindung PHP kann auf unterschiedlichste Art und Weise mit stinknormalem HTML-Code kombiniert werden. Wichtig ist dabei nur, dass der PHP-Code speziell ausgezeichnet werden muss. Dabei gibt es mehrere Möglichkeiten, die aber zum Teil abhängig von der Server-Konfiguration sind.
<?
... SMGL Style ...
?>
--------------------------------------
<?PHP
... XML-Style 1 ...
?>
--------------------------------------
<?php
... XML-Style 2 ...
?>
--------------------------------------
<%
... ASP-Style ...
%>
--------------------------------------
<script language="php" runat="server">
... ist mir auch neu ...
</script>
Ich persönlich habe sehr lange die erste Variante benutzt, weil sie die Schreibfaulen unterstützt. Allerdings hat man mich auf zwei Möglichkeiten aufmerksam gemacht, bei dem es zu Problemen kommen kann. Ersten könnte die Option short_open_tag in der php.ini auf Off stehen. Dann funktioniert die <?-Variante nicht mehr. Das zweite Problem kann in Kombination mit XML-Dokumenten auftreten, das Letztere ja gewöhnlich so anfangen: <?xml version="1.0" encoding="..." ?>. Darum werde ich ab sofort auch mit <?php arbeiten. Die letzten beiden habe ich ehrlich gesagt nie zu Gesicht bekommen. Wann ihr wie und wo euren PHP-Code einbaut, bleibt euch überlassen.
3. Kommentare Kommentare werden in PHP genau so eingebunden wie in C, C++ oder Java. Ein einzeiliger Kommentar beginnt mit zwei / also:
<?php
// Einzeiliger Kommentar
?>
Ein mehrzeiliger Kommentar sieht so aus:
<?php
/* Hier kommt eim
mehrzeiliger Kommentar */
?>
4. Ausgaben Eine erste Form der Ausgabe habt ihr schon kennen gelernt. Es handelt sich um den Befehl echo. Dabei wird die Ausgabe an den Browser gesendet. Dazu aber später mehr, merkt euch erst mal nur echo.
PHP - Grundlagen - Variablen
1. Einführung In der Literatur (mein Gott ich höre mich an wie ein Professor) wird sehr oft der Begriff "Container" benutzt, um Variablen zu beschreiben. Man muss sich das so vorstellen. Wir haben ein Element, das wir mit beliebigen Inhalten füllen können, ähnlich eines Mülleimers, in den wir alles Mögliche hineinwerfen und wieder herausholen. Den Inhalt unseres "Mülleimers" nutzen wir dann, um den Ablauf unseres Programms zu steuern. Dabei können wir den Wert der Variable jederzeit ändern.
2. Schreibweise In PHP beginnt eine Variable grundsätzlich mit einem $-Zeichen. Als weitere Zeichen sind alle Buchstaben von A-Z erlaubt (achtet bitte auch hier auf die Groß- und Kleinschreibung) und die Zahlen von 0-9, sowie der Unterstrich (_). Wichtig dabei ist, dass nach dem $-Zeichen nur Buchstaben oder der Unterstrich kommen dürfen.
<?php
// Erlaubte Varianten
$blubb
$_bla
$schwall2
// Verboten
$1
$dum-didum
$kräh
?>
Achtet bei der Benamung darauf, dass sie eindeutig ist. Das bedeutet: benennt eure Variablen so, dass ihr auch in drei Monaten noch wisst, um was es sich dabei handelt.
<?php
// Empfohlen
$mein_name
$adresse
// Unsinn
$mn
$a
?>
3. Zuweisung Bleiben wir mal bei dem oben genannten Beispiel, um euch die Wirkungsweise von Variablen zu erklären. Also, ihr nehmt euch einen leeren Mülleimer und werft einen 10€-Schein hinein. Aus didaktischen Gründen denken wir uns das Euro mal weg. in PHP sähe das dann so aus:
<?php
$muelleimer = 10;
echo $muelleimer;
?>
Nun werfen wir noch einen 20€-Schein hinein und das sieht dann so aus:
<?php
$muelleimer = 10;
$muelleimer = $muelleimer + 20;
echo $muelleimer;
?>
Man kann das auch kürzer schreiben, und zwar so:
<?php
$muelleimer = 10;
$muelleimer += 20;
echo $muelleimer;
?>
Jetzt nehmen wir den 10€-Schein wieder heraus und werfen ein 50-Cent Stück hinein.
<?php
$muelleimer = 10;
$muelleimer = $muelleimer + 20;
$muelleimer = $muelleimer - 10 + 0.5;
echo $muelleimer;
// Alternative Schreibweise
$muelleimer = 10;
$muelleimer += 20;
$muelleimer -= 10;
$muelleimer += 0.5;
echo $muelleimer;
?>
Kleiner Hinweis, die Engländer und Amerikaner und Australier und der restliche anglophone Haufen benutzen einen Punkt anstelle eines Kommas, so wie es die zivilisierte Welt gewohnt ist.
4. "Variable" Variablen Des Öfteren kommt es vor, dass man den Wert einer Variable als Namen für eine weitere benutzen möchte. Nehmen wir mal an, ihr seid gaaaaanz doll besorgt um unsere Umwelt und habt keinen stinknormalen Mülleimer mehr. Stattdessen verfügt ihr über eine Biotonne, eine gelbe Tonne für Verpackungen, eine blaue Tonne für richtigen Abfall und hinten im Haus steht noch ein riesiger Karton für Papier. Und da ihr euren Müll je nach seiner Beschaffenheit in ein anderes Behältnis werfen wollt, müsst ihr in diesem Fall flexibel sein, also etwa so:
<?php
$behaeltnis = 'gelbe_tonne';
${$behaeltnis} = 20;
// entspricht einem $gelbe_tonne;
$behaeltnis = 'biotonne';
${$behaeltnis} = 30;
// entspricht einem $biotonne;
?>
So in etwa müsst ihr euch die Funktionsweise von "variablen" Variablen vorstellen. Aber obacht! die Variable ${$behaeltnis} existiert nur einmal! In obigem Beispiel würde einfach ausgedrückt, aus der Entsprechung $gelbe_tonne zum Schuss ein $biotonne.
5. Zurück zum Mülleimer So steckt nun euer 50-Cent wieder ein und werft eine Zigarettenschachtel hinein. Was haben wir jetzt, 20 Zigarettenschachteln? Schön wär's. Nein, wir haben folgendes: 20Zigarettenschachtel. Schaut mal in euren Mülleimer, es stimmt. Aber wie soll man nun dieses seltsame Konstrukt "20Zigarettenschachtel" erklären. Ganz einfach, Computer wissen ganz genau, was die 20 bedeutet, aber versucht mal so einem Blecheimer klarzumachen, was eine Zigarettenschachtel ist. Und damit kommen wir zu den verschiedenen Formen von Variablen.
PHP - Grundlagen - Typisierung
1. Einführung So bis jetzt haben wir gelernt, dass Variablen Mülleimer sind, in die wir unser sauer verdientes Geld und noch alles Mögliche hineinwerfen und herausholen können. Bleibt aber immer noch das Rätsel mit diesem "20Zigarettenschachtel". Zuerst haben wir ganz normale Berechnungen durchgeführt, wie wir es schon in der Grundschule gelernt haben. Und mit was rechnen wir, mit Zahlen.
2. Integer Ein Integer ist eine stinknormale Ganzzahl. Wenn ihr vor diese Zahl ein Minus-Zeichen setzt, habt ihr eine negative Ganzzahl. Letzteres gilt auch für folgendes.
3. Float Erinnert ihr euch beim dem Beispiel mit dem Mülleimer an die 50 Cent? Die habe ich als 0.5 notiert. Das ist eine Fließkommazahl. Bei Berechnungen beträgt die Genauigkeit 14 Stellen hinter dem Punkt (Komma). Versucht also bitte nicht, ein Programm in PHP zu schreiben, mit dem ihr eine Rakete zum Jupiter schicken wollt. Die fliegt mit ziemlicher Sicherheit daran vorbei und irrt anschließend im Sonnensystem umher.
4. String Endlich werde ich das Geheimnis um die Zigarettenschachtel lüften. Wie ich schon bemerkte, ist es extrem schwer, einem Computer zu erklären, was das ist (die KI-Forschung schlägt sich mit dem Problem schon seit Jahren herum). Darum wird alles, was keine Zahl ist, von PHP als so genannte Zeichenkette, also eine wilde Ansammlung von Buchstaben und Zahlen, interpretiert. Das bedeutet, dass ihr einen so genannten String habt, sobald auch nur irgendetwas in eurer Zuweisung keine Zahl ist. Ein String muss immer in Hochkommata (') oder einfache Anführungszeichen (") gesetzt werden, sonst weiß der PHP-Interpreter nicht, was ihr wollt, und wirft eine Fehlermeldung aus:
<?php
$test = 24; // Ganzzahl
$test = 10.5; // Fließkommazahl
$test = '134 Bla bla'; // Korrekter String
$test = "134 Bla bla"; // Korrekter String
$test = 134Blabla; // Fehler!
?>
Hochkommata/Anführungszeichen In PHP gibt es, wie schon gesagt, zwei Möglichkeiten, einen String zu kennzeichnen. Bei der Variante mit den Anführungszeichen könnt ihr zusätzlich Variablen in die Zeichenkette einbinden, bei den Hochkommata nicht:
<?php
$variable = 25;
$test = "ich habe $variable Euro";
echo $test;
/* Ergebnis: Ich habe 25 Euro */
$variable = 25;
$test = 'ich habe $variable Euro';
echo $test;
/* Ergebnis: Ich habe $variable Euro */
?>
5. Umwandlung Was passiert nun, wenn unterschiedliche Variablen miteinander verknüpft werden, oder eine Berechnung von zwei Ganzzahlen eine Fließkommazahl ergibt? Ganz einfach, die Konvertierung wird vom Interpreter übernommen. Daher gehört PHP auch zu den so genannten schwach bzw. dynamisch getypten Sprachen, wo die entsprechende Konvertierung automatisch vorgenommen wird. Ein paar Beispiele:
• Integer plus Float = Float
• Integer geteilt durch Float = Float (wenn kein Integer)
• Integer plus String = String
• Float plus String = String
• Integer geteilt durch String = Müll/Fehlermeldung
6. Boolsche Variablen Diese Variante geht auf den englischen Mathematikprofessor George Boole zurück, der Mitte des 19. Jahrhunderts mit seinen Theorien die moderne mathematische Logik begründete. Diese Variablen sind einfach ausgedrückt das Ergebnis einer logischen Operation und kennen zwei Werte: TRUE und FALSE. Zu den Details komme ich später.
PHP - Grundlagen - Operatoren
Operatoren sind dazu da, Variablen Werte zuzuweisen, sinnvoll miteinander zu verbinden oder zu vergleichen. Dabei gibt es verschiedene Formen.
1. Zuweisungsoperator Den kennen wir schon, das ist das Gleichheitszeichen, damit weisen wir einer Variablen einen Wert zu:
<?php
$nummer = 5;
$zeichen = 'Blubb Blubber';
?>
2. Mathematische Operatoren Die kennen wir aus unserem Mathematikunterricht, nur die Schreibweise ist teilweise anders:
<?php
$a + $b // Plus
$a - $b // Minus
$a * $b // Mal
$a / $b // Geteilt
$a % $b // Modulo
?>
Rechenregeln Hier gilt das alte Prinzip, Punkt-Rechnung geht vor Strich-Rechnung. Also Mal und Geteilt kommen vor Plus und Minus. Wer das nicht begriffen hat, ist hier Fehl am Platze und sollte sich besser da aufhalten.
<?php
$a = 50;
$b = 30;
$c = 10;
$rechnen = $a * $b + $c;
// Ergibt 1510
$rechnen = $a * ($b + $c);
// Ergibt 2000
?>
Modulo Klingt im Moment ein wenig irritierend, ist aber einfach zu erklären. Es muss in der Grundschule gewesen sein, da habe ich folgendes gelernt: 6 geteilt durch 4 ist 1 Rest 2. Und dieser Rest, also 2, ist der Modulo-Wert.
3. Inkrement- und Dekrementoperatoren Diese Operatoren stellen nur eine verkürzte und spezielle Form der mathematischen Operatoren + und - um den Faktor 1 dar. Dabei gibt es folgende Varianten: Prä-Inkrement Erhöht erst(!) $a um 1 und gibt dann den neuen Wert aus.
<?php
++$a;
?>
Post-Inkrement Gibt erst den Wert von $a aus und erhöht ihn dann(!) um 1.
<?php
$a++;
?>
Prä-Dekrement Vermindert erst(!) $a um 1 und gibt dann den neuen Wert aus.
<?php
--$a;
?>
Post-Dekrement Gibt erst den Wert von $a aus und vermindert ihn dann(!) um 1.
<?php
$a--;
?>
4. Verknüpfungsoperator Den brauchen wir, um Zeichenketten miteinander zu verbinden. Im Falle von PHP handelt es sich dabei um den Punkt, also zum Beispiel:
<?php
$vorname = 'Peter';
$nachname = 'Kropff';
echo 'Ich bin '.$vorname.' '.$nachname;
?>
Man könnte es auch so schreiben, aber dann bräuchten wir den Verknüpfungsoperator nicht mehr. Ein Tipp, gewöhnt euch die obere Schreibweise an, dann habt ihr weniger Probleme (siehe Zeichenketten).
<?php
$vorname = 'Peter';
$nachname = 'Kropff';
echo "Ich bin $vorname $nachname";
?>
Alternative Schreibweise Man kann das auch der Übersichtlichkeit halber über mehrere Zeilen hinweg kombinieren:
<?php
$string = 'Ich bin ein gaaaaaaaaaaanz langer String.';
$string .= 'und ich bin ein kurzer String';
$string .= 'Ich bin auch ein gaaaaaaaaaaanz langer String';
echo $string;
?>
5. Vergleichsoperatoren Werden bei Bedingungen benötigt. Dabei erfolgt ein Vergleich und als Ergebnis wird eine Boolsche Variable zurückgeliefert. Es gibt unter Anderem folgende Möglichkeiten:
<?php
$a == $b // Logisches Gleich
$a != $b // Logisches Ungleich
$a > $b // Größer als
$a < $b // Kleiner als
$a >= $b // Logisches Größer-Gleich
$a <= $b // Logisches Kleiner-Gleich
// Vergleiche auf Binär-Ebene
$a === $b // Bitweises Gleich
$a !== $b // Bitweises Ungleich
?>
6. Logische Operatoren Definieren Bedingungen, bei denen wieder mal Boolsche Variablen als Ergebnis zurückgegeben werden.
<?php
$a && $b // Logisches UND
$a || $b // Logisches ODER
!$a // Logisches NICHT
$a // Logisches JA
?>
Die Details zu den logischen Operatoren erfahrt ihr bei den Bedingungen.
PHP - Grundlagen - Konstanten
1. Einführung Konstanten stellen eine ganz spezielle Form von Variablen dar und unterscheiden sich von denen durch folgende Eigenschaften:
• Konstanten beginnen NICHT mit einem $-Zeichen
• Konstanten müssen mit dem Befehl define definiert werden
• Bei der Definition muss direkt ein Wert zugewiesen werden
• Konstanten können nicht gelöscht werden
• Der Wert einer Konstante kann nicht geändert werden
• Konstanten sind globale Variablen, auf ihren Inhalt kann man immer und überall zugreifen
2. Schreibweise Eine Gemeinsamkeit haben die Konstanten mit den Variablen. Es gelten dieselben Regeln bei der Schreibweise, das $-Zeichen klammern wir mal aus. Erlaubt sind alle Buchstaben von A-Z, Zahlen sowie der Binde- und Unterstrich. Das erste Zeichen muss ein Buchstabe oder der Unterstrich sein. Es hat sich eingebürgert, Konstanten immer groß zu schreiben. Wenn ihr das nicht wollt, so achtet auf die Groß- und Kleinschreibung.
3. Definition und Zuweisung Wie schon beschrieben werden Konstanten mit dem Befehl define erzeugt. Der erste Parameter legt den Namen fest, der in Hochkommata oder Anführungszeichen eingeschlossen sein muss. Der zweite Wert liefert den Inhalt. Bei der Zuweisung des Wertes gelten dieselben Regeln wie bei Variablen.
<?php
define("KONSTANTE", 'Hallöle');
echo KONSTANTE;
define('CONST_WERT', 20);
echo CONST_WERT;
define("BOOL", TRUE);
echo BOOL;
?>
4. Einsatzmöglichkeiten Nun werdet ihr euch sicher fragen, wozu man solche Konstanten überhaupt gebrauchen kann. Sie müssen extra definiert werden, sie können nicht geändert werden und Alles in Allem scheint es, dass die Arbeit mit Konstanten sehr unflexibel ist. Ich will euch die Vorteile mal an einem Beispiel erläutern.
"Das Schwierigste am Programmieren ist, sich ständig vernünftige Namen für Variablen einfallen zu lassen." [Quelle: Ich in einem Beitrag im Forum von PHP-Resource]
Aus dem obigen Zitat könnt ihr vielleicht schon erahnen, wieso man Konstanten einsetzt. Nehmt mal an, wir programmieren einen Online-Shop, wo die Mehrwertsteuer zusätzlich zum Preis aufgeschlagen wird. Dafür haben wir dann zwei Variablen, $preis und $mwst. Daraus ergibt sich dann der Gesamtpreis:
<?php
// Irgendwo im Code
$mwst = 0.19;
// Woanders im Code
$preis = 24.5;
$gesamt = $preis + ($preis * $mwst);
?>
Was aber, wenn wir irgendwo in unseren 5.000 Zeilen aus Versehen den ursprünglichen Wert der Variable $mwst mit etwas anderem überschrieben haben, also zum Beispiel in Zeile 581 der Datei xyz.php $mwst = $irgendeine_zahl? Genau, dann haben wir ein Problem. Also legen wir die Mehrwertsteuer nicht in einer Variable fest, sondern in einer Konstanten, dann kann uns so was nicht passieren.
<?php
// Irgendwo im Code
define ('MWST', 0.19);
// Woanders im Code
$preis = 24.5;
$gesamt = $preis + ($preis * MWST);
?>
Wenn man zum Beispiel nur mit einer Datenbank arbeitet, so empfiehlt es sich, bei den Zugangsdaten ebenfalls mit Konstanten zu arbeiten.
5. Vordefinierte Konstanten Innerhalb von PHP gibt es bereits vordefinierte Konstanten. Ich möchte hier erst mal nur zwei aufführen, die euch die Arbeit erheblich erleichtern können. __FILE___ Gibt den Namen der aktuell verwendeten Datei aus. E_ALL Ist Teil des error_reporting()-"Befehls", und gibt Fehlermeldungen, Warnungen und Hinweise aus. Ist hervorragend(!) für die Beseitigung von Problemen geeignet. Legt also am Beginn eines Projektes in einer zentralen Datei folgendes fest:
<?php
error_reporting (E_ALL);
?>
Wenn ihr dann das Projekt online stellt, könnt ihr diese Zeile auskommentieren.
PHP - Grundlagen - Arrays Teil 1
1. Einführung Drei Kapitel zu einem Thema, das ist sonderbar, ... oder wichtig. In diesem Fall sehr, sehr wichtig! Arrays erleichtern die Programmierung ungemein. Sie helfen uns, unseren Code besser zu strukturieren und organisieren. Man kann mit ihnen sogar ganze Anwendungen steuern. Also lest euch das Folgende genau(!) durch, wenn ihr diesen Punkt nicht versteht, braucht ihr eigentlich gar nicht mehr weiter zu machen.
2. Das Problem Nehmen wir einfach mal an, dass wir eine Anwendung programmieren, in der wir Namen abspeichern müssen. Das könnte man dann so machen:
<?php
$name_1 = 'Claudia Mustermann';
$name_2 = 'Dieter Hinz';
$name_3 = 'Peter Kunz';
?>
Sieht ziemlich unkomfortabel aus und ist es auch. Irgendwann sind wir bei $name_541 und verlieren komplett den Überblick. Um dieses Problem zu vermeiden, arbeitet man stattdessen mit Arrays. Das sind Variablen, in denen man mehrere Werte abspeichern kann.
3. Schreibweise/Syntax Bei der Schreibweise gelten dieselben Regeln wie bei den Variablen. Zusätzlich wird ein so genannter Index angelegt, mit dem man Zugriff auf einzelne Werte hat. Diesen setzt man in eckige Klammern. Das Schema sieht dann folgendermaßen aus:
variablenname[index] = variablenwert
Gibt man beim Index nicht explizit etwas an, so nummeriert PHP den Index einfach von 0 bis Irgendwas durch. Das obige Beispiel könnte man also folgendermaßen schreiben.
<?php
$name[] = 'Claudia Mustermann';
$name[] = 'Dieter Hinz';
$name[] = 'Peter Kunz';
?>
4. Varianten Aus der Art und Weise, wie der Index definiert oder nicht definiert wird, unterscheidet man verschiedene Varianten, die auch kombiniert werden können.
• Eindimensionale Arrays
• Mehrdimensionale Arrays
• Assoziative Arrays
PHP - Grundlagen - Arrays Teil 2
1. Eindimensionale Arrays Im ersten Teil haben wir schon ein Beispiel für ein eindimensionales Array kennen gelernt. Zum besseren Verständnis setzen wir diesmal einen numerischen Index und geben die Inhalte aus:
<?php
$name[0] = 'Claudia Mustermann';
$name[1] = 'Dieter Hinz';
$name[2] = 'Peter Kunz';
echo $name[0].'<br>';
echo $name[1].'<br>';
echo $name[2].'<br>';
?>
alternative Schreibweise Gottlob gibt es eine verkürzte Schreibweise. Dazu benutzt man den Befehl array. Das obige Beispiel könnte man auch so schreiben:
<?php
$name = array (
'Claudia Mustermann',
'Dieter Hinz',
'Peter Kunz'
);
?>
Was aber, wenn wir weitere Informationen abspeichern wollen, wie zum Beispiel die Mail-Adresse? Ein zweites Array anlegen und darin die E-Mails abspeichern? Wohl kaum, dann haben wir bald ein ähnliches Variablen-Chaos, wie beim vorherigen Abschnitt beschrieben.
2. Mehrdimensionale Arrays Wollen wir nun zum Namen auch noch die Mail-Adresse abspeichern, so erweitern wir das Array um eine zusätzliche Ebene.
Was zum Teufel haben wir denn jetzt gemacht? Ganz einfach, wir haben drei Arrays angelegt, die wiederum auch Arrays sind. $name[0] beinhaltet die Daten von Frau Mustermann (wieso eigentlich mann?), $name[1] die von Herrn Hinz und $name[2] die von Herrn Kunz. Auf der zweiten Ebene werden nun die Inhalte unterteilt in den Namen [0] und die E-Mail [1]. Es wäre jetzt ein Leichtes, noch ein Element hinzuzufügen, zum Beispiel die Straße:
Allerdings hat die Sache einen Haken. Um die einzelnen Werte der zweiten Ebene auszulesen, muss man die genaue Reihenfolge kennen. Das ist im Moment noch zu bewältigen, aber bei vielen zusätzlichen Elementen in der zweiten Ebene verliert man sehr schnell den Überblick. 3. Assoziative Arrays Um diesem Problem aus dem Weg zu gehen, nimmt man anstelle der nackten und wenig aussagekräftigen Zahlen eine Beschreibung innerhalb des Indexes.
Erstaunlicherweise darf man bei der Benamung dieser Indizes so ziemlich alles machen, was man will. Es gibt keinerlei Beschränkungen, wie Umlaute, Sonder- oder Leerzeichen. Selbst ein Array wie das Folgende ist erlaubt:
<?php
$moi['Ich bin der Größte und der Schönste'] = 'Peter Kropff';
?>
Will man nun eine kleine Adressdatenbank aufbauen so könnte man ein mehrdimensionales, assoziatives Array aufbauen:
4. Verständnis Das alles klingt jetzt ein wenig kompliziert und viele haben Probleme, Arrays und ihr Konzept zu verstehen. Aber wir alle arbeiten tagtäglich damit, ohne dass es uns bewusst ist. Ein Beispiel? Wir gehen samstags abends in eines dieser Riesen-Kinos. Irgendwann sitzen wir in "Kino 12", "Reihe 7", "Platz 8". Dämmert es?
<?php
$multiplex[12][7][8] = 'Mein Platz';
?>
Oder in einem Parkhaus, 2. Etage, Abschnitt A, Platz Nr. 24.
<?php
$parkhaus[2]['A'][24] = 'Mein Auto';
?>
Ein paar kleine Beispiele zur Verarbeitung von Arrays findet ihr bei den Schleifen.
PHP - Grundlagen - Arrays Teil 3
1. Globale Arrays Neben den Arrays, die wir selber definieren können, stellt uns PHP noch ein paar globale (oft auch als superglobale bezeichnete) Arrays zur Verfügung, auf die wir jederzeit zugreifen können. Ich werde euch hier nur ein paar von denen vorstellen, und auch nicht in allen Details.
2. $_SERVER Liefert uns "systemnahe" Auskünfte über den Server und den Client des Betrachters sowie einige zusätzliche Funktionalitäten. Allerdings kann es Einschränkungen durch die Konfiguration des Webservers geben. Alle folgenden Varianten werden so geschrieben: $_SERVER[variante]. Serverausgaben
• SERVER_ADDR gibt die IP-Adresse des Servers wieder
• SERVER_PORT Standardport für das HTTP-Protokoll
• DOCUMENT_ROOT Wurzelverzeichnis der Domain
• SCRIPT_FILENAME Pfad und Name der aktuellen PHP-Datei
• SERVER_PROTOCOL Angabe der Versionsnummer des HTTP-Protokolls
• PHP_SELF Ruft die aktuelle Seite noch einmal auf (sehr nützlich!) Clientausgaben
• REMOTE_ADDR gibt die IP-Adresse des Clients wieder
• HTTP_USER_AGENT gibt den Browser des Clients wieder WARNUNG! Diese Angaben müssen nicht den Tatsachen entsprechen. Sitzen zum Beispiel 10 Personen hinter derselben Firewall, so wird für alle dieselbe IP angegeben.
<?php
$_SERVER['SERVER_ADDR']
$_SERVER['PHP_SELF']
$_SERVER['REMOTE_ADDR']
?>
3. $_POST Gibt alle Inhalte eines Formulars aus, das mit method="post" versendet wurde.
4. $_GET Gibt alle Inhalte eines Formulars aus, das mit method="get" versendet wurde, oder listet alle Parameter einer URL auf, also zum Beispiel;
<?php
// blubb.php
<a href="bla.php?id=1&blubb=blubber">
// bla.php
echo $_GET['id']; // Gibt 1 aus
echo $_GET['blubb']; // Gibt blubber aus
?>
5. $_SESSION Speichert alle Inhalte, die in eine Session geschrieben werden, dazu später mehr.
6. $_COOKIE Speichert alle Inhalte, die in ein Cookie geschrieben werden.
7. Testausgabe Sollte es beim Einsatz von Arrays zu Problemen oder Fehlern kommen, hilft eine einfache Ausgabe sehr schnell weiter, print_r(...).
<?php
print_r ($arrayname);
print_r ($_SERVER);
print_r ($_POST);
print_r ($_GET);
print_r ($_SESSION);
?>
Damit wird der komplette Inhalt inklusive aller Indizes ausgegeben. Ein wirklich sehr praktischer Befehl, der das Programmieren wirklich erleichtert.
PHP - Grundlagen - Bedingungen
1. Einführung Bedingungen, oder auch Kontrollstrukturen genannt, steuern den Ablauf eines Programms. Dazu benötigen wir die Vergleichs- und logischen Operatoren, aus denen sich die Abfolge ergibt. Achtet bitte immer(!) darauf, dass der Gleichheitsoperator nicht wie in der Schule das normale sondern das doppelte (==) Gleichheitszeichen ist.
2. if Die if-Bedingung stellt die einfachste Form von Kontrollstruktur dar. Man definiert eine Bedingung und wenn die wahr ist, so wird die folgende Anweisung ausgeführt. Das Schema ist ganz einfach:
if (bedingung ist wahr)
{
tu dies;
}
Die entsprechende Syntax dazu sieht wie in den folgenden Beispielen aus.
<?php
if ($a == $b) // True, wenn $a gleich $b
if ($a != $b) // True, wenn $a ungleich $b
if ($a > $b) // True, wenn $a größer $b
if ($a < $b) // True, wenn $a kleiner $b
if (!$a) // True, wenn $a false, 0 oder nichts ist
if ($a) // True, wenn $a nicht false, nicht 0
// oder nicht nichts ist
?>
Man kann auch Bedingungen mit logischen Verknüpfungen aufstellen:
<?php
/* True, wenn $a größer $b ist
UND $c false, 0 oder nichts */
if ($a > $b && !$c)
/* True, wenn $a größer/gleich $b ist
ODER $b ungleich $c */
if ($a >= $b || $b != $c)
?>
3. if ... else if ... else Dieses Konstrukt ist eine erweiterte Form der einfachen if-Bedingung. Hier können zusätzliche Bedingungen festgelegt werden.
<?php
if ($a > $b)
{
echo $a.' ist größer als '.$b;
}
else if ($a == $b)
{
echo $a.' ist genauso groß wie '.$b;
}
else if ($a < $b)
{
echo $a.' ist kleiner als '.$b;
}
else
{
echo 'Hier passt garnichts';
}
?>
4. Trinitätsoperator Der so genannte Trinitätsoperator ist nur eine verkürzte Schreibweise einer einfachen if-else-Bedingung.
<?php
if ($a == $b)
{
$c = $a;
}
else
{
$c = $b;
}
// Schreibweise als Trinitätsoperator
($a == $b) ? $c = $a : $c = $b;
?>
Aufbau
• 1. Bedingung ohne if
• 2. ein Fragezeichen
• 3. dann die Anweisung, wenn die Bedingung wahr ist
• 4. ein Doppelpunkt
• 5. dann die Anweisung, wenn die Bedingung falsch ist
5. switch ... case Die Möglichkeit bietet sich vor allem bei vielen, vielen Überprüfungen einer(!) Variable an. Man verwendet sie an Stelle von zig else-if-Monstern. Es gibt dabei diverse Möglichkeiten, auf die ich aber erst in den Tutorials eingehe. Für den Anfang sollte dies reichen.
<?php
switch ($a)
{
case 1: echo '$a ist 1';
break;
case 2: echo '$a ist 2';
break;
case 3: echo '$a ist 3';
break;
default: echo '$a ist weder 1, noch 2, noch 3';
}
?>
PHP - Grundlagen - Schleifen
1. Einführung Schleifen werden dann eingesetzt, um einen bestimmten Programmierteil mehrmals zu durchlaufen. Dabei können Variablenwerte flexibel geändert werden. Besonders wichtige Anwendungsgebiete sind Arrays (da war doch was?) und Datenbankabfragen (da kommt noch was).
2. for-Schleife Die for-Schleife stellt meiner Meinung nach die verständlichste und klarste Form dar. Deshalb benutze ich sie wahrscheinlich auch, wo ich nur kann. Sie sollte dann eingesetzt werden, wenn uns alle notwendigen Parameter bekannt sind. Ich nenne diese Form daher einfach mal "bestimmte" Schleife. Der Aufbau sieht wie folgt aus:
for ([Ausgangssituation]; [Bedingung]; [Anweisung])
Das folgende Beispiel gibt einfach die Zahlen von 0 - 9 aus:
<?php
for ($i = 0; $i < 10; $i++)
{
echo $i.'<br>';
}
?>
Erinnert ihr euch noch beim Thema Arrays Teil 2 an das erste Beispiel? Nun, so etwas kann man wunderbar mit einer for-Schleife abarbeiten:
<?php
$name[0] = 'Claudia Mustermann';
$name[1] = 'Dieter Hinz';
$name[2] = 'Peter Kunz';
for ($i = 0; $i < count ($name); $i++)
{
echo ($i + 1).' '.$name[$i].'<br>';
}
?>
Wichtig ist hierbei der Befehl count. Er gibt die Anzahl der Array-Einträge wieder, also in unserem Fall 3. Das erklärt auch, warum der erste numerische Index eines Arrays immer den Wert 0 hat. Denn count ist immer um 1 größer, als der letzte numerische Index. Alternativ kann man auch sizeof benutzen, das ist das Selbe in grün.
3. while-Schleife Die while-Schleife stellt die einfachste Form dar. Sie wird solange ausgeführt, wie eine Bedingung wahr ist. Ich nenne sie daher eine "unbestimmte" Schleife, da man nicht weiß, wann sie abgebrochen wird. Die Syntax baut sich so auf:
while ([Bedingung])
Dieser Typ eignet sich besonders in Verbindung mit Datenbanken, wo die Zahl der ausgegeben Datensätze entsprechend einer Abfrage unbekannt ist. Ein anderes Gebiet der while-Schleife ist das zeilenweise Auslesen von Text-Dateien. Die folgenden Beispiele sind natürlich nicht funktionsfähig, dazu kommen wir bei den Tutorials.
<?php
/* Entsprechend einer SQL-Abfrage werden alle
gefundenen Datensätze in ein Array geschrieben */
while ($row = mysql_fetch_assoc (result))
/* Liest eine Textdatei zeilenweise ein */
while ($line = fgets ($file))
?>
4. do...while-Schleife Dieser Schleifentyp arbeitet genauso wie while, bis auf zwei Unterschiede. Die Syntax ist ein wenig anders und somit auch das Verhalten. Wenn bei einer while-Schleife schon die erste Bedingung falsch ist, bricht sie sofort ab. Bei do while dagegen wird die Schleife mindestens einmal(!) ausgeführt. Ich persönlich muss gestehen, dass ich noch kein einziges Mal damit gearbeitet habe. Warum? Habe ich nie gebraucht.
<?php
$i = 0;
/* keine Ausgabe, da Bedingung von
vornherein falsch */
while ($i > 0)
{
echo $i;
}
/* gibt $i einmal aus */
do
{
echo $i;
}
while ($i > 0);
?>
5. foreach-Schleife Die Variante dient einzig und allein der Verarbeitung von Arrays, und das macht sie ganz hervorragend. Im folgenden Beispiel werden alle assoziativen Indizes des Arrays und deren Werte ausgegeben.
1. Einführung Funktionen sind einfach ausgedrückt, autonome Abschnitte innerhalb des Quellcodes, die explizit an anderer Stelle aufgerufen werden müssen. Sie werden vor allem dann eingesetzt, wenn bestimmte Aufgaben immer wieder ausgeführt werden sollen, aber jedes Mal mit anderen Werten. Ihre Syntax ist sehr einfach:
function Funktionsname (optionale Variablen)
{
Anweisungen
}
2. Funktionsweise Nehmen wir mal ein einfaches Beispiel für den Einsatz und die Arbeitsweise von Funktionen. Wir haben einen Online-Shop, wo wir den Bruttopreis einer Bestellung ausrechnen wollen. Dazu brauchen wir eine Variable für den Nettopreis und die Menge sowie eine Funktion, die den Bruttopreis zurückgibt.
<?php
function getBrutto ($preis, $menge)
{
$brutto = ($preis + ($preis * 0.19)) * $menge;
return $brutto;
}
?>
Wichtig ist das Wörtchen return, das gibt nämlich das Ergebnis der Berechnung zurück. Nun kann die Funktion zum Beispiel so aufgerufen werden.
<?php
$gesamtpreis = getBrutto (25.95, 10);
?>
Ach ja, noch zwei Hinweise zu return. Erstens, man kann nur einen(!) Wert zurückgeben. Sei es ein true/false, eine Variable oder ein Array. Zwei returns sind nicht möglich. Warum? Weil jeglicher weiterer Code danach nicht mehr ausgeführt wird. Darum sollte ein return auch immer am Ende eines Funktionsblocks stehen.
3. Geltungsbereich von Variablen Bei der Verwendung von Funktionen muss man auf eine Sache besonders achten. Variablen innerhalb einer Funktion können nur dort genutzt werden, solange man sie nicht als global definiert. Allerdings sollte man damit, wenn möglich, nicht arbeiten. Das lässt auf unsauberen Code schließen.
<?php
// Global im Script verfügbar
$blubb = 'blubber';
// Nur innerhalb der Funktion verfügbar
function machWas()
{
$bla = 'schwall';
}
// Global im Script verfügbar
function machWas()
{
global $bla = 'schwall';
}
// Zugriff auf lokale Variablen innerhalb einer Funktion
function machWas()
{
$bla = 'schwall';
return ($bla);
}
$neu_bla = machWas();
echo $neu_bla;
?>
PHP - Grundlagen - Funktionen Teil 2
1. Noch und nöcher Manchmal weiß man zu Beginn einer Funktion gar nicht, wie viele Parameter man benötigt. Also haut man einen an den anderen rein und dasselbe Spielchen wiederholt sich dann beim Funktionsaufruf. Doch seit PHP4 ist das nun nicht mehr nötig, denn da gibt es ein paar schöne Möglichkeiten.
2. Optionale Parameter Manchmal kann es vorkommen, dass eine Funktion an mehreren Stellen genutzt wird, aber nicht alle Parameter benötigt werden. Die erste Möglichkeit wäre, beim Aufruf "leere" Werte zu übergeben, um eine entsprechende Fehlermeldung zu umgehen:
<?php
function doSomething ($bla, $blubb, $blubber)
{
...
}
doSomething ($schwall,'','');
?>
Das kann dann schon mal ziemlich ausarten. Daher besteht die Möglichkeit, bei optionalen Parametern bereits in der Funktionsdefinition Standardwerte vorzugeben. Dann muss man beim entsprechenden Aufruf nur noch die Parameter angeben, die wirklich benötigt werden:
<?php
function doSomething ($bla, $blubb = '', $blubber = '')
{
...
}
doSomething ($schwall);
?>
Wichtig ... ist die Reihenfolge der Parameter. Zuerst kommen all die, wo man definitiv einen Wert übergeben muss, und DANN ERST die optionalen. Ansonsten gibt es einen Fehler!
3. func_irgendwas Bei den folgenden Funktionen muss man auf drei grundsätzliche Dinge achten:
• Bei selbst definierten Funktionen müssen keine Parameter mehr angegeben werden
• Sie dürfen nur innerhalb von selbst definierten Funktionen aufgerufen werden
• Wenn man einen entsprechenden Wert weiter verarbeiten möchte, so muss der vorher in einer Variablen gespeichert werden
func_num_args Ermittelt die Anzahl der übergebenen Parameter. Anhand des Ergebnisses kann man schon eine erste Fallunterscheidung treffen:
<?php
function bla ()
{
if (func_num_args() > 2)
{
doThis();
}
else
{
doThat();
}
}
bla('blubb','blubber','laber');
?>
func_get_args Ermittelt alle Parameter und schreibt sie in ein numerisches Array. Nun kann man über den entsprechenden Index darauf zugreifen.
<?php
function bla ()
{
$params = func_get_args();
print_r ($params);
}
bla('blubb','blubber','laber');
?>
func_get_arg Hier hat man direkten Zugriff auf einen Parameter anhand seines numerischen Indexes. Ist der angegebene Wert größer als die Anzahl der tatsächlichen Parameter, so wird eine entsprechende Warnung ausgegeben.
<?php
function bla ()
{
$blubb = func_get_arg(1);
echo $blubb;
}
bla('blubb','blubber','laber');
?>
PHP - Grundlagen - Funktionen Teil 3
1. Variable Funktionsnamen Analog zu den variablen Variablen (siehe Punkt 4) bietet uns PHP auch die Möglichkeit, das mit Funktionen zu machen. Dabei legt man in einer Variablen den Funktionsname fest und ruft dann diese dann einfach mit einem () auf.
<?php
function bla ()
{
echo 'Jodelblah';
}
function blubb()
{
echo 'blubber';
}
if (true === $irgendwas)
{
$func = 'bla';
}
else
{
$func = 'blubb';
}
$func();
?>
2. Dynamische Funktionen Was das nun soll, weiß ich selber nicht genau, aber ich zeige es euch trotzdem. Wenn man eine Funktion definieren will, während der PHP-Interpreter zur Laufzeit ein Script abarbeitet, so kann man das so machen
<?php
$rechne_um = create_function (
'$dollar, $euro_wert',
'return $dollar * $euro_wert;'
);
$kohle = $rechne_um(25, 1.5);
echo $kohle;
?>
Erläuterung Als erstes erstellt man mit $rechne_um einen Verweis auf die entsprechende Funktion (create_function). Dabei müssen zwei "Parameter" angegeben werden. Der erste beinhaltet die tatsächlichen Parameter, die diese "Laufzeitfunktion" benötigt und der zweite stellt den eigentlichen Code, also die benötigten Anweisungen derselbigen dar.
3. Verschachtelte Funktionen Nicht nur in JavaSript, sondern auch in PHP kann man Funktionen IN Funktionen einsetzen! Wofür man das gebrauchen kann? Keine Ahnung, ich zeig es euch trotzdem mal. Ist wahrscheinlich so eine Art von Pseudo-OOP. Ein Beispiel
<?php
function bla ()
{
function blubb()
{
echo 'blubb wurde aufgerufen<br>';
}
function blubber()
{
echo 'blubber wurde aufgerufen<br>';
}
blubb();
blubber();
}
bla();
?>
Erläuterung Die Funktion bla enthält zwei zusätzliche Funktionen namens blubb und blubber. Diese werde nun in selbiger aufgerufen (blubb(); blubber();). So reicht denn nun der einmalige Aufruf der Hauptfunktion bla, um beide Ausgaben zu erzeugen. Der Aufruf der beiden Unterfunktionen muss natürlich NACH deren Definition erfolgen, sonst gibt es eine entsprechende Fehlermeldung à la Call to undefined function blubb().
Wichtig Man hat bei obigem Beispiel keinen DIREKTEN Zugriff auf die, nennen wir sie mal so, Kindfunktionen. Folgendes Beispiel würde also auf jeden Fall eine Fehlermeldung erzeugen:
<?php
function bla ()
{
function blubb()
...
function blubber()
...
}
blubb();
?>
Aber ... man kann das trotzdem über einen Umweg erreichen, indem man zuerst die "Elternfunktion" aufruft und dann die gewünschte Kindfunktion (daher mein obiger Begriff Pseudo-OOP):
<?php
function bla ()
{
function blubb()
...
function blubber()
...
}
bla();
blubb();
?>
PHP - Grundlagen - Programmierstile
1. WICHTIG!!! Das nun folgende Kapitel solltet ihr als Anfänger auf gar keinen Fall überspringen. Also HIERGEBLIEBEN. Denn hier werde ich euch zeigen, wie ihr euern Code so sauber und übersichtlich strukturieren könnt, dass ein Programmierer in der Lage ist, ihn zu lesen wie in einem Buch. Viele von euch werden jetzt sicher denken:
"Was soll denn der Blödsinn?" Ich will erst mal die Grundlagen lernen. Das mit dem sauberen Code kommt später" [Quelle: Leute, die gerade erst mit PHP angefangen haben]
Falsch! Das hier sind bereits Grundlagen, und zwar elementare! Anfänger habe zu Beginn oft große Probleme, selbst einfachste Fehler schnell zu finden. Und das liegt sehr häufig an so schlampig geschriebenem Code, dass selbst Profis erst dreimal hinschauen müssen. Wenn ihr euch also die folgenden Abschnitte zu Gemüte führt und sie auch beherzigt, so habt ihr bereits einen wichtigen Schritt getan.
2. Coding-Standards Dabei handelt es sich um eine Sammlung von Regeln, die dafür Sorge tragen sollen, dass der Code von jedermann lesbar ist. Mit jedermann meine ich zum Beispiel ein Programmierteam in einer Firma, wo alle an derselben Anwendung rumstricken müssen. Da ist es dann äußerst hinderlich, wenn jeder seinen Code so aufbaut, wie es ihm gerade in den Kram passt. Gut in einer solchen Situation werden sich Anfänger nicht befinden (außer den Praktikanten unter euch). Ihr solltet euch aber trotzdem einen einheitlichen Stil angewöhnen, also euren eigenen Standard festlegen. Wichtig dabei ist, dass wenn ihr euch einmal für etwas entschieden habt, ihr das auch konsequent durchzieht. Also macht es nicht mal so, und dann mal so, und ansonsten so.
3. Der Inhalt In den folgenden Abschnitten mache ich euch mit den verschiedenen Programierstilen vertraut, die es bei PHP gibt. Dabei werde ich bewusst nicht auf offizielle Coding-Standards wie zum Beispiel dem PEAR-Style eingehen, da ich euch nur auf die verschiedenen Variationen hinweisen möchte. Für was ihr euch dann letztendlich entscheidet, ist eure Angelegenheit.
4. Ein Wort in eigener Sache Alles was ich euch hier erzähle, ist meine persönliche Meinung! Wenn ihr andere Programmierer dazu befragt, werdet ihr mit Sicherheit recht häufig andere Ansichten zu hören bekommen. Daran ist auch nichts auszusetzen, bekanntlich führen viele Wege nach Rom. Denkt aber immer daran. Viele von denen haben das Programmieren von der Pike auf an gelernt (Ausbildung, Studium) und ticken sowieso ganz anders. Ich habe mir das selber beibringen müssen und bin dabei durch ein Tal voller Irrungen und Wirrungen gewandert, bevor ich irgendwann mal mein Ziel erreicht hatte und in der Lage war, sauberen Code zu produzieren.
1. Die Hauptvarianten Hier gibt es zwei grundsätzliche Möglichkeiten. Bei der ersten setzt man die öffnende Klammer hinter die Anweisung und die schließende am Ende in eine neue Zeile. Bei der zweiten dagegen wird jede Klammer in eine neue Zeile geschrieben. Das gilt für ALLE Fälle, wo man damit arbeitet, nur bei den "variablen" Variablen nicht.
<?php
// Variante 1
function doSomething () {
Anweisung
}
// Variante 2
function doSomething ()
{
Anweisung
}
?>
2. Eine Sondervariante Die trifft man vor allem bei Bedingungen. Neben den oben beschriebenen Möglichkeiten gibt es da auch noch diese zu sehen. Ich persönlich halte nicht sehr viel davon, da ich sie für ziemlich unleserlich halte.
<?php
// Sondervariante
if (wert == irgendwas) {
Anweisung
} elseif (wert == was_anderes) {
Anweisung
} else {
Anweisung
}
?>
3. Arbeiten ohne Klammern Dies ist bei Bedingungen durchaus möglich. Ich rate euch aber, die Finger davon zu lassen. Man spart sich zwar ein wenig Tipparbeit, aber die Konsistenz des Quellcodes geht dabei flöten. Darum sage ich euch auch nicht, wann man diesen Stil benutzen darf. Ätsch ;-).
<?php
if (wert == irgendwas)
Anweisung
else
Anweisung
if (bedingung) Anweisung;
?>
4. Die Horrorvarianten Neben den oben beschriebenen Möglichkeiten tauchen von Zeit zu Zeit auch noch Variationen auf, die es zwar gibt, von denen ich aber nur abraten kann. Ganz zu schweigen von Stilen, die sich irgendwelche Entseelten ausgedacht haben:
1. Warum was zu normalen Klammern sagen? Die gehören doch normalerweise in eine Zeile, oder? Das war es dann doch, oder? Nein, nicht ganz. Es gibt Situationen, wo man von der üblichen Schreibweise abweichen sollte, und darum geht es hier. Dabei kommen zwei Situationen in Frage, komplexe Bedingungen und Arrays.
2. Bedingungen ... können manchmal ziemlich nerven, wenn sie gehäuft auftreten. Da wird der Code dann schon mal ziemlich lang und unübersichtlich. Aus Platzgründen verzichte ich hier einfach auf konkrete Beispiele. Ich denke aber, ihr wisst, was ich meine.
<?php
//Schlimm
if (bedingung_1 && bedingung_2 && bedingung_3 ...)
// Schlimmer
if ((bedingung_1 || bedingung_2) && (bedingung_3 || bedingung_4))
?>
So was kann ziemlich schnell überhand nehmen. Vor allem, wenn man dann die einzelnen Bedingungen noch aufdröseln muss. Daher hat sich vielfach eine deutlich übersichtlichere Schreibweise etabliert, an der ihr euch teilhaben lassen möchte.
<?php
if (
($dings != 1 && $bumms == 2) &&
($blubb != 3 && $blubber == 4) ||
($bla != 5 || $schwall == 6)
)
?>
Gut, auch hierzu gibt es wiederum verschieden Variationen, manche setzen die logischen Operatoren an das Ende einer Zeile, andere an den Anfang, und wo dann die geschweiften Klammern hingehören, weiß auch keiner so genau.
<?php
// Variante 1
if (
// diverse Bedingungen
) {
Anweisung
}
// Variante 2
if (
// diverse Bedingungen
)
{
Anweisung
}
// Variante 3
if (
// diverse Bedingungen
) {
Anweisung
}
?>
Nichtsdestotrotz sollte man bei komplexen Bedingungen auf diese Schreibweise zurückgreifen, da sie doch übersichtlicher ist.
3. Arrays Dasselbe Prinzip kann man auch bei komplexeren Arrays anwenden, vor allem wenn man sie mit array erzeugt. Eine zusätzliche Verbesserung hierzu findet ihr im nächsten Abschnitt.
<?php
$array = array (
'bla' => 'blubb',
'schwall' => 'laber',
'kraeh' => 'sülz'
);
?>
PHP - Grundlagen - Programmierstile - Leerzeichen
1. Grundsätzlich ... sollte man (fast) immer mit Leerzeichen arbeiten. Das erhöht die Lesbarkeit des Quellcodes ganz enorm:
<?php
// nicht so doll
for($i=0;$i<count($result);$i++)
// Schon besser
for($i = 0; $i < count($result); $i++)
?>
2. Zusätzliche Leerzeichen An diesem Punkt streiten sich die Gelehrten mal wieder und jeder behauptet etwas Anderes. Darum stelle ich euch einfach Mal nur ein paar zusätzliche Varianten vor. Was euch am ehesten liegt, sei eurem ganz persönlichen Geschmack überlassen:
<?php
// Leerzeichen nach Funktion oder Befehl
$new_array = array_values ($array);
// Leerzeichen in normalen Klammern
if ( $bla > $blubb )
// Leerzeichen in normalen Klammern
// mit Leerzeichen nach Funktion
while ( $row = mysql_fetch_assoc ($res) )
// Kein Leerzeichen vor den Klammern einer eigenen Funktion
function doSomething()
// Leerzeichen vor den Klammern einer eigenen Funktion
function doSomething ()
?>
3. "Tabulator"-Leerzeichen Die kann man zusätzlich einfügen, um bestimmte Code-Konstrukte zusätzlich zu gliedern. Beispiele dafür wären umfangreichere Bedingungen oder Arrays. Allerdings weise ich an dieser Stelle darauf hin, dass es zu diesem Thema zig Varianten gibt, auf die ich aus Platzgründen (und Faulheit) nicht eingehen werde.
1. Erklärung In diesem Abschnitt geht es nicht um zusätzliche Formatierungsmöglichkeiten mittels Leerzeichen, wie ich sie im vorherigen Abschnitt gezeigt habe. An dieser Stelle möchte ich auf etwas Grundsätzliches eingehen, dass in den so genannte Semikolon-Sprachen wie PHP gang und gäbe ist. Dabei handelt es um Einrückung eines bestimmten Codeabschnitts innerhalb einer übergeordneten Anweisung. Also all das, wo geschweifte Klammern drum rum sind (für dieses Deutsch hätte ich eigentlich Prügel verdient). Ein Beispiel zur Anschauung
<?php
function doSomething ()
{
$bla = 'blubb'; <-- Das ist eine Einrückung
if ($irgendwas) { <-- Das auch
doSomethingElse (); <-- Das ebenso
}
}
?>
2. Einrückungstiefe Hier gilt die Grundregel, dass die Einrückung einen Tabulatorsprung groß ist. Ja toll, und was ist ein Tabulatorsprung? Ganz einfach, das, was ihr in euren Editor einstellt ;-). Jetzt mal Spaß beiseite. Der Tabulatorsprung definiert sich tatsächlich als die Anzahl von Leerzeichen, die ihr in eurem Editor einstellt. Als eine Art Standardwert hat sich dabei die Vier etabliert.
<?php
// Tabsprung mit vier Leerzeichen
function doSomething ()
{
if ($bla == $blubb)
{
$blubber = 'Laber'
}
}
?>
Ich selber habe das jahrelang so gehandhabt, bis ich Anfang Oktober 2007 einen neuen Brötchengeber fand. Dort ist es vorgeschrieben, dass man nur zwei Leerzeichen benutzen darf. Wegen der internen Coding-Standards. Anfangs war ich ein wenig pikiert, weil ich das für sehr unübersichtlich hielt. Mittlerweile habe ich mich so daran gewöhnt, dass ich selbst bei meinen privaten Projekten dazu übergangen bin.
<?php
// Tabsprung mit zwei Leerzeichen
function doSomething ()
{
if ($bla == $blubb)
{
$blubber = 'Laber'
}
}
?>
Für was ihr euch letztendlich entscheidet, ist mir völlig schnuppe. Es gibt auch Varianten mit drei oder sogar acht Leerzeichen. Zerbrecht euch aber bitte nicht den Kopf darüber, vor allem wenn ihr jetzt schon an potenzielle zukünftige Arbeitgeber und deren Standards denkt. Die Umstellung ist wirklich reine Gewöhnungssache und hat bei mir nur etwa 4 Wochen gedauert, bis ich es komplett verinnerlicht hatte.
3. Tatsächliche Leerzeichen Bei Editoren kann man einstellen, ob bei der Einrückungstiefe auch tatsächlich Leerzeichen oder nur "virtuelle" Tabulatorsprünge gesetzt werden. Bei letzterem handelt es nur um ein Steuerzeichen, so eine Art \t. Leider wird das von anderen Editoren recht eigenwillig interpretiert. Daher kann es da schon mal passieren, dass euer ach so toller Quellcode in einem anderen Editor aussieht wie Sau. Darum solltet ihr immer nach einer Option bei den Einstellungen suchen wie "Tabulatorgröße in Leerzeichen umwandeln" oder "Tab zu Leerzeichen".
PHP - Grundlagen - Programmierstile - Kommentare
1. Standards? Gab es lange Zeit keine. Darum hat auch jeder gemacht was er/sie wollte. Mit dem Ergebnis, dass sich heutzutage viele Programmierer durch den eigenen oder fremden Ekelcode aus längst vergessenen Zeiten kämpfen müssen und keine Sau weiß, was wofür gebraucht wird. Gottlob hat sich mittlerweile ein Standard eingebürgert, die PEAR Coding Standards für Kommentare. Und die solltet ihr auf jeden Fall nutzen, da sie sehr gut aufgebaut sind. Der zusätzliche Vorteil dabei ist, dass man mit Programmen wie phpDocumentor automatisch Dokumentationen von seinem Quellcode erstellen kann, besonders wenn er objektorientiert programmiert wurde.
2. PEAR Coding Standards für Kommentare Grundlagen Einzeilige Kommentare fangen wie gehabt mit // an. Bei mehrzeiligen dagegen gibt es eine kleine Besonderheit. Sie beginnen mit einem /**, enden mit einem */ und die Kommentare werden dann dazwischen (!) in die einzelnen Zeilen geschrieben, die jeweils mit * anfangen. Also so:
<?php
/**
* Dies ist ein mehrzeiliger Kommentar,
* der so aussehen sollte und nicht anders
*/
function doSomething() ...
?>
Ich persönlich habe mir angewöhnt, das erste / um ein Leerzeichen nach links einzurücken, damit die Sternsken (*) schön untereinander und auf Höhe des folgenden Codes stehen. Auch nutze ich diese Schreibweise mittlerweile bei einzeiligen Kommentaren, da ich erstens nie weiß, ob da noch etwas hinzu kommt und ich zweitens großen Wert auf Einheitlichkeit lege. Bei solchen Dingen bin ich einfach sehr pedantisch. Variablen Der PEAR Standard sieht vor, dass Eigenschaften einer Klasse genauer beschrieben werden müssen. Das kann man auch auf die unsäglichen als global deklarierten Variablen in Funktionen übertragen. Ebenso besteht die Möglichkeit, bei prozeduraler Programmierung dies auch generell für global verfügbare Variablen zu nutzen. Dabei gibt es neben der eigentlichen Beschreibung ein paar "Schlüsselwörter" für weitere Informationen, die mit einem @ beginnen:
<?php
/**
* Hier wird der Sinn des Lebens definiert
* @var int
*
* bei Eigenschaften von Klassen zusätzlich die Sichtbarkeit
* @access public
*/
public $meaning_of_life = 42;
?>
Funktionen und Klassen Da sich die PEAR Coding Standards für Kommentare hauptsächlich auf Klassen bezieht, übertrage ich das einfach auch mal auf Funktionen. Das ist zwar nicht ganz glücklich, ich mache aber trotzdem, wie so oft ;-). Dabei sollte man so genau wie möglich die Aufgabe der Klasse/Funktion beschreiben. Dazu gehören eventuelle Parameter und Rückgabewerte. Damit ihr euch ein Bild davon machen könnt, gibt es hier ein abschreckendes Beispiel meinerseits. Wer es ganz genau wissen will, sollte sich mal das oder das hier ansehen. Da wird genau beschrieben, wie man vorzugehen hat und was für zusätzliche "Schlüsselwörter" es noch gibt. Also die mit dem @ davor.
3. Die Sprache Das ist so eine Sache. In international tätigen Unternehmen ist Englisch natürlich die Hauptsprache. Also sollte man in dem Fall auch in der Lage sein, seine Kommentare in dieser Sprache verfassen zu können. Ansonsten reicht in eurem Fall auch Deutsch aus. Das hat zum einen den Vorteil, dass euch eure Kollegen verstehen und zum Anderen, dass im Falle eines geplanten IT-Outsourcing in andere Länder ihr ein Erpressungsmittel habt. Frei nach dem Motto:
"Eih, Alde von McKinsey. Du wilst auslagern. Übersetzt du Kommentare selber." [Quelle: Erpresser mit Hirn]
Bei privaten Projekten könnt ihr natürlich jede Sprache nehmen, mit der ihr klar kommt. Selbst wenn es sich dabei um Kisuaheli oder Mandarin-Chinesisch handelt.
PHP - Grundlagen - Programmierstile - Variablen- und Funktionsnamen
1. Grundsätzliches In den letzten Jahren hat sich auch hier ein Quasi-Standard etabliert, der aus anderen Sprachen übernommen worden ist. Es gibt da zwar einige Variationsmöglichkeiten, aber das Grundprinzip ist dasselbe. Allerdings werde ich hier das ein oder andere Mal kräftig meinen Senf dazugeben, wenn ich etwas für nicht so glücklich halte.
2. KONSTANTEN ... werden immer groß geschrieben. Da erkennt man auf einen Blick, um was es sich da handelt. Und das war es schon zu diesem Thema.
<?php
define('DEUTSCH', 1);
echo DEUTSCH;
?>
3. Funktionsnamen Hier hat sich eine Schreibweise etabliert, die unter dem Begriff Camel Caps bekannt ist. Dabei gliedert sich der Funktionsname in zwei Teile. Ich nenne dies das "Tu-Was"-Prinzip. Der erste Teil beschreibt dabei die Art der Handlung und wird klein geschrieben. Im zweiten Teil geht es dann um das Was. Hier beginnt man mit einem Großbuchstaben.
<?php
function getContent ()
?>
Der "Tu"-Teil Hier gelten ein paar einfache Regeln. Wenn man sich etwas holt, so nimmt man get, wenn man etwas setzt, so benutzt man set, wenn man etwas aufruft ohne Rückgabewert so wird häufig call genommen, und so weiter und so fort. Als kleine Hilfe sollte man sich die Funktionsbezeichnungen in PHP anschauen. Dann kommt man auch auf Dinge wie replace, unset oder auch destroy.
<?php
function unsetSession ()
function replaceContent ()
function destroyUser ()
?>
Der "Was"-Teil Hier sollte relative genau beschreiben, um was es sich handelt. Da PHP derzeit aber noch keine Namespaces kennt, artet das manchmal ziemlich aus. Wichtig ist aber, dass die "Einzelbeschreibungen" immer mit einem Großbuchstaben beginnen.
<?php
function unsetLoginSession ()
function getContentFromArray ()
function sendUserMail ()
?>
3. Variablennamen Hier hat sich in letzter Zeit ein Trend breit gemacht, von dem ich, ehrlich gesagt, gar nichts halte. Dabei wird obige Schreibweise übernommen, nur die Aufteilung ist anders. Nennen wir es mal das "Typ-Hauptinfo[-Nebeninfo]"-Schema. Der Variablenname beginnt mit einem Kleinbuchstaben, der in verkürzter Form den Typ der Variable beschreibt, also zum Beispiel a für ein Array, i für ein Integer, s für einen String oder g für globale Variablen. Als nächstes kommt die Beschreibung des Inhalts, beginnend mit einem Großbuchstaben, also zum Beispiel Nav für die Inhalte eines Navigationsmenüs. Zusätzlich kann man daran weitere Infos anhängen, die ebenfalls mit einem Großbuchstaben beginnen. Dieses Schema kann man auch als Index bei assoziativen Arrays anwenden.
<?php
aNavTree = ...
sSearchWord = ...
iUserGroup = ...
$_SESSION['sUserName'] = ...
$aUserInfo['sUserCity'] = ...
?>
Meine Meinung Grundsätzlich habe ich nichts gegen dieses Schema. Mir persönlich stinken nur zwei Dinge, die aber gewaltig. Ersten die Schreibweise. Sie erinnert mich zu stark an den Aufbau von Funktionsnamen, was zu Irritationen führen kann. Ich persönlich bevorzuge daher die Unterstrich-Methode, die lange Zeit gang und gäbe war (und es auch heute zum Teil noch ist). Auch mag ich hier eine konsequente Kleinschreibung. So kann man auf dem allerersten(!) Blick erkennen, dass es sich um eine Variable handelt und nicht um eine Funktion.
<?php
a_nav_tree = ...
s_search_word = ...
i_user_group = ...
$_SESSION['s_user_name'] = ...
$aUserInfo['s_user_city'] = ...
?>
Als zweites stört mich die Sache mit der "Ein-Buchstaben-Typ-Kurzbeschreibung". Bei stark typisierten Sprachen mag das ja durchaus sinnvoll sein. Bei PHP aber kann es meiner Meinung nach Entwickler dazu verführen, eine Typprüfung aus Leichtsinnigkeit und/oder Faulheit zu unterlassen, so nach dem Motto:
"Ich habe doch ein i vor die Variable gesetzt. Das soll also ein Integer sein. Warum machst du daraus einen String?" [Quelle: ein leichtsinniger und/oder fauler Programmierer]
Außerdem ist es meiner Meinung nach ein wenig irreführend. Steht das s nun für einen String oder eine Session? Darum sage ich, weg damit. Auch wenn mich einige dafür kreuzigen möchten, meine Kollegen eingeschlossen ;-).
1. Die Möglichkeiten In PHP gibt es zwei Möglichkeiten, um normale Zeichenketten/Strings mit Variablen zu kombinieren. Entscheidend ist dabei die Art und Weise, womit ihr die Zeichenketten einschließt. Da gäbe es einmal die Anführungszeichen (") und die so genannten Hochkommata ('). Für welches ihr euch entscheidet, ist eigentlich egal, ihr solltet das dann aber konsequent durchziehen. Mal so und mal so ist meiner Meinung nach auf Dauer problematisch bei der Fehlersuche. Beide Varianten haben ihre Vor- und Nachteile. Die Anführungszeichen Bei dieser Variante kann man Variablen direkt in eine Zeichenkette hineinschreiben und ihr Wert wird trotzdem erkannt. Ein kleines Beispiel:
<?php
$hartz_vier = 500;
echo "Ich bekomme jeden Monat $hartz_vier Euro";
?>
Die Hochkommata Bei dieser Variante werden die Werte von Variablen innerhalb der Zeichenkette nicht mehr erkannt und müssen "separiert" werden. Die Verbindung erfolgt über den so genannten Verknüpfungsoperator, dem Punkt.
<?php
$hartz_vier = 500;
// Falsch
echo 'Ich bekomme jeden Monat $hartz_vier Euro';
// Richtig
echo 'Ich bekomme jeden Monat '.$hartz_vier.' Euro';
?>
2. Das Problem Egal für welche Variante man sich entscheidet, spätestens bei der Ausgabe von HTML- und/oder JavaScript-Code steht man vor einem Problem. Setzt man zum Beispiel bei HTML-Attributen die Anführungszeichen ein oder Hochkommata? Nun, beides ist erlaubt. Aber wie geht man vor?
NEIN, sage ich Und bitte, glaubt mir jetzt einfach mal. Die beiden ersten Möglichkeiten sind meiner Meinung nach extrem fehleranfällig und obendrein sehr schlecht zu lesen, weil viele Editoren hier die Variablen optisch nicht hervorheben. Darum solltet ihr euch wirklich das hier angewöhnen:
Zeichenketten schön in Hochkommata setzen und Variablen über den Verknüpfungsoperator einbinden. Das ist sauber, das ist übersichtlich. Außerdem braucht man sich nicht mehr um die Maskierung der Anführungszeichen kümmern. Noch ein Argument ... für die Skeptiker und Zweifler. Bei assoziativen Arrays wird der Index ebenfalls entweder in Anführungszeichen oder Hochkommata gesetzt. Nur leider fallen die bei der ersten Schreibweise weg, also eine weitere Fehlerquelle, die euch die Arbeit erschweren kann.
<?php
// Unübersichtlich und fehleranfällig
$monatsgehalt['mai'] = 3000;
echo "Im Monat Mai betrug mein Gehalt $monatsgehalt[mai] Euro";
// So ist's brav
$monatsgehalt['mai'] = 3000;
echo 'Im Monat Mai betrug mein Gehalt '.$monatsgehalt['mai'].' Euro';
?>
3. Mein Tipp Meidet die Anführungszeichen wie der Teufel das Weihwasser. Da wird euch eure Arbeit erheblich erleichtern und ihr schießt nicht diese Böcke, die man immer wieder in Foren zu Gesicht bekommt.
<?php
// Was soll das?
$bla = "$blubb";
// Und das?
$bla["$blubb"] = "blubber";
// Das hier ist ja völliger Tinnef
$bla['$blubb'] = 'blubber';
?>
Nicht lachen! Ist alles schon vorgekommen. Daher gilt hier ab sofort eine Grundregel:
Grundregel Variablen werden NIEMALS in Anführungszeichen gesetzt! Wer es trotzdem tut, wird aus der Gemeinschaft der Programmierer ausgeschlossen. Wie all diejenigen, die noch immer mit GOTO arbeiten, wenn es die Sprache erlaubt.
4. Escapen Während meine obige Meinung von vielen anderen Entwicklern geteilt wird, so sieht es beim Escapen nicht ganz so eindeutig aus. Ich persönlich mag es nicht, aber etliche andere schon. Darum stelle ich euch nur mal die zwei Möglichkeiten vor und ihr entscheidet selber.
Ohne Escapen
<?php
// Ein JavaScript-Code ohne Escapen mit Hochkommata
$query = 'UPDATE bla SET blubber = \''.$_POST['blubber'].'\'';
?>
PHP - Grundlagen - Programmierstile - PHP in HTML
1. Ja, ich weiß In großen (und auch leider kleinen) Anwendungen werden heutzutage konsequent mit wie auch immer gearteten Template-Systemen gearbeitet. Seien es nun solche wie das Monster Smarty, oder vlibTemplate bzw. Savant sowie vernünftige Lösungen wie XSL. Dies ist aber eigentlich immer erst der zweite Schritt, nachdem man sich intensiv mit PHP vertraut gemacht hat. Für Anfänger tun sich damit einige Problem auf. Standards hin, Standards her.
2. Das Problem Wie soll man denn nun seinen PHP-Code in ein HTML-Dokument einbinden? Da, wo man es gerade braucht? Oder sollte man doch den benötigten HTML-Code per PHP erzeugen? Nun denn, so werde ich euch mal meine Ansicht zu diesem Thema kundtun, auch wenn andere Programmierer das Gegenteil behaupten werden.
3. PHP-Code in HTML ... ist meiner Meinung dann in Ordnung, wenn es einfach und übersichtlich ist. Also zum Beispiel bei der Festlegung von value-Werten in Formularen, Oder bei einfachen Anweisungen.
4. Bloß nicht Bei vielen Anfängern findet man sehr oft Codebeispiele wie dieses:
<div class="inhalt">
<table>
<?php
$open = fopen ('blubb.txt');
while ($line = fgets ($open, "r"))
{
$trenn = explode (';', $line);
?>
<tr>
<td><?php echo $trenn[0]; ?></td>
<td><?php echo $trenn[1]; ?></td>
<td><?php echo $trenn[2]; ?></td>
</tr>
<?php
}
?>
</table>
</div>
Davon rate ich euch dringenst ab! Meine ersten Gehversuche in PHP sahen genauso aus. Und glaubt mir jetzt einfach mal. Das ist das Falscheste, was ihr machen könnt. Besonders bei Schleifen oder Bedingungen wird der Quellcode extrem unübersichtlich. Und bei Fehlern sucht ihr euch da wirklich einen Wolf.
4. Vielleicht so? Obigen Code kann man auch mit PHP wesentlich übersichtlicher gestalten. Dabei nutzt man einfach die Möglichkeiten der Zeichenkettenverknüpfung und arbeitet mit einfachen Zeilenumbrüchen.
<div class="inhalt">
<?php
echo '<table>';
$open = fopen ('blubb.txt');
while ($line = fgets ($open, "r"))
{
$trenn = explode (';', $line);
echo '<tr>
<td>'.$trenn[0].'</td>
<td>'.$trenn[1].'</td>
<td>'.$trenn[2].'</td>
</tr>';
}
echo '</table>';
?>
</div>
Dies ist besonders bei den schon oben erwähnten Schleifen oder Bedingungen sehr hilfreich. Und glaubt mir, damit spart ihr euch eine Menge Ärger.
1. Das Problem SQL-Abfragen neigen dazu, immer länger und länger zu werden. Meiner Meinung nimmt das proportional mit dem eigenen Wissen zu. Leider geht das zu Lasten der Lesbarkeit. Denkt nur mal an die Ungetüme, die ich euch hier um die Ohren hauen werde. Oder an das, was ihr selbst schon fabriziert habt. Selbst wenn man die Abfrage per Zeichenkettenverknüpfung in einzelne Teile zerlegt, so bringt das in Punkto Lesbarkeit herzlich wenig.
$query .= 'LEFT JOIN produkt ON produkt.id=bestellung.pr_id ';
$query .= 'LEFT JOIN kunde ON kunde.id=bestellung.kd_id ';
$query .= 'LEFT JOIN hersteller ON hersteller.id=bestellung.hr_id ';
$query .= 'WHERE kunde.id = '.$_GET['id'];
?>
2. Die Lösung Ist eigentlich so einfach, dass ich Superhirn (Ironie) einfach nicht von selbst darauf gekommen. Nein, dass musste ich erst bei meinem neuen Brötchengeber erfahren. Das Prinzip ist ganz einfach. Man schreibt seine Abfragen in etwa so wie seinen PHP-Code. Allerdings gibt es hier wieder etliche Variationen, so dass ich euch nur mal meinen Favoriten zeige.
<?
$query = 'SELECT
anzahl,
produkt,
preis,
nummer,
zulieferer,
hersteller.ort AS ort
FROM
bestellung
LEFT JOIN
produkt ON produkt.id=bestellung.pr_id
LEFT JOIN
kunde ON kunde.id=bestellung.kd_id
LEFT JOIN
hersteller ON hersteller.id=bestellung.hr_id
WHERE
kunde.id = '.$_GET['id'];
?>
Als einfache Grundregel gilt folgendes. Die SQL-Befehle wie INSERT, UPDATE oder UPDATE werden jeweils in eigene Zeilen geschrieben, ebenso wie die wichtigen Zusatzanweisungen, als da wären so Sachen wie FROM, WHERE oder jedwede Joins-Anweisung. Tabellen- oder Spaltennamen werden eingerückt und bei mehreren untereinander gesetzt. Hilfsanweisungen wie ON oder AS sollten nicht zusätzlich in neuen Zeilen auftauchen. Man kann es auch übertreiben.
3. Fazit Ich hoffe, ihr habt hier einen guten Einstieg in mögliche Programmierstile gefunden und beherzigt das dem entsprechend. Allerdings muss ich zu meiner Schande, und der meiner Kollegen, sagen, dass sich selbst die Profis nicht immer daran halten. Das liegt einfach in der Natur der Sache. Man ist mit einem Problem beschäftigt und hat weder Zeit noch Lust, sich an irgendwelche Standards zu halten. Allerdings sollte man doch zumindest versuchen, seinen Code entsprechend eigener/anderer Vorgaben gemäß umzusetzen. Im Notfall kann man den Murks auch noch später korrigieren.
PHP - Befehle - Einführung
1. Ein Wort zuvor Ich weiß ehrlich gesagt gar nicht, wie viele Befehle es in PHP gibt. 50.000? Keine Ahnung. Da eine komplette Auflistung jeden erträglichen Rahmen sprengt (vor allem für mich), werde ich euch mit den Wichtigsten vertraut machen, also denjenigen, die man für den Hausgebrauch und erste Anwendungen benötigt. Wer es ganz genau wissen will, dem empfehle ich das PHP-Handbuch, viel Spaß beim durchwühlen.
2. Befehle und Funktionen Die Überschrift dieses Kapitels heißt "PHP - Befehle", aber im Untermenü steht auf einmal was von Funktionen. Und die hatten wir doch schon bei den Grundlagen. Viele von euch werden jetzt sicher denken:
"Ei, will de Alde uns ver*rschen?" [Quelle: Viele von euch]
Nee, will er nicht. Das hat er ganz bewusst so gemacht! Zunächst mal haben die in PHP eingebauten Funktionen (um die es hier geht) nichts mit denen zu tun, die ihr selber schreibt. Kommen wir nun zum feinen Unterschied. Jeder, der mit dem Programmieren anfängt, oder nur mal was davon gehört hat, oder auch überhaupt nichts davon wissen will, weiß was ein Befehl ist. Nämlich eine Anweisung, die irgendwer auszuführen hat. Damit ist das Grundverständnis schon vorhanden und erklärt auch, warum ich erst mal von Befehlen rede. Da begreift selbst im Zusammenhang mit Computern wirklich jeder, was gemeint ist. Befehle Programmiertechnisch gesehen ist ein Befehl eine Anweisung, die einfach nur ausgeführt wird. Diejenigen von euch, die etliche Monate bei Y-Tours auf Abenteuerurlaub waren, kennen sicher noch Befehle wie folgende:
„Schütze XY, in Deckung und den Arsch nach unten!“ [Quelle: Irgendein Unteroffizier, dem das wirklich Spaß machte]
"Schütze XY, SCHNAUZE!" [Quelle: Derselbe Kerl, hoffentlich bricht er sich bald den Hals]
Man hat sich also das nächste Loch gesucht (auch wenn keine Haare drumherum waren) und die Klappe gehalten. Damit hat man einen Befehl ausgeführt. Funktionen PHP-spezifische Funktionen sind anders. Sie liefern einen Rückgabewert. Verbleiben wir noch ein wenig in der olivgrünen Welt der Bundeswehr. Da kam es das ein oder andere Mal vor, dass man folgenden Befehl bekam:
"Schütze XY, machen sie Meldung!" [Quelle: Immer noch derselbe Nervtöter]
Also hat man sich zusammengerissen, aufgerichtet und mit leidlich ernster Miene geantwortet:
"Schütze XY meldet, auf Alarmposten .. bla bla ... mit dem Auftrag ... blubb blubber." [Quelle: ein unendlich genervter Wehrpflichtiger]
In diesem Fall ist der Befehl des Nervtöters programmiertechnisch gesehen eine Funktion, da er eine Antwort bekommt. Im Gegensatz zur realen Welt, wo man sich auf mehr oder weniger motivierte Wehrpflichtige verlassen muss, erfolgt diese Antwort bei Programmiersprachen automatisch und ohne murren. Dabei hängt die Art der Antwort vom Befehl ab.
3. Funktionsarten Boolsche Funktionen Sehr oft gibt es nur zwei Möglichkeiten, 1 bzw. true für "Befehl wurde erfolgreich ausgeführt" und 0 bzw. false für "das hat nicht geklappt, da ist ein Fehler aufgetreten". Ob man das nun als "Boolsche Funktion" bezeichnen kann, weiß ich nicht, ich mache es einfach mal. Ein einfaches Beispiel ist der Befehl, sorry die Funktion, mail. Wird die Mail versandt, erhalten wir als Rückgabewert die 1 (true), anderenfalls eine 0 (false). Array-Funktionen Die liefern ein komplettes Array zurück. Das beste Beispiel hierfür ist die Funktion "print_r", die alle Indizes mit samt den Werte eines Arrays ausgibt. Der Rest Hierbei handelt es sich um alle Funktionen, die Strings, Datumsangaben, mathematische Berechnungen oder was weiß ich nicht zurückliefern.
4. Error Handling Dieser neudeutsche Begriff steht für eine Art der Programmierung, in der versucht wird, alle möglichen Fehler über die Rückgabewerte der Funktionen abzufangen. Greifen wir für ein kleines Beispiel auf die oben genannte mail-Funktion zurück. Die könnte man nun einfach ausführen und hoffen, dass alles klappt. Das habe ich selber lange Zeit so gemacht, weil immer alles wunderbar funktionierte. Bis ich dann eines Tages ein einfaches Formularscript auf den Webserver eines Kunden hochlud und nach etwa 2 Wochen massive Beschwerden von dessen Kunden bei ihm einliefen, weil keine einzige Anfrage über besagtes Formular beantwortet wurde. Das Problem lag in einer fehlerhaften Konfiguration des Mail-Servers, der einfach nichts verschickte. Seitdem überprüfe ich immer den Rückgabewert:
<?php
// Alte Variante, bis zu obigen Problem
mail ($to, ... der Rest kommt später ...):
// Die neue und sichere Variante
$mail_send = mail ($to, ... siehe oben ...):
// Überprüfung, ob Mail gesendet wurde
if ($mail_send)
{
echo 'Mail wurde versendet';
}
else
{
echo 'Ein Fehler ist aufgetreten.';
}
?>
So, und nun wird es erst mal ziemlich langweilig, da ich euch einen Haufen von Befehlen (nee, ihr habt Recht, Funktionen) um die Ohren haue. Ihr müsst euch nicht alle verinnerlichen, schaut mal kurz drüber. Später bei den Tutorials werdet ihr die meisten sowieso wieder finden.
PHP - Befehle - Variablenfunktionen
1. isset Überprüft, ob eine Variable gesetzt wurde. Dabei muss man aber beachten, dass die trotzdem leer sein kann. Diese Funktion braucht man vor allem bei der Überprüfung von Radio-Buttons und Checkboxen innerhalb von Formularen.
<?php
if (isset ($var))
?>
2. empty Überprüft, ob eine Variable einen Wert hat oder nicht. Diese Funktion gibt true zurück, wenn die Variable leer, bzw. unbestimmt ist.
<?php
if (empty ($var))
?>
3. unset Setzt eine Variable zurück auf den Zustand "unbestimmt", das heißt, sie hat keinen Wert mehr. Diese Funktion gibt immer true zurück.
<?php
unset ($var)
?>
4. gettype Gibt den Variablentyp zurück. Möglich sind integer, double, string, array oder object.
<?php
$var = 'Ich bin ein String';
$typ = gettype ($var);
echo $typ;
?>
5. settype Ändert den Typ einer Variablen und gibt TRUE zurück, wenn die Umwandlung erfolgreich war. Möglich sind alle Typen wie unter gettype beschrieben.
<?php
$var = "123";
$ok = settype ($var, "integer");
?>
6. is_wasweissichdenn Aus lauter Faulheit fass ich die folgenden Funktionen einfach zusammen. Sie überprüfen, ob eine Variable den gesuchten Type haben und geben TRUE zurück, wenn dem so ist. Es gibt is_array, is_float, is_int, is_string und noch ein paar für Fließkommazahlen mit astromischer Genauigkeit.
<?php
$var = array ('a','b','c');
if (is_array ($var))
...
$ok = is_array ($var);
?>
7. intval Diese Funktion versucht aus einer Variablen eine Ganzzahl zu extrahieren. Dabei bricht die Funktion sofort ab, wenn in einer Zeichenkette an irgendeiner Stelle keine Zahl vorkommt.
<?php
$var = '123blabla';
$int = intval ($var);
// Ergibt 123
$var = 'blabla123';
$int = intval ($var);
// Gibt FALSE zurück
?>
PHP - Befehle - Stringfunktionen
1. addslashes / stripslashes addslashes "Maskiert" einfache Anführungszeichen und Gänsefüßchen mit einem Backslash (\). Dies ist besonders wichtig bei Formulareingaben wo ein ' oder " mitten in einem eingegeben Text unwiderruflich die Zeichenkette beendet und auch zu einem Fehler führen kann. So wird folgender Text umgewandelt "Wir alle kennen die berühmten Deppen-Aposthroph's und hassen sie." Ohne addslashes würde bei der nächsten Weiterverarbeitung von $_POST['text'] nur noch "Wir alle kennen die berühmten Deppen-Aposthrop" übrig bleiben. stripslashes Entfernt wieder das maskierende "\".
<?php
$text = addslashes ($_POST['text']);
echo $text;
/* Ausgabe:
Wir alle kennen die berühmten
Deppen-Aposthrop\'s und hassen sie.*/
// Entfernt den Backslash
$text = stripslashes ($text);
?>
2. chop, trim Entfernen überflüssige Leerzeichen, chop nur am Ende einer Zeichenkette, trim auch am Anfang. Diese Funktionen sind besonders nützlich beim Verarbeiten von so genannten csv-Dateien.
<?php
$chop = chop ($string);
$trim = trim ($string);
?>
3. chunk_split Diese Funktion ist besonders nützlich bei der Base64-Kodierung von längeren Texten, da laut Spezifikation nur 76 Zeichen pro Zeile erlaubt sind.
4. explode, split / implode, join explode, split Wandelt eine Zeichenkette anhand eines Trennsymbols in ein Array um. Bei explode muss ein konkretes Zeichen angegeben werden, bei split kann man Reguläre Ausdrücke benutzen.
implode, join Diese Funktionen machen das genaue Gegenteil von explode und split). Sie verbinden die einzelnen Elemente eines Arrays zu einer einzigen Zeichenkette, nur getrennt durch ein vorgegebenes Zeichen.
<?php
$array = explode (';', $string);
$string = implode (';', $array);
?>
5. htmlspecialchars, htmlentities, nl2br Wandeln normale Zeichen in HTML-Notation um. htmlspecialchars beschränkt sich auf die Zeichen ", &, < und >, während htmlentities sich auch noch alle anderen Sonderzeichen wie zum Beispiel ä, ö oder ü. nl2br macht aus normalen Zeilenumbrüchen ein <br>.
<?php
$convert = htmlspecialchars ($string);
$convert = htmlentities ($string);
$convert = nl2br ($string);
?>
8. strip_tags Schmeißt jeglichen HTML- und PHP-Code aus einer Zeichenkette heraus.
<?php
$naked_text = strip_tags ($html_string);
?>
9. str-Funktionen strlen Gibt die Anzahl von Zeichen in einem String aus.
<?php
$string = 'Kräh bla schwall';
echo strlen ($string);
// Gibt 16 aus
?>
strpos, strrpos strpos findet das erste Zeichen in einem String, strrpos das letzte.
<?php
$string = 'Kräh bla schwall';
$pos = strpos ($string, 'b');
// Gibt 6 aus
?>
strstr, stristr Gibt einen String ab dem ersten Vorkommen der Zeichenkette aus, strstr unterscheidet zwischen Groß- und Kleinschreibung, stristr nicht.
<?php
$string = 'Kräh bla schwall';
echo strstr ($string, 'bla');
// Gibt bla schwall aus
?>
strtolower, strtoupper strtolower wandelt alle Zeichen in Kleinbuchstaben um, strtoupper in Großbuchstaben.
<?php
$string = 'kräh bla schwall';
echo strtoupper ($string);
// Gibt KRÄH BLA SCHWALL
?>
str_replace Ersetzt eine Zeichenkette durch eine Andere.
<?php
$string = 'kräh bla schwall';
echo str_replace ('bla', 'blubb', $string);
// Gibt kräh blubb schwall aus
?>
PHP - Befehle - Arrays
Bei Arrays gibt es zig Funktionen, von denen ich bisher nur einen relativ kleinen Teil benutzt habe. Und die werde ich hier kurz vorstellen, eine komplette Liste findet ihr zum Beispiel hier.
1. array Kennen wir schon, damit wird ein Array erzeugt.
<?php
$mein_array = array ('blä','blö','blü');
?>
2. count, sizeof Gibt die Anzahl von Einträgen eines Arrays zurück und lässt sich sehr gut in Schleifen einsetzten.
<?php
$array = array ('blä','blö','blü');
for ($i = 0; $i < count ($array); $i++)
{
echo $array[$i].'<br>';
}
?>
3. array_keys Gibt die Schlüssel eines Arrays zurück, ganz gleich, ob es sich um numerische oder alphanumerische Werte handelt. Diese Funktion bietet sich besonders bei assoziativen Arrays an.
<?php
$mein_array = array (
'kräh' => 'dumdidum',
'bla' => 'blubb',
'schwall' => 'blubber'
);
print_r (array_keys($mein_array));
?>
4. array_values Gibt alle Werte eines Arrays aus, egal ob es sich um numerische oder assoziative handelt.
<?php
$mein_array = array (
'kräh' => 'dumdidum',
'bla' => 'blubb',
'schwall' => 'blubber',
);
print_r (array_values($mein_array));
?>
5. array_search Durchsucht ein Array nach einem bestimmten Wert und gibt im Erfolgsfall den Index zurück.
<?php
$mein_array = array ('blä','blö','blü');
$found = array_search ('blö', $mein_array);
?>
6. array_unique Entfernt doppelte Werte aus einem Array und behält den Index bei.
<?php
$mein_array = array ('blä','blö','blü','blö');
$single = array_unique ($mein_array);
print_r ($single);
?>
7. in_array Prüft, ob ein bestimmter Wert in einem Array vorhanden ist und gibt im Erfolgsfall ein true zurück.
1. Einführung Reguläre Ausdrücke sind so genannte Suchmuster, nach denen man Text durchforsten kann. Dabei gibt es in PHP zwei "Konzepte", die sich vor allem in der Performance und Komplexität unterscheiden, die ereg- und die preg-Variante. Da es sich bei diesem Thema meines Erachtens nach um das Komplizierteste handelt, was die Programmierung zu bieten hat, habe ich darüber ein Tutorial verfasst. Hier gibt es erst mal nur einen gaaanz kurzen Überblick.
2. ereg Das ist die einfachere aber leider auch langsamere Methode. ereg, eregi Suchen nach Übereinstimmungen innerhalb einer Zeichenkette. Der Unterschied zwischen beiden Funktionen liegt darin, dass ereg zwischen Groß- und Kleinschreibung unterscheidet, eregi nicht.
<?php
$datum = '31.6.2006';
/* Überprüft, ob eine Variable das
korrekte deutsche Datumsformat hat */
if (ereg ("([0-9]{1,2})\.([0-9]{1,2})\.([0-9]{4})",$datum))
{
echo 'Jau, paßt';
}
?>
ereg_replace, eregi_replace Ersetzt einen Ausdruck durch einen anderen. Der Unterschied liegt wieder in der Groß- und Kleinschreibung, siehe oben.
<?php
// Macht aus einer normalen Mail-Adresse einen Link
Wow, sieht aus, als ob ich mich beim Schreiben zwischendurch auf meiner Tastatur abgestützt habe. Na ja, das ist ein Code-Schnipsel, den ich mir vor Jahren mal irgendwo her besorgt habe, um eine URL zu überprüfen. Selbst ich weiß nicht, was er genau bedeutet. split Eigentlich sollte diese Funktion ereg_split heißen, aber wieder mal war man beim Entwicklerteam nicht sehr sorgfältig, oder schreibfaul. Mit split kann man anhand eines regulären Ausdrucks eine Zeichenkette aufsplitten. Das Ergebnis wird als Array zurückgegeben.
<?php
$ip = '192.168.0.152';
// zerlegt eine ip in ihre Bestandteile
$seperator = split ("\.",$ip);
print_r($seperator);
?>
3. preg preg steht für Perl Regular E(G)xpressions und stammt, wie man schon am Namen erkennen kann, aus der Programmiersprache Perl. Sie wurde von einem Linguisten entwickelt und eignet sich vor allem für eine komfortable Verarbeitung von Zeichenketten. Die preg-Variante ist zwar deutlich schneller als ereg, aber auch um ein vielfaches komplizierter. preg_match, preg_match_all Beide Funktionen suchen nach einem Muster innerhalb einer Zeichenkette. Der Unterschied besteht darin, dass preg_match_all global sucht, das heißt es werden alle Treffer in ein Array geschrieben. Die Details kommen später beim geplanten Tutorial.
1. Einführung PHP bietet uns die Möglichkeit, andere PHP-Dateien in ein Script einzubinden und auszuführen. Damit haben wir die Möglichkeit, bei größeren Projekten bestimmte Bereiche in separate Dateien auszulagern und bei Bedarf zu nutzen. Das beste Beispiel dafür sind die Zugangsdaten für eine MySQL-Datenbank. Wenn man lokal eine Anwendung programmiert, so hat man mit ziemlicher Sicherheit andere Zugangsdaten, als wenn die Anwendung online bei einem Provider läuft. Also erstellt man ein separate Datei mit Benutzernamen, Passwort usw., bindet diese in die jeweiligen Scripte ein und muss dann später nur an einer Stelle die Werte ändern, wenn die Anwendung scharf geschaltet wird. Der Pfad zur einzubindenden Datei wird eigentlich immer relativ angegeben. PHP-Dateien von einer anderen URL können nur in Ausnahmefällen eingebunden werden, das heißt, wenn der entsprechende Webserver dies gestattet. Also geht mal nicht davon aus. Grundsätzlich gibt es zwei Möglichkeiten, die sich nur durch die Fehlerbehandlung unterscheiden.
2. include, include_once Bindet eine andere Datei ein. Bei Fehlern in dieser Datei oder einem falschen Pfad wird eine Warnung ausgegeben, der folgende Code aber trotzdem ausgeführt. Der Unterschied von include und include_once besteht darin, dass include_once eine bereits eingebundene Datei auf keinen Fall noch einmal inkludiert.
//db_data.inc.php
<?php
// lokale Zugangsdaten zu MySQL
$user = 'root';
$host = 'localhost';
$password = 'blabla';
$database = 'meine_test_db';
?>
//index.php
<?php
include ('db_data.inc.php');
?>
//index.php
<?php
include_once ('db_data.inc.php');
?>
3. require, require_once Arbeitet genau so wie include, bis auf einen Unterschied. Taucht in der einzubindenden Datei ein Fehler auf oder ist diese überhaupt nicht am angegebenen Ort vorhanden, so wird die weitere Bearbeitung des Scriptes mit einer "Fatal Error"-Meldung abgebrochen.
//db_data.inc.php
<?php
// lokale Zugangsdaten zu MySQL
$user = 'root';
$host = 'localhost';
$password = 'blabla';
$database = 'meine_test_db';
?>
//index.php
<?php
require ('db_data.inc.php');
?>
//index.php
<?php
require_once ('db_data.inc.php');
?>
4. Geltungsbereiche von Variablen Wie bei Funktionen gilt auch hier dasselbe Prinzip, das ich bei den Grundlagen erläutert habe. Variablen, die in einer eingebundenen Datei nicht innerhalb einer Funktion deklariert wurden, stehen global im Hauptscript zur Verfügung.
PHP - Befehle - Datenbanken
1. MySQL Ich werde mich in diesem Abschnitt ausschließlich mit MySQL beschäftigen, da ich ehrlich gesagt mich noch nie mit einem anderen Datenbanksystem beschäftigen musste, wenn es um PHP ging.
2. mysql_connect Stellt die Verbindung zu einer Datenbank her. Diese Funktion erwartet drei Parameter, den Host, Benutzernamen und das Passwort.
3. mysql_select_db Wählt die angegebene Datenbank aus. Dabei wird der so genannte "Zeiger" aus obigem Verbindungsaufbauscript benötigt.
<?php
mysql_select_db('meine_db',$db);
?>
4. mysql_query Sendet eine Anfrage an die Datenbank. Bei Änderungen innerhalb der Datenbank bekommt man ein true bzw. eine 1 zurück, wenn die Korrektur erfolgreich war, bei einer Suchanfrage erhält man einen "Zeiger", mit dem man das Ergebnis mit den folgenden Befehlen auswerten kann.
<?php
$result = mysql_query('SELECT * FROM meine_tabelle');
$result = mysql_query('UPDATE meine_tabelle SET ...');
?>
5. mysql_num_rows Liefert die Anzahl der gefunden Treffer einer Abfrage. Dabei muss der entsprechende "Zeiger" der Anfrage angegeben werden.
<?php
$result = mysql_query('SELECT * FROM meine_tabelle');
$num = mysql_num_rows ($result);
?>
6. mysql_fetch_irgendwas Um nun die Ergebnisse einer Anfrage auszuwerten, gibt es vier verschiedene Möglichkeiten, die sich nur in der Art und Weise der Ausgabe unterscheiden. Beachten muss man dazu Folgendes. Wenn man genau weiß, dass maximal ein(!) Treffer gelandet wird, so kann man den entsprechenden mysql_fetch_irgendwas-Befehl normal verwenden, ansonsten benötigt
man eine Schleife. Bei letzterem wird das Ergebnis in ein fortlaufend durchnummeriertes Array geschrieben. mysql_fetch_row Liefert das Ergebnis in einem numerischen Array zurück, pro abgefragtem Tabellenfeld eines. mysql_fetch_array Liefert das Ergebnis in einem numerisch-assoziativem Arrays zurück. Dabei werden pro Treffer für jedes abgefragte Tabellenfeld zwei Einträge erzeugt, einer mit einer fortlaufenden Nummer und einer mit dem Namen des Tabellenfeldes. mysql_fetch_assoc Liefert das Ergebnis in einem assoziativen Arrays zurück. Dabei wird für jedes abgefragte Tabellenfeld ein Index angelegt, der den Namen des Feldes trägt. mysql_fetch_object Liefert das Ergebnis als Objekt zurück. Habe ich noch nie benutzt, also geh fort.
<?php
$result = mysql_query('SELECT * FROM meine_tabelle');
// z.B. wir erwarten mehrere Treffer
while ($rows = mysql_fetch_assoc ($result))
{
...
}
// z.B wir haben definitiv nur einen Treffer
$rows = mysql_fetch_array ($result)
?>
PHP - Befehle - Dateisystem
1. Dateirechte unter Unix-Systemen Unix-Systeme kennen drei Berechtigungsstufen, den Besitzer, die Gruppe, den schäbigen Rest. Wenn ihr also mit folgenden Befehlen arbeitet, denkt immer daran, dass ihr über die notwendigen Rechte verfügt. Ein einfaches Beispiel: wenn man Daten per FTP-Programm auf den Webserver hochladet, so heißt der Besitzer ftpuser, wenn ihr dann mit PHP auf diese Dateien zugreift, so mit den Rechten des Users wwwrun.
2. opendir, closedir, chdir, readdir opendir öffnet ein ausgewähltes Verzeichnis und setzt einen "Zeiger", mit dem weitere Operationen möglich sind. closedir schließt das Verzeichnis. Mit chdir springt man in ein anderes Verzeichnis und readdir liest die Dateien im ausgewählten Verzeichnis aus.
<?php
$open = opendir ('bla/');
closedir ($open);
chdir ('blubb');
while ($file = readdir ($open))
{
echo $file.'<br>';
}
?>
3. chmod, umask chmod ändert die Zugriffsrechte für Ordner und Dateien. Allerdings nur diejenigen, für die das Script die entsprechenden Rechte hat. Gibt im Erfolgsfall true zurück. umask passt die aktuellen Zugriffsrechte an oder gibt sie zurück.
<?php
// Legt für alle User volle Zugriffsrechte fest
$mod = chmod ('bla/blubber.gif', 0777);
// Bei Problemen mit Dateiuploads vollbringt dies ware Wunder
$mask = umask (0);
?>
4. copy Kopiert eine Datei von A nach B und gibt im Erfolgsfall True zurück.
5. fopen, fclose fopen öffnet eine Datei, wenn die entsprechenden Rechte vorhanden sind. fclose schließt sie wieder. Parameter für fopen
• 'r' - öffnet eine Datei zum Lesen
• 'r+' - öffnet eine Datei zum Lesen und schreiben
• 'w' - öffnet eine Datei zum Schreiben. Ist die Datei nicht vorhanden, wird sie angelegt, existiert sie, wird der Inhalt gelöscht
• 'w+' - öffnet eine Datei zum Lesen und Schreiben. Ist die Datei nicht vorhanden, wird sie angelegt, existiert sie, wird der Inhalt gelöscht
• 'a' - öffnet eine Datei zum Schreiben. Ist schon Inhalt vorhanden, bleibt der erhalten und alles Neue wird dahinter geschrieben
• 'a+' - öffnet eine Datei zum Lesen und Schreiben. Ist schon Inhalt vorhanden, bleibt der erhalten und alles Neue wird dahinter geschrieben
<?php
$file = fopen ('bla/blubber.txt', 'r')
?>
6. fgets, fwrite fgets liest eine Zeile innerhalb einer Datei aus. Die Aktion wird am Zeilenende abgebrochen. Dafür muss die Datei vorher mit fopen geöffnet werden. fwrite schreibt Zeichenketten in die Datei.
<?php
while ($line = fgets ($open))
{
echo $line.'<br>';
}
$write = fwrite ($open,'blubb blubber');
?>
7. is_wasweissichnicht Nimmt Überprüfungen im Dateisystem vor. Dabei gibt es folgende Funktionen:
• is_dir (überprüft, ob es sich um ein Verzeichnis handelt)
• is_file (überprüft, ob es sich um eine Datei handelt)
• is_readable (überprüft, ob eine Datei gelesen werden darf)
• is_writeable (überprüft, ob eine Datei geschrieben werden darf)
• is_executable (überprüft, ob eine Datei ausführbar ist)
<?php
if (is_writeable ('blubb.txt'))
?>
8. file_exists Überprüft, ob eine Datei existiert.
<?php
if (file_exists ('blubber.txt'))
?>
9. filesize Gibt die Größe einer Datei in Byte zurück. Allerdings muss man über das lokale Dateisystem darauf zugreifen können.
