PHP
Willemers Informatik-Ecke
PHP ist eine Programmiersprache, um Webseiten interaktiv zu machen. Wie bei Javascript findet man den Source im HTML, im Unterschied zu JavaScript wird PHP allerdings auf dem Webserver ausgeführt.

Installation und Konfiguration

PHP wird unter Linux (hier Debian, Ubuntu oder Linux Mint) installiert, indem das Paket libapache2-mod-php für apache installiert wird. Falls der Apache noch nicht eingerichtet war, muss das Paket apache2 gleich mitinstalliert werden. 
# apt-get install apache2 libapache2-mod-php
Anschließend muss PHP aktiviert werden. Dazu sind folgende Schritte erforderlich: 
# a2dismod mpm_event
# a2enmod php7.2
# systemctl restart apache2
Erzeugen Sie nun im Verzeichnis /var/www/html eine Datei index.php mit folgendem Inhalt: 
<html>
<body>
Huhu!
<br>
<?php phpinfo(); ?>
</body>
</html>
Anschließend rufen Sie einen Browser auf und geben die Adresse http://localhost/index.php ein. Es müsste Huhu! erscheinen und eine Info über das installierte PHP. Erscheint nur ein Huhu, dann funktioniert PHP nicht. Sollte es andere Fehlermeldungen geben, ist der Apache nicht korrekt installiert.

PHP in HTML einbinden

Der PHP-Interpreter wird vom Webserver (Apache) ausgeführt, bevor eine angeforderte Datei an den Client gesandt wird.

Die Sprache PHP

PHP ähnelt in der Syntax an vielen Stellen C und seinem Nachfahren C++. Befehle werden beispielsweise durch Semikolen getrennt. Blöcke werden duch geschweifte Klammern definiert. Die mathematischen und logischen Operatoren sind weitgehend gleich.

Kommentare

Kommentare sollten erklären, was sich der Programmierer gedacht hat. Stehen im Programm keine Kommentare, liegt der Verdacht nahe, dass der Programmierer überhaupt nicht gedacht hat.

Erscheint im Kommentar ein ?>, so wird dies sehr wohl vom Interpreter wahrgenommen.

Variablen

Variablen werden als solche durch ein vorangestelltes $-Zeichen gekennzeichnet. Sie erhalten ihren Typ durch Zuweisung eines Wertes.

PHP kennt boolesche und ganzzahlige Typen, Fließkommavariablen und Strings. Die Variablen erhalten ihren Typ durch Zuweisung. Der Typ wird nicht deklariert. 

$wert = 12.4;   // Fließkommavariable
$name = "Hugo"; // String / Zeichenkette

Arrays

Ein Array ist in der Lage mehrere gleichartige Werte aufzunehmen. Diese Werte haben miteinander zu tun und werden typischerweise durch Schleifen bearbeitet. Ein typisches Beispiel für ein Array sind die Lottozahlen. Es handelt sich um sechs ganzzahlige Werte, die gezogen, sortiert oder ausgegeben werden. Immer wird das Programm sich sechs Mal wiederholen, um diese sechs Werte zu bearbeiten.

Ein Array wird syntaktisch durch die rechteckigen Klammern gekennzeichnet. Das folgende Listing legt eine Liste von Leuten an, die wir zu einer Party enladen wollen: 

$name[0] = "Hugo";   // das erste Element liegt an Position 0!
$name[1] = "Erna";
$name[] = "Eulalia"; // Steckt Wert in das nächste freie Element, hier Pos 2.
Die Initialisierung kann einfacher so erfolgen: 
$name = array("Hugo", "Erna", "Eulalia");

In den rechteckigen Klammern müssen nicht zwingend ganzzahlige Werte stehen. Stattdessen können auch Strings verwendet werden. Dadurch entsteht ein assoziativer Speicher. 

$kennzeichen["SL"] = "Schleswig-Flensburg";

Abfragen und Schleifen

Abfrage if

if (Bedingung1) {
    // Bedingung1 tritt ein
} elseif (Bedingung2) {
    // Bedingung2 trat ein, Bedingung1 aber nicht
} else {
   // Alle anderen Fälle
}
Alternative Syntax für alle, die eine Allergie gegen geschweifte Klammern haben: 
if (Bedingung1):
    // Bedingung1 tritt ein
elseif (Bedingung2):
    // Bedingung2 trat ein, Bedingung1 aber nicht
else:
   // Alle anderen Fälle
endif;

Bedingungen

Vergleichsoperatoren Verknüpfung boolescher Ausdrücke

Schleife while

while (Bedingung) {
    // läuft, solange die Bedingung gilt
}
Die Abfrage ist am Kopf der Schleife.

Alternative Syntax für alle, die eine Allergie gegen geschweifte Klammern haben: 

while (Bedingung):
    // läuft, solange die Bedingung gilt
endwhile;

Die Abfrage am Fuß bewirkt, dass die Schleife mindestens ein Mal durchlaufen wird. 

do {
    // läuft mindestens einmal, aber nur solange Bedingung gilt
} while (Bedingung);

Zählschleife for

Mit Schleifen kann man prima Arrays durchlaufen. Am besten kann das die for-Schleife. Die beiden könnten also heiraten. 

for ($i=0 ; $i<10 ; $i++) {
     echo $lotto[$i];
}
In den Klammern der for-Schleife befinden sich drei Ausdrücke (expression). Um Arrays noch effizienter durchlaufen zu lassen, gibt es die Schleife foreach. 

foreach ($meinarray as $index => $wert) {
     echo "[".$index."]".$wert.' - ';
 }

Funktionen

Eine Funktion ist die Zusammenfassung mehrerer Anweisungen unter einem neuen Namen, der von beliebiger Stelle im Programm aufgerufen wird. Eine Funktionsdefinition wird durch das Schlüsselwort function eingeleitet. 
function tudochwas() {
    // beliebig viele Anweisungen
}

Der Aufruf erfolgt durch Nennung des Funktionsnamens gefolgt von einem Klammerpaar. Im Falle von Parametern werden diese zwischen die Klammern geschrieben. 

tudochwas();

Rückgabe von Werten

Mit dem Befehl return gibt die Funktion einen Wert an den Aufrufer zurück. 
function tudochwas() {
    // beliebig viele Anweisungen
    return $einwert;
}
Der Aufrufer kann den Wert in einem beliebigen Ausdruck verwenden, im einfachsten Fall weist er ihm einer Variablen zu. 
$ergebnis = tudochwas();

Parameter

Funktionen können Parameter haben. Dann wird der Funktion vom Aufrufer übergeben, mit welchen Werten sie arbeiten sollen. 
function inhalt($laenge, $breite) {
    return $laenge * $breite);
}
Die Parameter können vorbesetzt werden. 
function inhalt($laenge, $breite=10) {
    return $laenge * $breite);
}
Parameter werden normalerweise kopiert. Das bedeutet, dass der Aufrufer sicher sein kann, dass er die Variable, die er als Parameter übergibt, nach dem Aufruf immer noch unverändert vorfindet.

Wollen Sie den Aufrufer aber foppen, dann können Sie mit dem kaufmännischen Und (&) aus dem Paramter einen Referenzparameter machen, der ein Verändern der Aufrufervariable erlaubt.

Lokale und globale Variablen

Wird innerhalb einer Funktion auf eine Variable zugegriffen, geht PHP davon aus, dass eine lokale Variable gemeint ist. Ggf. wird diese Variable dann erzeugt.

Soll dagegen auf eine Variable außerhalb der Funktion zugegriffen werden, dann muss diese als global deklariert werden. 

$weite = 14;
function rufmich() {
    global $weite;
    $weite = 13;
}

Statische Variablen

Die lokalen Variablen einer Funktion verlieren beim Verlassen der Funktion ihren Wert. Mit dem Zauberwort static ist es möglich, dass sie sich beim nächsten Eintritt in die Funktion erinnern, welchen Wert sie zuletzt hatten.

Java-Programmierer müssen sich etwas umgewöhnen. Dort bedeutet static etwas anderes.

Klassen

PHP kann auch Klassen definieren. Klassen sind eine Mischung aus Variablen und Funktionen und dienen vor allem dazu, die Realität zu modellieren und die Programme sinnvoll zu modularisieren. 

class Person {
    $name = "Hugo";
    function getName() {
        return this->name;
    }
}

Ein Objekt einer Klasse wird durch den Befehl new erzeugt. Über das Objekt werden die Klassenelemente über einen Pfeil erreicht, der aus Minuszeichen und Größerzeichen erzeugt wird. 

$freund = new Person;
$freund->getName();

Auch das Vererben von Klassen ist über das Schlüsselwort extends möglich. Dabei erbt die Klasse alles von ihrer Basisklasse, ohne dass das noch einmal explizit genannt werden muss. 

class Mitarbeiter extends Person {
    $krankenkasse;
}

HTTP-Methoden GET und POST

PHP arbeitet als Interpreter auf einem Webserver. Die Sprache wird also aktiv, wenn ein Client etwas vom Server will. Als Protokoll verwenden Webserver HTTP (Hypertext Transfer Protocol).

Dieses Protokoll kennt mehrere Methoden, die häufigst eingesetzten sind GET für das Holen einer Seite und POST für das Senden von Formularinhalten.

Anfragen per GET

Wird eine GET-Anfrage an den Server gesendet, können der URL neben der Adresse des Servers und dem Pfad der Datei auch noch weitere Parameter übergeben werden, die duch ein Fragezeichen abgetrennt werden.

www.willemer.de/informatik/web/testget.php?wert=4711&name=Arnold

Wurde eine PHP-Seite mit dieser URL aufgerufen, kann sie über das assoziative Array _GET die übergebenen Variablen auslesen. Die folgende Web-Seite führt dies vor: 

<html>
<head>
</head>
<body>
Wert = <?php echo $_GET['wert']; ?>
<br>
Name = <?php echo $_GET["name"]; ?>
</body>
</html>

Auswerten eines POST-Formulars

Besonders einfach ist die Auswertung von Formularen in PHP. Zunächst muss ein Formular erstellt werden. Als Aktion des Formulars wird eine weitere PHP-Webseite angegeben. Jedes der Eingabeelemente erhält dabei einen Namen. Diese Namen können auf der aufgerufenen PHP-Webseite direkt als PHP-Variablen ausgelesen werden. 

<FORM ACTION=verarbeite.php METHOD=POST>
<INPUT TYPE="TEXT" NAME="name" SIZE=30>
<BR>Per Mail versenden
<INPUT TYPE="checkbox" NAME="versenden">
<BR>
<INPUT TYPE="SUBMIT" VALUE="Abschicken">
</FORM>

Bei Betätigung des Submit-Buttons wird die Seite verarbeite.php aufgerufen. Hier stehen die Variablen name und versenden zur Verfügung. 

<?php
  echo ("Name: $name <BR>");
  echo ("Versenden: $versenden <BR>");
  if ($versenden=="on") {
    echo ("mach mail auf");
    mail("arnold@localhost", "Betreff: PHP-Test",$name);
  }
?>

PHP 5.0 liest die übergebenen Variablen nicht direkt, sondern verwendet ein assoziatives Array namens $_POST, bei dem der Variablenname als Index verwendet wird. Das obige Beispiel muss dann so aussehen: 

<?php
  echo ("Name: $_POST['name'] <BR>");
  echo ("Versenden: $_POST['versenden'] <BR>");
  if ($_POST['versenden']=="on") {
    echo ("mach mail auf");
    mail("arnold@localhost", "Betreff: PHP-Test",$_POST['name']);
  }
?>

Die Funktion mail sendet Nachrichten per E-Mail. Der erste Parameter ist die E-Mailadresse, der zweite der Betreff (subject) und der dritte Parameter enthält den Inhalt der Mail.

Anstatt das Formular und die Bearbeitung in zwei Dateien aufzuteilen, kann dies auch in einer Seite erledigt werden. Dazu kann gleichzeitig die Fehlerbehandlung durchgeführt werden. Die Grundidee besteht darin, dass das Formular in einer Textvariablen abgelegt wird. In einer Variablen, die wir hier firsttime nennen, wird festgehalten, ob die Seite das erste Mal aufgerufen wird und entsprechend angezeigt werden muss. Die action im Formular zeigt auf die eigene Datei namens checkform.php. 

<html>
<head> <title>checkform.php</title> </head>
<body>
<?PHP
// Das Formular wird in der Variablen $form abgelegt
$form="
<form action=\"checkform.php\" method=\"post\">
<input type=\"hidden\" name=\"firsttime\" value=\"y\">
<input type=\"text\" name=\"name\" size=\"20\" maxlength=\"20\" value=\"\"><br>
<input type=\"submit\" value=\"Ok\">
</form>
";

// Erst wenn das Formular erstmals angezeigt wurde, wird firsttime definiert
// PHP 4.0
// if ($firsttime!="y"):
// PHP 5.0
if ($_POST['firsttime']!="y"):
    print "$form";
else:
    $error="n";
    if ($_POST['name']=="") :
        print "<font color=\"red\">Name fehlt</font><br>";
        $error="y";
    endif;
    if ($error=="y") :
       print "$form";
    else :
       print "Alles prima!";
    endif;
endif;

?>
</body>
</html>

An der Stelle, wo "Alles prima!" angezeigt wird, ist die Bearbeitung korrekt. Es kann hier beispielsweise eine Mail mit dem Inhalt abgesetzt werden oder zur nächsten Seite weitergeleitet werden.

Datei-Upload

Für einen Upload wird zunächst ein Formular benötigt. 
<form enctype="multipart/form-data" action="upload.php" method="POST">
<input type="hidden" name="MAX_FILE_SIZE" value="1000000" />
<input name="datei" type="file" size=40 maxlength=255 />
<input type="submit" value="Starte Upload" />
</form>
Wichtig sind folgende Einträge: Das hinter der action angegebene PHP-Skript findet in der Array-Variablen $_FILE alle notwendigen Informationen über die hochgeladenen Dateien. 
$fileArray = $_FILE["datei"];
$filename = fileArray["name"];
$typ = $fileArray["type"];
$tmp = $fileArray["tmp_name"];
$size = $fileArray["size"];
$error = $fileArray["error"];
Die Datei sollte nun vom temporären Ort in das Zielverzeichnis geschoben werden. 
if (move_uploaded_file($_FILES['datei']['tmp_name'], 'ziel/'.$_FILES['datei']['name'])) {
   // Upload hat geklappt
} else {
   // Das war nichts
}

Datenbankanschluss an MySQL

Im Beispiel soll auf eine MySQL-Datenbank zugegriffen werden. Dazu muss neben der MySQL-Datenbank, PHP und Apache auch das Modul installiert sein, das PHP den Zugriff auf MySQL ermöglicht. Unter Debian heißt das Paket php5-mysql. 
apt-get install php5-mysql
Die Aufrufe erinnern ein wenig an die C-API. 

int mysql_connect(string [hostname][:port], 
                  string [username], string [password]);
int mysql_close(int [link_identifier] );

Mit mysql_connect wird die Verbindung zur Datenbank aufgebaut. Die Verbindung wird mit mysql_close wieder beendet. 

int mysql_db_query(string database, string query, int [link_identifier] );

Mit mysql_db_query kann ein SQL-Kommando an die Datenbank übermittelt werden. Der Rückgabewert ist das Handle auf eine Ergebnismenge, das mit entsprechenden Routinen ausgelesen wird. 

array mysql_fetch_row(int result);

Mit mysql_fetch_row wird Zeile für Zeile das Ergebnis in ein Array gelesen, das die Spalten einer Zeile darstellt.

Das folgende Beispiel nimmt eine Verbindung zur lokal eingerichteten Datenbank auf und liest aus der Tabelle customer alle Zeilen und stellt sie im Browser in einer Tabelle dar. 

<script language="php">
// Versuche auf die DB zuzugreifen
$dbhandle = mysql_connect("localhost", "arnold", "geheimespasswort");
$dbresult = mysql_db_query("test_arnold", "select * from customer", $dbhandle);
echo "Das ist das Ergebnis:<table border> ";
while ($row = mysql_fetch_row($dbresult)) {
  echo "<tr><td>",$row[0],"</td><td>", $row[1], "</td></tr>";
}
echo "</table>";
mysql_close($dbhandle);
</script>

Eingabedaten in die Datenbank einfügen

Wenn Daten in eine Datenbank eingefügt werden sollen, verwendet man den SQL-Befehl INSERT. Hier wird erst einmal direkt eingefügt. 
<?php
    $dbcon=mysql_connect("localhost","fewo","geheim");
    if (mysql_select_db("fewo", $dbcon)) {
        echo("Datenbank fewo existiert.");
    } else {
        echo("Keine Datenbank fewo");
    }
    $sql="INSERT INTO gast (id, name, vorname) VALUES (13, 'Murks', 'Max')";
    if (mysql_query($sql, $dbcon))
    {
       echo("Insert funktioniert.");
    } else {
       echo("Uuuupps");
    }
    mysql_close();
?>
Nun werden einfach die Formularauswertung von oben, das Entnehmen der POST-Daten und der Insert-Aufruf zusammengesetzt. Das Formular ist in der Datei formgast.php. 
<html>
<body>
<form action=neuergast.php method=post>
<table>
<tr><td>ID: </td><td> <input type="TEXT" name="id" size=40></td></tr>
<tr><td>Name: </td><td> <input type="TEXT" name="name" size=40></td></tr>
<tr><td>Vorname: </td><td> <input type="TEXT" name="vorname" size=40></td></tr>
<tr><td> </td><td> <input type="submit" value="Einfügen"></td></tr>
</table>
</form>
</body>
</html>
Das Formular ruft beim Submit die Datei neuergast.php auf. Diese entnimmt die POST-Daten und ruft den Datenbank-Befehl INSERT auf. 
<?php
    $dbcon=mysql_connect("localhost","fewo","geheim");
    if (mysql_select_db("fewo", $dbcon)) {
        echo("Datenbank fewo");
    } else {
        echo("Keine Datenbank fewo");
    }
    $sql="INSERT INTO gast (id, name, vorname) VALUES ($_POST[id], '$_POST[name]', '$_POST[vorname]')";
    if (mysql_query($sql, $dbcon))
    {
       echo("Insert funktioniert.");
    } else {
       echo("Uuuupps");
    }
    mysql_close();
?>

MySQL-Daten per JSON weitergeben

Zunächst wird eine MySQL-Datenbank fewo mit der Tabelle gast angelegt. 
mysql -u root -p
Enter password:
mysql> CREATE USER 'fewo'@'localhost' IDENTIFIED BY 'geheim';
mysql> CREATE USER 'fewo'@'%' IDENTIFIED BY 'geheim';
mysql> create database fewo;
mysql> grant all on fewo.* to fewo;
Nun ausloggen und als Benutzer fewo die Datenbank fewo öffnen. Dort eine Tabelle gast anlegen und einen Beispielsatz eintragen: 
mysql -u fewo -p fewo
Enter password:
mysql> create table gast ( id int primary key, name varchar(40), 
          vorname varchar(40), mail varchar(50), strasse varchar(80),
          plz varchar(20), ort varchar(50), tel varchar(40),
          kinder int, info varchar(255));
mysql> insert into gast values (12, 'Name', 'Vorname', 'name@mail.de',
          'Strasse', 'plz', 'Ort', '112', 2, 'Informationen');
Datenbank verlassen.

Für PHP müssen die Module für den Zugriff auf MySQL und JSON installiert sein. Es wird eine PHP-Webseite namens gast.php angelegt. Darin wird ein Kontakt zur MySQL-Datenbank aufgebaut und ein SELECT ausgeführt. Das Ergebnis wird in einer Schleife durchlaufen und jede Zeile an eine String-Variable angehängt. Das Ergebnis wird durch den Aufruf json_encode in das Format JSON gewandelt und ausgegeben. 

<?php
    $dbcon=mysql_connect("localhost","fewo","geheim");
    mysql_select_db("fewo", $dbcon);
    $result=mysql_query("SELECT * FROM gast", $dbcon);
    if ($result) {
        while($row=mysql_fetch_row($result)) {
             $output[]=$row;
        }
    } else {
        echo("Kein Ergebnis aus SELECT");
    }
    print(json_encode($output));
    mysql_close();
?>
Wird diese URL durch ein Programm aufgerufen, kann es die Ausgabe sammeln und die Daten verarbeiten. Unter Java wird beispielsweise folgende Methode den JSON-Code abholen und als String zurückliefern. 
public String holeGaeste(String strUrl) {
    StringBuilder daten = new StringBuilder();
    try {
        URL url = new URL(strUrl);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        BufferedReader in = new BufferedReader(
                new InputStreamReader(connection.getInputStream()));
        String line;
        while ((line = in.readLine()) != null) {
            daten.append(line);
        }
        in.close();
    } catch(IOException e) {
        System.out.println(e.toString());
    }
    return daten.toString();        
}

Literaturhinweise

Thomas Theis: Einstieg in PHP 7 und MySQL
Christian Wenz, Tobias Hauser: PHP 7 und MySQL