Sie sind auf Seite 1von 15

GKInf 2009/10 PHP Begleitskript

Hinweis: für Detailfragen benutze SELFHMTL bzw. SELFPHP (www.selfphp.de)

Wir benutzen grundsätzlich PHP innerhalb von HTML-Code. Dazu brauchen wir nur

<?php......unser Code.....?>

in den HTML-Quelltext einzufügen.

Enthält unser HTML-Text vorwiegend PHP. so sollte er mit der Endung .php statt .html
abgespeichert werden. Damit wird ein PHP-Programm nur noch zu <?php ................?>.

Alle Befehle (und Zeilen) in PHP werden durch einen Strichpunkt ; abgeschlossen.

Die Ausgabe erfolgt mit

echo ..... oder print ......

Bsp: echo string; bzw print string;

Mehrere strings hintereinander erhalten das Komma als Trennzeichen:

echo "Erster", " ", "April";

Im string dürfen HTML-Steuerzeichen wie <br> vorkommen. Sie werden vom Browser richtig
ausgeführt.

Ein string ist eine Zeichenkette, die mit einem (oberen) Anführungszeichen " beginnt und endet.
Mit Einschränkungen kann man auch ein Hochkomma ' statt dem Anführungszeichen " verwenden.

Zwei strings werden durch einen Punkt zusammengesetzt : string1 . string2


Bsp.: echo "Das" . " " . "war es";

Alle Variablen beginnen mit dem Dollarzeichen $. Als nächstes Zeichen ist entweder der
Unterstrich _ oder ein Buchstabe zu verwenden. Die Groß- und Kleinschreibung ist zu wichtig :
$Halt und $halt sind zwei verschiedene Variablen.

Variablen können Zeichenketten oder Zahlen als Inhalt haben. Dies wird bei der Wertzuweisung
entschieden:

String-Variablen : $a = "a"; $b = "b1"; $c = "12";


Zahlenvariablen : $e1 = 123; $f2g = 24.5; $g88h = 2.1e-2;
Achtung : Zahlen der Form 0123 mit führender Null sind Oktalzahlen (Achtersystem), Zahlen der
Form 0x123 sind Hexadezimalzahlen

Ein Array ist eine (durchnummerierte) Zusammenfassung mehrerer Variablen zu einem Ganzen :

Bsp.: $a[0] = "OHG";

1
GKInf 2009/10 PHP Begleitskript

$a[1] = 78532;
$a[2] = "Tuttlingen";

Kommentare werden bei der Programmausführung überlesen. Bei einem Kommentar von einer
Zeile Länge beginnt die Zeile mit // (oder #), bei mehreren Zeilen beginnt der Kommentar mit /*
und endet mit */:

// Dies ist ein einzeiliger Kommentar


/* Dies ist ein Kommentar
von mehreren Zeilen */

Zur Eingabe benutzen wir HTML-Formulare :

<form method="post" action="unsere Zieldatei.php">


Text zum ersten Eingabefeld <input name = "erster Variablenname"><p></p>
Text zum zweiten Eingabefeld <input name = "zweiter Variablenname"><p></p>
............................................................
<input type = "submit"> <input type = "reset">
</form>

Um die Eingaben in unserem PHP-Programm unsere Zieldatei.php verarbeiten zu können, müssen


wir sie ausdrücklich aus dem Array _POST einlesen :

$a = $_POST['erster Variablenname'];
$b = $_POST['zweiter Variablenname'];
...................

Bei einer Fallunterscheidung oder Verzweigung wird geprüft, ob die Bedingung erfüllt ist oder
nicht und je nachdem ein anderer Programmcode ausgeführt :

if (Bedingung)
Anweisung1;
else
Anweisung2;

Bei mehreren Anweisungen müssen diese durch Klammern {} zu einer zusammengefasst werden :

if (Bedingung)
{ Anweisung1;
........................
letzte Anweisung;}
else
{ Anweisung1;
........................
letzte Anweisung;}

2
GKInf 2009/10 PHP Begleitskript

Schleifen :

Computer sind nur dann nützlich, wenn sie die gleiche Operation viele Male hinter einander
ausführen. Dazu dienen Schleifen.

Ist von vornherein schon bekannt oder berechenbar, wie oft eine Schleife durchlaufen werden soll,
so nimmt man eine Zählschleife :

for ( Schleifenvariable = Anfangswert ; Abbruchbedingung ; Erhöhung der Schleifenvariablen )


{
Anweisungen ;
}

Bsp: Ausgabe der Quadrate der Zahlen von 1 bis 10 :

for ( $n = 1 ; $n <= 10 ; $n++)


{
echo $n*$n;
}

Ist nicht bekannt, wie oft die Schleife durchlaufen werden wird, so nimmt man eine der beiden
Schleifen mit while :

a) while (Bedingung erfüllt)


{ Anweisungen ; }

b) do
{ Anweisungen ; }
while (Bedingung erfüllt)

In Schleife b) werden im Gegensatz zur Schleife a) die Anweisungen mindestens einmal ausgeführt,
da erst am Schluss der Schleife die Überprüfung erfolgt.

Bsp: Alle Quadratzahlen, die kleiner als 900 sind :

a) $n = 1;
while ( $n*$n < 900)
{
echo $n*$n;
$n++;
}

b) $n = 1;
do
{ echo $n*$n; $n++; }
while ($n*$n < 900)

3
GKInf 2009/10 PHP Begleitskript

Schleifen lassen sich vorzeitig durch den Befehl break beenden:

for ($i=1; $i == 100; $i++)


{
..................
if ($i > 35) break;
..................
}

Hier wird die Schleife bei i = 36 beendet.

Mit dem Befehl continue lässt sich der Rest der Anweisung in der Schleife überspringen und sofort
ein neuer Schleifendurchlauf starten :

for ($i=1; $i == 100; $i++)


{
Anweisung 1;
if ($i == 35) continue;
Anweisung 2;
}

Bei i=35 wird im Gegensatz zu allen sonstigen Schleifendurchläufen nur Anweisung 1 ausgeführt.

Mit dem Befehl die( auszugebender Text ) kann das ganze Programm mit Ausgabe einer
Fehlermeldung beendet werden.

Ergänzungen :

a) Eine zufällige Zahl bekommt man durch die Funktion rand(). Ohne Parameter liefert sie eine
Zufallszahl zwischen 0 und der Konstanten RAND_MAX. Wie groß RAND_MAX ist, zeigt die
Funktion getrandmax() an. Ein Aufruf der Form rand(kleinste Zahl, größte Zahl) mit ganzen
Zahlen ergibt zufällige ganze Zahlen in diesem Bereich. Mit srand(zufällige ganze Zahl) lässt
sich der Zufallszahlengenerator neu starten.

b) sqrt(Zahl) ergibt die Quadratwurzel


round(Zahl [, Nachkommastellen]) rundet die Zahl auf die angebene Zahl von
Nachkommastellen.
abs(Zahl) liefert den Betrag
sin(..), cos(..), tan(..) und ihre Umkehrfunktionen asin(..), acos(..), atan(..) existieren (Achtung :
es gilt das Bogenmaß).
log(..) ist der natürliche Logarithmus ln, log10(..) der Zehnerlogarithmus
exp(x) ist ex
fmod(x,y) liefert den Rest bei der Division x durch y
pi() ist die Zahl Pi
pow(basis, exponent) ist basisexponent

4
GKInf 2009/10 PHP Begleitskript

Damit ein Programm nicht zu lang und damit zu unübersichtlich wird (Fehlerbeseitigung !) muss
es in Teilprogramme zerlegt werden. Dazu dienen Funktionen :

function Name_der_Funktion(...)
{
Anweisungen;
...............
}

Bsp:
function Fehlermeldung()
{
echo "Es ist ein Fehler aufgetreten";
}

Diese Funktion wird im Hauptprogramm durch die Anweisung


Fehlermeldung();
aufgerufen.

An eine Funktion können Werte als Parameter übergeben werden :


function Name_der_Funktion($Variablenname)
{ ................... }
und das aufrufende Programm kann einen Rückgabewert erhalten, der hinter dem Befehl return
steht :

Bsp:
function hochdrei($zahl)
{
return $zahl*$zahl*$zahl;
}

$a = 3;
echo hochdrei($a);

Beim Aufruf der Funktion kann ein anderer Variablenname verwendet werden als bei der
Definition. Und selbstverständlich kann eine Funktion auch mehrere Parameter enthalten (aber
nur einen Rückgabewert !) :

function n_te_Potenz($basis, $hochzahl)


{
$potenz = 1;
for (i = 1; i <= $hochzahl; i++)
{ $potenz = $potenz*$basis }
return $potenz;
}

// Aufruf im Hauptprogramm mit :


$ergebnis = $potenz($a,$n);

5
GKInf 2009/10 PHP Begleitskript

Grafik mit PHP:

Auch wenn der Befehlssatz nicht allzu umfangreich ist, lassen sich auch Grafiken mit PHP
(Ergänzungen sind in PEAR enthalten) erstellen.

Ein farbiges Rechteck erhält man mit

<?php
$image = imagecreate(300,150);
$farbe_body = imagecolorallocate($image, 100,0, 200);
header('Content-Type: image/gif');
imagegif($image);
?>

imagecreate legt ein Bild mit dem angegebenen Variablennamen $image und der Größe 300
Punkte waagrecht und 150 Punkte senkrecht an. imagecolorallocate gibt diesem Bild seine
Farbe. Die Intensität von Rot, Grün und Blau wird direkt mit Werten zwischen 0 und 255 (1
Byte) eingegeben.
Den header brauchen wir, damit der Typ des Bildes (gif, png, jpg) vom Browser erkannt wird.
Schließlich führt der Befehl imagegif zur Aussageb des Bildes.

Ein weiteres Beispiel :

<?php
$image = imagecreate(400,300);
$farbe_body = imagecolorallocate($image,200,200,200);
$Schwarz = imagecolorallocate($image,0,0,0);
$weis = imagecolorallocate($image,255,255,255);
$red = imagecolorallocate($image,255,0,0);
$blau = imagecolorallocate($image,100,100,255);
imagefill($image, 0, 0, $farbe_body);
imageline($image, 300, 0, 300, 300, $red);
imageline($image, 300, 150, 400, 150, $red);
imagefill($image, 301, 0, $blau);
imagefilledrectangle($image, 50, 50, 250, 250, $weis);
//1.Punkt
$punkte[] = 0; $punkte[] = 0;
//2.Punkt
$punkte[] = 50; $punkte[] = 20;
//3.Punkt
$punkte[] = 100; $punkte[] = 100;
//4.Punkt
$punkte[] = 250; $punkte[] = 120;
//5.Punkt
$punkte[] = 400; $punkte[] = 270;
//6.Punkt
$punkte[] = 400; $punkte[] = 273;

6
GKInf 2009/10 PHP Begleitskript

//7.Punkt
$punkte[] = 250; $punkte[] = 150;
//8.Punkt
$punkte[] = 100; $punkte[] = 130;
//9.Punkt
$punkte[] = 50; $punkte[] = 23;
//10.Punkt
$punkte[]= 0; $punkte[]= 3;
imagefilledpolygon ($image, $punkte, count($punkte)/2, $red);
//header("Content-Type: image/gif");
//imagegif($image);
//header("Content-Type: image/png");
//imagepng($image);
header("Content-Type: image/jpeg");
imagejpeg($image,"",100);
imagedestroy($image);
?>

imagefill füllt das Bild mit der angegebenen Farbe.


imageline zeichnet eine Strecke (Achtung : der Ursprung liegt links oben, die y-Achse geht nach
unten)
imagefilledrectangle zeichnet ein ausgefülltes Rechteck mit waagrechten und senkrechten Seiten.
imagefilledpolygon zeichnet ein Vieleck, bei dem die Koordinaten der Eckpunkte im Array
$punkte gespeichert sind.
imagedestroy löscht unsere Arbeit wieder.

Die weiteren Grafikbefehle entnimmt man am besten SelfPHP.

Aufgaben :

1) Zeichne eine Schar von Ursprungsgeraden.

2) Zeichne mehrere ineinander geschachtelte Quadrate.

3) Zeichne ein um 30o gedrehtes Quadrat.

4) Zeichne mehrere Quadrate, deren Größe abnimmt und die immer weiter gedreht sind, aber
eine Ecke gemeinsam haben.

5) Zeichne mehrere konzentrische Kreise.

6) Zeichne mehrere konzentrische Ellipsen.

7) Experimentiere weiter.

7
GKInf 2009/10 PHP Begleitskript

Objektorientiertes Programmieren mit PHP

Unseren bisherigen Programme waren prozedurale Programme. Sie bestanden aus Variablen,
Operationen mit diesen Variablen und Funktionen. Bei großen Programmen wird eine solche
Vorgehensweise schnell unübersichtlich und damit fehleranfällig.

Um hier Abhilfe zu schaffen werden bei objektorientierten Programmieren die Variablen


zusammen mit den Funktionen, die für diese Variablen erlaubt sind, zu größeren Einheiten
zusammen gefügt.

Konkret: In einer Klasse befinden sich die Variablen und die dafür vorgesehen Funktionen. Diese
Klasse ist zunächst nur der Bauplan. Um sie anwenden zu können muß mit new eine neue
Variable vom Typ dieser Klasse erzeugt werden :

<?php
// Klassen – Definition
class Produkt
{
// Klassen – Eigenschaften
public $name = "Vaio X20";
public $hersteller = "Sony";
public $preis = 1999.95;

// Klassen – Methode
public function Kaufen($kaeufer)
{
echo "Käufer: $kaeufer\n";
echo "Verkauf eines ";
echo $this->name . " von ";
echo $this->hersteller . "\n";
echo "-------------------\n";
echo "Preis: " . $this->preis;
}
}

// Objekt – Erzeugung
$einkauf = new Produkt();
$einkauf2 = new Produkt();

// Methoden – Aufruf
echo "Onlineshop: <br>";
$einkauf->Kaufen("Caroline");
echo "<br>";
$einkauf2->Kaufen("Hansi");

?>

8
GKInf 2009/10 PHP Begleitskript

Es folgen nun die Grundrechenarten mit Hilfe von Klassen :

<?php

class Rechnen
{
public $a;
public $b;

public function Addition()


{
return $this->a + $this->b;
}

public function Subtraktion()


{
return $this->a - $this->b;
}
}

$Test = new Rechnen();

$Test->a = 666;
$Test->b = 222;

echo $Test->Addition(), "<br>";


echo $Test->Subtraktion() ;

?>

Wichtig bei Klassen ist, dass sie ihre Eigenschaften vererben können. So kann aus einer
Basisklasse eine neue abgeleitete Klasse (durch das Schlüsselwort extends )erstellt werden, die
außer den Funktionen (und Variablen) der Basisklasse zusätzlich noch eigene weitere Funktionen
mitbringt. Sie besitzt dann sowohl die Funktionen und Variablen der Basisklasse als auch ihre
neuen Funktionen und Variablen :

<?php

class Rechnen
{
public $a;
public $b;

public function Addition()


{
return $this->a + $this->b;
}

9
GKInf 2009/10 PHP Begleitskript

public function Subtraktion()


{
return $this->a - $this->b;
}
}

class Rechnen1 extends Rechnen


{
public function Multiplikation()
{
return $this->a * $this->b;
}

public function Division()


{
return $this->a / $this->b;
}
}

$Test = new Rechnen();

$Test->a = 666;
$Test->b = 222;

echo $Test->Addition(), "<br>";


echo $Test->Subtraktion(), "<br>" ;

$Test1 = new Rechnen1();

$Test1->a = 333;
$Test1->b = 111;

echo $Test1->Addition(), "<br>";


echo $Test1->Division(), "<br>" ;

?>

Die Funktionen und Variablen einer Klasse können nur einen beschränkten Zugriff erlauben :

Steht public davor, so ist der Zugriff nicht eingeschränkt.


Steht private davor, so ist der Zugriff nur innerhalb der Klasse selbst erlaubt.
Bei protected ist der Zugriff innerhalb der Klasse sowie innerhalb aller abgeleiteten Klassen
erlaubt

Mit final kann eine Funktion oder eine Klasse als endgültig markiert werden. Damit können sie
in abgeleiteten Klassen nicht mehr überschrieben werden.

10
GKInf 2009/10 PHP Begleitskript

.............................................................
class Rechnen2 extends Rechnen1
{
final function Potenz()
{
$erg = $this->a;
for ($i = 1; $i < $this->b; $i++) $erg = $erg * $this->a;
return $erg;
}
}

class Rechnen3 extends Rechnen2


{
public function Potenz()
{
return pow($this->a, $this->b);
}
private function pi()
{
return 3;
}

public function Kreisfläche()


{
return $this->a*$this->a*$this->pi();
}
}

Hier führt der Versuch, in der Klasse Rechnen3 die Funktion Potenz() aus der Klasse Rechnen2
zu überschreiben zu einer Fehlermeldung und zwar gleich beim Programmstart, da der PHP-
Interpreter zunächst den Programmkode parst, also durchliest und kontrolliert und dann sofort
auf den Fehler stößt.

Beim Bau eines wird zuerst der Bauplan angefertigt und erst dann mit der konkreten Ausführung
begonnen. Genau so ist gerade bei größeren Programmen es sinnvoll, zuerst die Eigenschaften
anzugeben und erst dann zur konkreten Implementierung zu schreiten. Ein typisches Beispiel
dafür ist die Objektschnittstelle oder das Interface :

interface Grundrechenarten
{
function Addition();
function Subtraktion();
function Multiplikation();
function Division();
}

Hier ist nur grundsätzlich festgelegt, dass bei den Grundrechenarten Addition, Subtraktion,
Multiplikation und Division zu Verfügung stehen sollen.

11
GKInf 2009/10 PHP Begleitskript

Um das Ganze zu nutzen, muss jetzt eine Klasse erstellt werden, die vom Interface
Grundrechenarten abgeleitet wird und die vorgegebenen Funktionen als Rechenvorschriften
erstellt:

class Rechnen1 implements Grundrechenarten


{
public $a;
public $b;

public function Addition()


{
return $this->a + $this->b;
}

public function Subtraktion()


{
return $this->a - $this->b;
}
public function Multiplikation()
{
return $this->a * $this->b;
}

public function Division()


{
return $this->a / $this->b;
}

Das Stichwort implements statt extends deutet an , dass hier eine abstrakte Klasse zum Leben
erweckt wird.
Der Vorteil eines solchen Vorgehensweise liegt darin, dass in einer zweiten Klasse Rechnen2 die
Implementierung anders aussehen könnte :

public function Multiplikation()


{
private $c = 1;
for ($i = 1 ; $i <= $this->b; $i++)
{ $this->c = $this->c * $this->a ; }
return $this->c;
}

Ergänzungen :
mit clone kann eine Klasse kopiert werden :
$a = new meine_Klasse;
$b = clone $a;
mit const könne konstante Werte definiert werden :
const a = 111;

12
GKInf 2009/10 PHP Begleitskript

PHP undMySQL

MySQL ist ein bekannter kostenloser Datenbankserver, der bei uns als Dienst im Hintergrund in
XAMPP läuft. Er soll uns dazu dienen, erste Einblicke in die Verwaltung von Datenbanken zu
gewinnen.

Um eine Datenbank anzulegen und grundsätzlich zu verwalten benutzen wir das freie PHP-
Programm PHPMyAdmin, das ebenfalls in XAMPP enthalten ist. Damit bekommen wir über den
Browser mit der Eingabe "127.0.0.1/phpmyadmin" den direkten Datenbankzugriff.

Nach dem Anlegen der Datenbank können wir über PHP-Befehle auf sie zugreifen. Dabei ist es
typisch, dass PHP die SQL-Befehle an MySQL absetzt.

Zugriff auf die Datenbank (als Teil eines PHP-Programmes) :

$server = 127.0.0.1; // Angabe der IP-Adresse des Servers


$Benutzer = ""; //In der Praxis folgt hier die Angabe der Bnutzerkennung
$Kennwort = ""; // und seines Passwortes

$verbindung = mysql_connect($server, $Benutzer, $Kennwort); //Verbindung zum Server


herstellen

mysql_select_db("Lokomotiven", $verbindung); //Datenbank Lokomotiven auswählen

$sql = "SELECT * FROM DB"; //alle Inhalte der Tabelle DB auswählen

$erg = mysql_query($sql, $verbindung); //kommt die Verbindung zustande ?

while($Zeile = mysql_fetch_object($erg) //Zeile für Zeile auslesen


{
echo "Baureihe ", $Zeile->Baureihe, ", Leistung ", $Zeile->Leistung, "kW, Masse ", $Zeile-
>Masse , " t, ","<b>";
}

mysql_free_result($erg); //$erg auf Null setzen


mysql_close($verbindung); //Verbindung abbrechen

Wollen wir nicht die ganze Tabelle sondern nur einzelne Spalten auslesen, müssen den SQL-
Befehl SELECT FROM modifizieren :

$sql ="SELECT Baureihe, Leistung, Masse FROM DB";


liefert nur Baureihe, Leistung und Masse.

Mit SELECT * FROM tabellenname WHERE Bedingung erhalten wir nur die Datensätze, die
eine gewisse Bedingung erfüllen :

$sql = "SELECT * FROM Lokomotiven WHERE Baureihe = 103" liefert nur die Angaben zur
Baureihe 103.

13
GKInf 2009/10 PHP Begleitskript

PHP kennt nur relativ wenige Befehle, um direkt auf eine Datenbank von MySQL zuzugreifen.
Normalerweise übergibt es nur die entsprechenden MySQL-Befehle an den Datenbankserver.
Das war bereits hier der Fall :

$sql = "SELECT * FROM DB";


$erg = mysql_query($sql, $verbindung);

In der Variablen $sql wird der Befehl 'SELECT * FROM Datentabelle' als String gespeichert und
dann mit der Funktion mysql_query() an den Datenbankserver weitergeleitet. Das Ergebnis $erg
dieser Funktion ergibt bei Erfolg true sonst false.

Damit kann man das Einlesen neuer Datensätze programmieren

$br = $_POST['Baureihe'];
$P = $_POST['Leistung'];
$m = $_POST['Masse'];
$l = $_POST['Länge'];
$v = $_POST['Geschwindigkeit'];
$n = $_POST['Anzahl'];
…...................................................................
$sql = "INSERT INTO `DB` VALUES ($br, $P, $m, $l, $v, $n)";
$erg = mysql_query($sql);

oder die Datensätze sortiert auslesen

$sql = "SELECT * FROM `DB` ORDER BY Leistung";


$erg = mysql_query($sql);

Auch das Löschen eines einzelne Datensatzes erfolgt analog :

$sql = "DELETE FROM `DB` WHERE Name_der_Spalte = gesuchter Begriff LIMIT 1";
$erg = mysql_query($sql);

LIMIT 1 sorgt hier dafür, dass jeweils nur ein Datensatz gelöscht wird (sonst würden alle
gelöscht).

Zum Ändern der Daten in einer Datenbank kann der Befehl UPDATE benutzt werden :

$sql = "UPDATE `DB` SET `Baureihe` = …., `Leistung` = …., ….. WHERE
Name_der_Spalte = gesuchter Begriff ";
$erg = mysql_query($sql);

WHERE wählt jeweils den zu ändernden Datensatz aus.

14
GKInf 2009/10 PHP Begleitskript

15