# PHP lernen: Tutorial für Einsteigerinnen und Einsteiger

[PHP](https://www.ionos.at/digitalguide/websites/web-entwicklung/was-ist-php/) ist eine der gängigsten Programmiersprachen für die **serverseitige Programmierung**. Im Laufe der Zeit hat sich PHP zu einem unverzichtbaren Bestandteil vieler moderner Websites und Internettechnologien entwickelt. Doch PHP zu lernen kann für Neueinsteigerinnen und Neueinsteiger eine große Herausforderung sein. In diesem PHP-Tutorial zeigen wir Ihnen die Grundlagen der beliebten Programmiersprache sowie ihre wichtigsten [Operatoren](https://www.ionos.at/digitalguide/websites/web-entwicklung/php-operators/), Schleifen und Funktionen.

## PHP-Tutorial: Was Sie mitbringen sollen

Unser Tutorial richtet sich in erster Linie an Neuanfängerinnen und Neuanfänger. Bei manchen Beispielen ist es jedoch hilfreich, über ein Grundwissen der [modernen Webentwicklung](https://www.ionos.at/digitalguide/websites/web-entwicklung/grundlagen-der-modernen-webentwicklung/) sowie [HTML](https://www.ionos.at/digitalguide/websites/web-entwicklung/was-ist-html/) zu verfügen. Um die aufgeführten Beispiele an Ihrem eigenen Rechner nachzuvollziehen, müssen Sie folgende vorbereiten:

- Webserver inklusive **PHP-Interpreter**
- [PHP installieren](https://www.ionos.at/digitalguide/websites/web-entwicklung/php-installieren/)
- Webbrowser
- Texteditor

### XAMPP

Als Server empfehlen wir für den Einstieg die [lokale Testumgebung XAMPP](https://www.apachefriends.org/de/index.html "Downloadseite von Apache XAMPP"), die von Apache Friends für die Betriebssysteme Windows, Linux und macOS kostenlos zur Verfügung gestellt wird. **XAMPP ist ein reiner Testserver.** Webentwicklerinnen und Webentwicklern bietet das Software-Bundle die Möglichkeit, in kürzester Zeit eine komplette Testumgebung für Skripte, HTML-Seiten und Stylesheets aufzusetzen. Ein sicherer Betrieb als Webserver im Internet ist jedoch **nicht gewährleistet**. Eine ausführliche Installationsanleitung finden Sie in unserem [XAMPP-Tutorial](https://www.ionos.at/digitalguide/server/tools/xampp-tutorial-so-erstellen-sie-ihren-lokalen-testserver/).

### PHP Built-in Server

PHP bringt seit Version 5.4 einen integrierten Entwicklungsserver mit, der sich besonders für einfache Tests und Lernzwecke eignet. Dieser sogenannte Built-in Server erfordert keine zusätzliche Server-Software wie Apache oder [NGINX](https://www.ionos.at/digitalguide/server/konfiguration/nginx-grundlagen-installation-und-einrichtung/). Voraussetzung ist **lediglich eine installierte PHP-Version auf Ihrem System**. Anschließend können Sie den Server direkt über die Kommandozeile im Projektverzeichnis starten:

```bash
php -S localhost:8000
```

PHP stellt die Dateien im aktuellen Ordner anschließend unter der Adresse `http://localhost:8000` im Webbrowser bereit. Der Built-in Server eignet sich vor allem für erste PHP-Experimente, kleine Testskripte oder das schnelle Nachvollziehen von Codebeispielen.

### Docker und Docker-Compose

Eine etwas anspruchsvollere Alternative ist der Einsatz von [Docker](https://www.ionos.at/digitalguide/server/knowhow/was-ist-docker/). Docker ermöglicht es, Entwicklungsumgebungen in sogenannten **Containern zu kapseln**. Dadurch lassen sich Webserver, PHP und Datenbanken exakt so konfigurieren, wie sie später auch in der Produktionsumgebung laufen. Für PHP-Projekte wird häufig [Docker-Compose](https://www.ionos.at/digitalguide/server/konfiguration/docker-compose-tutorial/) verwendet, um mehrere Dienste gemeinsam zu starten. Die gesamte Konfiguration wird in einer Datei („docker-compose.yml)“ festgehalten und kann mit einem einzigen Befehl gestartet werden.

## PHP-Grundlagen: Die Syntax der Skriptsprache

Haben Sie Ihren lokalen Webserver (z. B. mithilfe von XAMPP) eingerichtet, sollten Sie testen, ob PHP korrekt installiert wurde und bereit ist, Skripte auszuführen. Ein Skript ist ein Programm, das nicht vorab in Binärcode kompiliert wird. Stattdessen werden sie von einem *Interpreter* ausgeführt. Öffnen Sie Ihren bevorzugten **Texteditor** und übernehmen Sie folgendes PHP-Skript:

```php
<?php
phpinfo();
?>
```

PHP-Skripte sind immer nach demselben Schema aufgebaut. Der öffnende PHP-Tag `<?php` signalisiert, dass eine **Skript-Umgebung** gestartet wird. Darauf folgt der eigentliche PHP-Code in Form von Anweisungen. Im Beispiel handelt es sich um den Aufruf der Funktion `phpinfo()`. Die meisten PHP-Funktionen verlangen einen oder mehrere Parameter, die zwischen den runden Klammern stehen; bei `phpinfo()` sind diese optional. Jede Anweisung endet mit einem Semikolon (;). Um die Skript-Umgebung zu schließen, kommt der schließende PHP-Tag zum Einsatz: `?>`. Dieser ist bei reinen PHP-Dateien optional.

Speichern Sie die Textdatei unter dem Namen „test“ im Format .php (PHP-Skript) ab und starten Sie Ihren Webserver. Sofern Sie die Testumgebung XAMPP nutzen, legen Sie „test.php“ im XAMPP-Verzeichnis unter „htdocs“ ab (C:\\xampp\\htdocs).

[![Bild: Die Datei test.php im htdocs-Ordner](https://www.ionos.at/digitalguide/fileadmin/_processed_/5/9/csm_php-tutorial-htdocs-xampp_c4c4eb81b8.webp "Die Datei test.php im htdocs-Ordner")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-htdocs-xampp.jpg) Damit Sie die Datei test.php via XAMPP ausführen können, müssen Sie diese im htdocs-Ordner platzieren. Die Beispieldatei lässt sich nun über folgende URL im Webbrowser aufrufen: `http://localhost/test.php`. Verwenden Sie einen anderen Webserver oder eine individuelle Konfiguration der XAMPP-Software, **wählen Sie die URL dem jeweiligen Dateipfad entsprechend**.

Mit dem Eintippen der URL `http://localhost/test.php` weisen Sie Ihren Webbrowser an, die Datei „test.php“ vom Webserver anzufordern. Der [Apache HTTP Server](https://www.ionos.at/digitalguide/server/knowhow/was-ist-apache/) oder die von Ihnen bevorzugte Webserver-Software ruft die Datei im entsprechenden Verzeichnis ab. Die Endung .php kündigt an, dass die Datei PHP-Code enthält. Nun schaltet sich der in den Webserver eingebundene PHP-Interpreter ein. Dieser parst das Dokument und stößt auf das öffnende PHP-Tag `<?php`. Der Interpreter ist in der Lage, den PHP-Code auszuführen und eine HTML-Ausgabe zu erzeugen, die vom Webserver an den Webbrowser ausgeliefert wird.

Hinweis Bei der Funktion `phpinfo()` handelt es sich um die Kurzschreibweise des Standardwerts `phpinfo(INFO_ALL)`. Dieser gibt detaillierte Informationen zur PHP-Konfiguration Ihres Webservers aus. Ist keine PHP-Version auffindbar, zeigt der Webbrowser eine Fehlermeldung oder liefert den PHP-Code, ohne diesen zu interpretieren, an den Browser aus.

### „Hello World!“ – so geben Sie Text per `echo` aus

Wurde PHP fehlerfrei installiert, wird es Zeit, das erste eigene Skript zu schreiben. Dazu bietet sich die Anweisung [PHP echo](https://www.ionos.at/digitalguide/websites/web-entwicklung/php-echo/) an. Anders als `phpinfo()` stellt `echo` keine Funktion dar. Vielmehr handelt es sich um ein **Sprachkonstrukt**, das es ermöglicht, einen nachfolgenden String als Text auszugeben.

Definition Sprachkonstrukte sind Anweisungen, die in PHP dazu genutzt werden, den Programmablauf zu steuern. Zu den Sprachkonstrukten zählen neben `echo` Anweisungen wie `if`, `for`, `do`, `include`, `return`, `exit` oder `die`. Daher sind in diesem Fall anders als bei Funktionen keine Klammern nötig.

Erstellen Sie für Ihr erstes eigenes Skript eine neue PHP-Datei und notieren Sie in dieser folgenden Code:

```php
<?php
echo 'Hello World!';
```

Das öffnende Tag `<?php` startet eine Skript-Umgebung. Es folgt das Sprachkonstrukt `echo` sowie der in einfache **Anführungszeichen** gefasste String „Hello World!“. Achten Sie auf das Semikolon nach der Anweisung. Statt „Hello World!“ kann ein beliebiger Text verwendet werden. Da es sich um eine reine PHP-Datei handelt, haben wir auf den schließenden PHP-Tag verzichtet.

Tipp Der schließende PHP-Tag `?>` muss bei reinen PHP-Dateien nicht verwendet werden. So lassen sich versehentliche Leerzeilen oder unsichtbare Zeichen am Dateiende vermeiden, die zu Fehlermeldungen wie „Headers already sent“ führen können.

Speichern Sie das Skript unter „hello.php“ im Ordner „htdocs“ auf ihrem Webserver ab und rufen Sie die Datei über die URL ‘http://localhost/hello.php’ im Webbrowser auf. Wurde der Code richtig übertragen, sollte das Browserfenster nun die von Ihnen verwendete Zeichenfolge zeigen:

[![Bild: Textausgabe mit Sprachkonstrukt echo](https://www.ionos.at/digitalguide/fileadmin/_processed_/8/2/csm_php-tutorial-hello-world_6212c88d9a.webp "Textausgabe mit Sprachkonstrukt echo")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-hello-world.jpg) Im Browser sehen Sie nun die Ausgabe „Hello World.“ Jeder Text, den Sie mit `echo` ausgeben, kann bei Bedarf mit [HTML-Tags](https://www.ionos.at/digitalguide/websites/web-entwicklung/html-tags/) ausgezeichnet werden. Diese werden vom Webbrowser anschließend der HTML-Spezifikation entsprechend interpretiert. Versuchen Sie es selbst, z. B. mit folgendem Skript:

```php
<?php
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
```

Im Webbrowser aufgerufen wird das **Ergebnis der Skriptausführung** folgendermaßen dargestellt:

[![Bild: Ergebnis einer Skriptausführung mit HTML-Tags](https://www.ionos.at/digitalguide/fileadmin/_processed_/3/f/csm_php-tutorial-hello-world-html_89d2cbd7db.webp "Ergebnis einer Skriptausführung mit HTML-Tags")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-hello-world-html.jpg) Die Ausgabe kann im PHP-Skript mit HTML-Tags formatiert werden. Die in `<h1>`-Tags gefasste Zeichenfolge „Hello World!“ wird vom Webbrowser als Überschrift erster Ordnung interpretiert. Es folgen ein automatischer Zeilenumbruch und der Textabsatz `<p>`.

Je nach Bedarf lässt sich `echo` sowohl mit einfachen (`'`) als auch mit doppelten Anführungszeichen (`"`) einsetzen. Möchten Sie lediglich Text ausgeben, macht es keinen Unterschied, für welche Anführungszeichen Sie sich entscheiden. Dies ändert sich jedoch, sobald **PHP-Variablen ins Spiel kommen**.

### Variablen

Das Sprachkonstrukt `echo` hält mehr bereit als die reine Textausgabe. Diese lässt sich schließlich auch ohne PHP auf Basis von HTML hervorragend umsetzen. Der eigentliche Mehrwert von `echo` beruht darauf, dass die Anweisung es ermöglicht, **Texte mithilfe von Variablen dynamisch zu erzeugen**.

Variablen begegnen Ihnen z. B. in folgender Form: `$beispiel`.

Jede Variable besteht aus einem Dollarzeichen (`$`) gefolgt vom Variablen-Namen. Variablen kommen in PHP-Skripten zum Einsatz, um **externe Daten in Webseiten einzubinden**. Dabei kann es sich um Werte verschiedener Art handeln – von einfachen Zahlen und Zeichenketten bis hin zu ganzen Texten oder HTML-Dokumentstrukturen.

PHP unterscheidet acht Variablen-Typen:

<table>
  <thead>
    <tr>
      <th><strong>Variablen-Typ</strong></th>
      <th><strong>Beschreibung</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>String</td>
      <td>Ein String ist eine Zeichenkette. Dabei kann es sich um ein Wort, einen Satz, einen Text oder den gesamten HTML-Code einer Webseite handeln.</td>
    </tr>
    <tr>
      <td>Integer</td>
      <td>Ein Integer ist eine Ganzzahl ohne Nachkommastellen. Diese kann positiv oder negativ sein.</td>
    </tr>
    <tr>
      <td>Float</td>
      <td>Ein Float ist eine Fließkommazahl, sprich ein Zahlenwert mit Nachkommastellen. Das Komma wird bei Programmiersprachen als Punkt (`.`) notiert. PHP unterstützt bis zu 14 Stellen hinter dem Komma</td>
    </tr>
    <tr>
      <td>Boolean</td>
      <td>Boolesche Variablen sind das Ergebnis einer logischen Operation und kennen nur zwei Werte: `TRUE` (wahr) und `FALSE` (falsch). Dieser Variablentyp kommt etwa zum Einsatz, wenn Sie mit Bedingungen arbeiten.</td>
    </tr>
    <tr>
      <td>Array</td>
      <td>Ein Array ist eine Variable, die mehrere Elemente beinhalten kann. Es handelt sich somit um eine Gruppierung mehrerer gleichartig strukturierter Daten, die zu einem Array zusammengefasst wurden.</td>
    </tr>
    <tr>
      <td>Object</td>
      <td>Der Variablen-Typ `object` ermöglicht es Programmierern, eigene Datentypen zu definieren. Anwendung findet er bei der objektorientierten Programmierung. In unserem PHP-Tutorial für Anfängerinnen und Anfänger klammern wir `object`-Variablen aus.</td>
    </tr>
    <tr>
      <td>NULL</td>
      <td>Der Wert `NULL` repräsentiert eine Variable ohne Wert. Für Variablen des Typs `NULL` ist dies der einzig mögliche Wert.</td>
    </tr>
    <tr>
      <td>Resource</td>
      <td>Eine Resource ist eine spezielle Variable, die eine Referenz auf externe Ressourcen enthält, z. B. eine geöffnete Datei, eine Datenbankverbindung oder einen Socket. Ressourcen werden von PHP selbst verwaltet. In unserem PHP-Tutorial für Anfängerinnen und Anfänger klammern wir `resource`-Variablen aus.</td>
    </tr>
  </tbody>
</table>

Die zentrale Verwaltung von Inhalten erfolgt in der Regel mithilfe von **Datenbanksystemen**. Werte für Variablen lassen sich jedoch auch direkt im Skript definieren. Diese Art der Zuordnung erfolgt nach folgendem Schema:

```php
$beispiel = "Wert";
```

Auf das charakteristische Dollarzeichen folgt der Variablen-Name (in diesem Fall `beispiel`). Dieser wird durch das Gleichheitszeichen (`=`) mit einem **in doppelte Anführungszeichen gefassten** Wert verknüpft. Werte für Variablen des Typs Integer und Float werden ohne Anführungszeichen notiert (z. B. `$beispiel = 24;` bzw. `$beispiel = 2.7;`)

PHP bietet Ihnen die Freiheit, Variablen nach eigenem Ermessen zu benennen. Es gelten jedoch folgende Einschränkungen:

- Jede Variable beginnt mit einem Dollarzeichen.
- Ein Variablen-Name ist eine beliebige Zeichenfolge aus Buchstaben, Ziffern und Unterstrichen (z. B. `$beispiel\_1`).
- Ein gültiger Variablen-Name beginnt immer mit einem Buchstaben oder einem Unterstrich (`$beispiel1` oder `$\_beispiel`), nie mit einer Ziffer (falsch: `$1beispiel`).
- PHP ist *case-sensitive*. Die Skriptsprache unterscheidet zwischen Groß- und Kleinschreibung (`$beispiel` ≠ `$Beispiel`).
- Der Variablen-Name darf keine Leerzeichen oder Zeilenumbrüche enthalten (falsch: `$beispiel 1`)
- Von PHP für andere Zwecke reservierte Zeichenfolgen können nicht als benutzerdefinierte Variablen eingesetzt werden (z. B. `$this`)

Wir schauen uns das an einem Beispiel an:

```php
<?php
$author = "John Doe";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>";
```

Auf das öffnende PHP-Tag folgt die **Definition der Variable**: Für `$author` soll der Wert „John Doe“ verwendet werden. Bei der Skriptausführung wird die Variable `$author` somit bei jeder Nennung innerhalb der Skript-Umgebung durch den Wert „John Doe“ ersetzt. Wie das im Webbrowser aussieht, zeigt die nachstehende Grafik.

[![Bild: Dynamische Texterstellung mit Variablen](https://www.ionos.at/digitalguide/fileadmin/_processed_/e/7/csm_php-tutorial-variablen_3dc36c510f.webp "Dynamische Texterstellung mit Variablen")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-variablen.jpg) Variablen fungieren als eine Art Platzhalter und ermöglichen dynamische Texterstellung. Liegt nun ein Irrtum vor und die Webpage stammt gar nicht von John Doe, sondern von seinem deutschen Kollegen Max Mustermann, braucht lediglich die Variable mit dem Namen `$author` angepasst zu werden, um den Fehler zu beheben. Effizient ist dies vor allem dann, wenn eine Variable innerhalb eines Skripts **mehrfach** vorkommt. Eine Korrektur müsste in diesem Fall lediglich an einer einzigen Stelle vorgenommen werden. Nämlich da, wo der Wert der Variable definiert wird.

Die Vorteile dieses Designkonzepts liegen auf der Hand: Werden Elemente der Website (z. B. im Footer-Bereich) überarbeitet, müssen die Anpassungen nicht auf jeder einzelnen Unterseite des Webprojekts manuell vorgenommen werden. Stattdessen genügt es, den entsprechenden **Eintrag in der Datenbank zu aktualisieren**. So wird die Überarbeitung automatisch für alle Webpages übernommen, die die entsprechenden Daten als Variablen einbinden.

Wird eine **Variable innerhalb eines Skripts mehrfach definiert**, überschreibt die neue Definition die vorhergehende. Ein nachfolgendes `echo` gibt immer den aktuellen Wert einer Variable aus.

```php
<?php
$author = "John Doe";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>";
$author = "Max Mustermann";
echo " <p>Supported by $author.</p>";
```

Im Codebeispiel wird für die Variable `$author` erst der Wert „John Doe“ vergeben und anschließend durch den Wert „Max Mustermann“ ersetzt.

[![Bild: Das Überschreiben von Variablen](https://www.ionos.at/digitalguide/fileadmin/_processed_/2/5/csm_php-tutorial-variablen-ueberschreiben_9f70b28a77.webp "Das Überschreiben von Variablen")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-variablen-ueberschreiben.jpg) Wird eine gleichnamige Variable mehrfach definiert, überschreibt die jeweils letzte Definition die vorherige. Nun zum Thema **Anführungszeichen**. Anders als Strings brauchen einzelne Variablen nicht in Anführungszeichen gesetzt werden:

```php
<?php
$author = "John Doe";
echo $author;
```

Es sei denn, die Variable soll innerhalb eines Strings verwendet werden. In diesem Fall arbeiten Sie mit doppelten Anführungszeichen (*“*). Diese signalisieren dem PHP-Interpreter, dass er den String nach Variablen absuchen soll, die ggf. durch die mit ihnen verknüpften Werte zu ersetzen sind. Zeichenfolgen, die in einfache Anführungszeichen (*’*) gefasst sind, werden als reine Textinformation interpretiert und wiedergegeben – selbst dann, wenn es sich um Variablen handelt.

```php
<?php
$author = "John Doe";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>';
```

Die Variable wird in diesem Fall also nicht interpretiert, sondern einfach als Text wiedergegeben.

[![Bild: Reine Textausgabe bei einfachen Anführungszeichen](https://www.ionos.at/digitalguide/fileadmin/_processed_/7/a/csm_php-tutorial-variablen-und-anfuehrungszeichen_57bb4ee5e0.webp "Reine Textausgabe bei einfachen Anführungszeichen")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-variablen-und-anfuehrungszeichen.jpg) Wenn ein String in einfachen Anführungszeichen steht und dort eine Variablennennung auftaucht, wird diese nicht interpretiert.  Hinweis Sie fragen sich nun vielleicht, was passiert, wenn Sie die Anführungszeichen ganz weglassen? In diesem Fall weist PHP sie auf einen syntaktischen Fehler hin.

### Strikte Typisierung mit declare(strict\_types=1)

Standardmäßig versucht PHP, **unterschiedliche Datentypen automatisch ineinander umzuwandeln**. Dieses Verhalten wird häufig als Typ-Jonglieren bezeichnet und kann dazu führen, dass fehlerhafte Werte unbemerkt weiterverarbeitet werden. Mit der Direktive `declare(strict_types=1);` lässt sich dieses Verhalten gezielt deaktivieren. PHP prüft dann bei Funktionsaufrufen strikt, ob übergebene Argumente und Rückgabewerte den deklarierten Variablentypen entsprechen. Die Direktive muss am Anfang einer PHP-Datei stehen und wirkt nur auf diese Datei:

```php
<?php
declare(strict_types=1);
function addiere(int $a, int $b): int
{
return $a + $b;
}
echo addiere(2, 3); 
echo addiere("2", 3);
```

Im Beispiel akzeptiert eine PHP-Funktion namens `addiere()` ausschließlich Integer-Werte. Während der Aufruf mit 2 und 3 problemlos funktioniert, führt der zweite Aufruf zu einem Fehler, da der String `"2"` nicht automatisch in eine Ganzzahl umgewandelt wird. Durch die strikte Typisierung werden solche Probleme frühzeitig erkannt, was die Wartbarkeit und Zuverlässigkeit von PHP-Code deutlich verbessert.

### Fehlermeldungen und Maskierung

Kommt es zu **syntaktischen Fehlern**, liegt kein valider PHP-Code vor und die geladene Seite im Browser ist leer oder der PHP-Interpreter gibt eine Fehlermeldung aus. Zu erwarten ist eine solche beispielsweise, wenn man die Anweisung `echo` mit einem String ohne Anführungszeichen einsetzt:

```php
<?php
echo Hello World!;
```

Fehlermeldungen beinhalten in den meisten Fällen Angaben dazu, wo ein Fehler aufgetreten ist, und liefern so wichtigen Input zu dessen Beseitigung. Sie können die Meldungen in jedem Fall im XAMPP-Log unter „C:\\xampp\\logs\\php\_error\_log“ einsehen.

[![Bild: Im Log finden Sie eine Fehlermeldung: Parse error](https://www.ionos.at/digitalguide/fileadmin/_processed_/8/5/csm_php-tutorial-parse-error-xampp-log_52dd257312.webp "Im Log finden Sie eine Fehlermeldung: Parse error")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-parse-error-xampp-log.jpg) Fehler werden jederzeit im XAMPP-Log angezeigt. Im aktuellen Beispiel wird ein Fehler in Zeile 2 unseres Programmcodes vermutet – genau da, wo wir zu Demonstrationszwecken die Anführungszeichen weggelassen haben.

Zu **syntaktischen Fehlern** kommt es auch, wenn Sie Zeichen als Text ausgeben möchten, die in PHP mit einer bestimmten Aufgabe verbunden sind. Ein Beispiel wäre das Anführungszeichen (*’*). Zeichen wie diese lassen sich in PHP nur dann als Text ausgeben, wenn Sie dem Interpreter verständlich machen, dass das Zeichen seiner eigentlichen Aufgabe entbunden wurde. Im Fall von einfachen Anführungszeichen stehen Ihnen dazu zwei Möglichkeiten zu Verfügung: Sie können einen String mit einfachen Anführungszeichen in doppelte Anführungszeichen fassen oder die Anführungszeichen durch einen vorangestellten Backslash maskieren (auch „escapen“ genannt):

```php
<?php
echo '\'Hello World!\' ';
```

[![Bild: Der Backslash als Maskierungszeichen](https://www.ionos.at/digitalguide/fileadmin/_processed_/8/2/csm_php-tutorial-backslash-maskierungszeichen_93d72f7d30.webp "Der Backslash als Maskierungszeichen")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-backslash-maskierungszeichen.jpg) Der Backslash dient in PHP als Maskierungszeichen. Ebenfalls möglich wäre die Kombination einfacher und doppelter Anführungszeichen:

```php
<?php
echo " 'Hello World!' ";
```

Nicht jedoch diese Schreibweise:

```php
<?php
echo ' 'Hello World!' ';
```

Die Leerzeichen zwischen den Anführungszeichen wurden in den Beispielen zwecks Lesbarkeit eingefügt.

### Verkettungsoperatoren

Möchten Sie mehrere Variablen innerhalb eines PHP-Skripts gleichzeitig ausgeben, könnten Sie dies so umsetzen, wie bisher gelernt:

```php
<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author1 and $author2.</p>";
```

Sie schreiben beide Variablen einfach zusammen mit dem restlichen Text, der ausgegeben werden soll, in den in doppelte Anführungszeichen gefassten String. PHP erkennt die Variablen anhand des Dollarzeichens (`$`) automatisch und setzt die entsprechenden Werte ein.

[![Bild: Textausgaben mit zwei Variablen](https://www.ionos.at/digitalguide/fileadmin/_processed_/1/b/csm_php-tutorial-zwei-variablen_adff619624.webp "Textausgaben mit zwei Variablen")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-zwei-variablen.jpg) Mit zwei Variablen können Sie theoretisch genau verfahren wie mit einer einzigen. Unter Programmiererinnen und Programmierern gilt ein solches Vorgehen jedoch als unsaubere Arbeit. Es gilt das Dogma, dass **Variablen nicht Teil des Strings** sein sollten. Ein Grund dafür ist, dass zahlreiche Programmiersprachen eine solche Trennung vorschreiben. Wichtiger ist, dass auch PHP die Trennung von String und Variable empfiehlt, wenn wir mit Funktionsaufrufen oder komplexeren Variablen arbeiten. Es lohnt sich daher, diese Trennung auch bei der reinen Textausgabe konsequent umzusetzen, selbst wenn es in diesem Fall nicht zwangsläufig nötig wäre.

Arbeiten wir mit Variablen, haben wir es somit immer mit mehreren Elementen zu tun, die bei der Ausgabe miteinander verkettet werden müssen. In PHP kommt dazu der **Verkettungsoperator** (`.`) zum Einsatz.

„Sauber“ programmiert müsste der Code für das oben angeführte Beispiel somit folgendermaßen aussehen:

```php
<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by ' . $author1 . ' and ' . $author2 . '.</p>';
```

Wir haben es somit mit drei Strings und zwei Variablen zu tun, die zu einer Zeichenfolge verkettet werden.

<table>
  <thead>
    <tr>
      <th><strong>String1</strong></th>
      <th></th>
      <th><strong>Variable1</strong></th>
      <th></th>
      <th><strong>String2</strong></th>
      <th></th>
      <th><strong>Variable2</strong></th>
      <th></th>
      <th><strong>String3</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>‘&lt;h1&gt;Hello World!&lt;/h1&gt;&lt;p&gt;This dynamic web page was created by’</td>
      <td>.</td>
      <td>`$author1`</td>
      <td>.</td>
      <td>’ and ’</td>
      <td>.</td>
      <td>`$author2`</td>
      <td>.</td>
      <td>‘&lt;\\p&gt;’</td>
    </tr>
  </tbody>
</table>

Zu beachten ist, dass ein Verkettungsoperator Strings oder Variablen ohne Leerzeichen zusammenfügt. Wird ein Leerzeichen gewünscht, muss dieses wie im Beispiel im String innerhalb der Anführungszeichen notiert werden.

[![Bild: Verbindung von Strings und Variablen mit Verkettungsoperatoren](https://www.ionos.at/digitalguide/fileadmin/_processed_/2/d/csm_php-tutorial-verkettungsoperator_7994c84f56.webp "Verbindung von Strings und Variablen mit Verkettungsoperatoren")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-verkettungsoperator.jpg) Es ist gute Programmierpraxis, mehrere Elemente bei der Ausgabe mit dem Verkettungsoperator zu konkatenieren. Programmiererinnen und Programmierer nutzen den Verkettungsoperator nicht nur, um Strings und Variablen für die Textausgabe zu verknüpfen, sondern auch, um Variablen zu verlängern. Wie das funktioniert, zeigt das folgende Beispiel:

```php
<?php
$beispiel = 'Hallo ';
$beispiel .= 'Welt';
echo $beispiel;
```

Um den Wert einer Variable zu verlängern, definieren Sie diese erneut, setzen dabei aber den Verkettungsoperator vor das Gleichheitszeichen. Es handelt sich dabei um die allgemein **übliche Kurzschreibweise** für `$beispiel = $beispiel . 'Welt'`.

PHP fügt den neuen Wert an den zuvor definierten an. Wünschen Sie ein Leerzeichen zwischen beiden Werten, notieren Sie dieses wie im Beispiel am Ende des ersten Strings.

[![Bild: Verlängerung des Werts einer Variable](https://www.ionos.at/digitalguide/fileadmin/_processed_/f/b/csm_php-tutorial-variablen-verlaengern_703788d72e.webp "Verlängerung des Werts einer Variable")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-variablen-verlaengern.jpg) Der Verkettungsoperator wird auch eingesetzt, um Variablen direkt zu konkatenieren. ### PHP in HTML einbinden

Der PHP-Interpreter interessiert sich prinzipiell nur für Code, der sich zwischen einem öffnenden und einem schließenden PHP-Tag befindet (wobei letzteres bei reinem PHP optional ist):

`<?php [Dieser Bereich wird vom PHP-Interpreter geparst] ?>`

Alle anderen Abschnitte des Dokuments werden vom Interpreter ignoriert und so, wie sie sind, an den Webserver weitergegeben. PHP-Code lässt sich somit beliebig **in HTML-Dokumente integrieren** – um z. B. ein Template für ein Content-Management-System zu erstellen. Dabei ist darauf zu achten, dass HTML-Dokumente, die PHP-Code enthalten, als PHP-Dateien gespeichert werden. Ansonsten wird das Dokument nicht vom PHP-Interpreter vorverarbeitet, sondern direkt an den Webbrowser ausgeliefert – was zur Folge hätte, dass der Programmcode als Text auf der Website erscheint.

Den PHP-Interpreter können Sie sich somit als den faulen Kollegen des Webservers vorstellen, der nur dann arbeitet, wenn er explizit dazu aufgefordert wird – z. B. durch ein öffnendes PHP-Tag.

Möchten Sie **HTML und PHP kombinieren**, schreiben Sie Ihre HTML-Seite wie gewohnt gemäß der klassischen Dokumentstruktur und speichern diese unter der Dateiendung .php ab:

```html

<html lang="de">
<head>
<meta charset="utf-8">
<title>My first PHP page</title>
</head>
<body>
<h1>Hello World</h1>
<p>What is the current time and date?</p>
<div class="hash d-none" hidden>hash_b59c004b721c50c9c6f5453b116fc5c605dec76a</div><script data-shy-copy-guard>(function(){var C=[0x00AD,0x200B,0x200C,0x200D,0x2060,0xFEFF];var s=function(t){for(var i=0;i<C.length;i++){t=t.split(String.fromCharCode(C[i])).join("");}return t;};document.addEventListener("copy",function(e){var sel=document.getSelection();if(!sel||sel.isCollapsed||!e.clipboardData){return;}e.clipboardData.setData("text/plain",s(sel.toString()));try{var d=document.createElement("div");d.appendChild(sel.getRangeAt(0).cloneContents());e.clipboardData.setData("text/html",s(d.innerHTML));}catch(x){}e.preventDefault();});})();</script></body>
</html>
```

Ergänzen Sie Ihr HTML-Dokument nun um ein PHP-Skript. Achten Sie darauf, dass sich der gesamte Programmcode innerhalb der PHP-Tags befindet.

```html

<html lang="de">
<head>
<meta charset="utf-8">
<title>My first PHP page</title>
</head>
<body>
<h1>Hello World</h1>
<p>What is the current time and date?</p>
<p>Your current time and date is:
<?php
echo date("d.m.Y H:i:s");
?>.</p>
<div class="hash d-none" hidden>hash_b59c004b721c50c9c6f5453b116fc5c605dec76a</div><script data-shy-copy-guard>(function(){var C=[0x00AD,0x200B,0x200C,0x200D,0x2060,0xFEFF];var s=function(t){for(var i=0;i<C.length;i++){t=t.split(String.fromCharCode(C[i])).join("");}return t;};document.addEventListener("copy",function(e){var sel=document.getSelection();if(!sel||sel.isCollapsed||!e.clipboardData){return;}e.clipboardData.setData("text/plain",s(sel.toString()));try{var d=document.createElement("div");d.appendChild(sel.getRangeAt(0).cloneContents());e.clipboardData.setData("text/html",s(d.innerHTML));}catch(x){}e.preventDefault();});})();</script></body>
</html>
```

Im Beispiel haben wir das Sprachkonstrukt `echo` mit der PHP-Funktion `date()` kombiniert, um das aktuelle Datum inklusive Uhrzeit serverseitig als Text ausgeben zu lassen. Der Parameter der Funktion gibt das gewünschte Format in Form eines Strings an:

`"d.m.Y H:i:s"` (Tag.Monat.Jahr Stunde:Minute:Sekunde)

Wird eine solche Datei von einem Webbrowser angefordert, führt der PHP-Interpreter zunächst das Skript aus und schreibt **die aktuelle Uhrzeit als Text** in das HTML-Dokument. Dieses wird im Anschluss vom Webserver ausgeliefert und im Browser als Webpage dargestellt.

[![Bild: Integration von PHP in HTML](https://www.ionos.at/digitalguide/fileadmin/_processed_/2/7/csm_php-tutorial-html-datum_854480f58a.webp "Integration von PHP in HTML")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-html-datum.jpg) Sie können PHP-Funktionen in Ihren HTML-Code einbetten. ### Die PHP-Kommentarfunktion

Wie HTML-Code lässt sich auch PHP beliebig auskommentieren. **Kommentare im Quellcode** werden vom PHP-Interpreter ignoriert, sofern diese der Syntax entsprechend ausgezeichnet wurden. PHP stellt dazu drei verschiedene Alternativen bereit.

Möchten Sie eine gesamte Zeile als Kommentar auszeichnen und somit von der Interpretation ausschließen, nutzen Sie den Hashtag (`#`) oder zwei aufeinanderfolgende Slashs. Im folgenden Codebeispiel kommen beide Möglichkeiten zum Einsatz:

```php
<?php
## This is a single line comment
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
// This is also a single-line comment!
```

Texteditoren oder IDEs mit Syntaxhervorhebung heben Kommentare farblich hervor. Die in der Skript-Umgebung als Kommentar ausgezeichneten Textstellen kommen im Webbrowser – im Gegensatz zu HTML-Kommentaren – gar nicht erst an, da diese bereits bei der Skriptausführung durch den PHP-Interpreter ignoriert werden.

Darüber hinaus haben Sie die Möglichkeit, Kommentare einzufügen, die sich **über mehrere Zeilen** erstrecken. Markieren Sie dazu den Anfang eines Kommentarabschnitts mit einem Slash gefolgt von einem Asterisk und das Ende mit einem Asterisk gefolgt von einem Slash.

```php
<?php
/*
This is a multiple-lines comment block
that spans over multiple
lines
*/
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
```

Auch derart ausgezeichnete Kommentare werden nicht geparst und erscheinen somit nicht auf der Webseite.

[![Bild: Beispiel eines mehrzeiligen Kommentars](https://www.ionos.at/digitalguide/fileadmin/_processed_/2/5/csm_php-tutorial-kommentare_1d1f7af35f.webp "Beispiel eines mehrzeiligen Kommentars")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-kommentare.jpg) Wie Sie sehen können, werden Kommentare nicht ausgegeben. Programmiererinnen und Programmierer nutzen Kommentare, um den Quellcode ihrer Skripte zu strukturieren, Hinweise für eine spätere Bearbeitung zu hinterlassen oder der Erstellung interne Angaben wie den Autor oder das Datum hinzuzufügen. Kommentare sind optional und sollten **sparsam verwendet** werden, um eine gute Lesbarkeit des Quellcodes zu gewährleisten.

### Rechnen mit Variablen

Im Rahmen unseres PHP-Tutorials sind Sie bereits mit Variablen in Berührung gekommen. Dabei wurden diesen in erster Linie String-Werte (sprich: Zeichenfolgen) zugewiesen. Nun werden wir uns mit Variablen beschäftigen, die **Ganzzahlen** (Integers) oder **Gleitkommazahlen** (Floats) repräsentieren.

Speichern Variablen Zahlenwerte, bietet PHP die Möglichkeit, mit diesen Berechnungen durchzuführen. Wir beginnen mit einer einfachen Addition zweier Ganzzahlen:

```php
<?php
$zahl1 = 237;
$zahl2 = 148;
$ergebnis = $zahl1 + $zahl2;
echo "Ergebnis: " . $ergebnis;
```

Zunächst weisen wir den Variablen `$zahl1` und `$zahl2` die Ganzzahlen 237 und 148 zu und definieren im Anschluss eine Variable `$ergebnis`. Diese soll die Summe der beiden Variablen speichern. Dazu bedienen wir uns des \*\*arithmetischen Operators `+` (Plus). Abschließend geben wir das Additionsergebnis mithilfe des Sprachkonstrukts `echo` als Text aus. Beachten Sie, dass Sie bei der Zuweisung von Zahlenwerten zu Variablen keine Anführungszeichen benötigen.

[![Bild: Addition von Ganzzahlen mithilfe eines PHP-Skripts](https://www.ionos.at/digitalguide/fileadmin/_processed_/1/9/csm_php-tutorial-addition-ganzzahlen-variablen_918f9b7481.webp "Addition von Ganzzahlen mithilfe eines PHP-Skripts")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-addition-ganzzahlen-variablen.jpg) Sie können mit numerischen Variablen genau wie mit Zahlen rechnen. Folgendes Codebeispiel zeigt eine **Auswahl mathematischer Berechnungen**, die sich mit PHP serverseitig durchführen lassen. Die verwendeten PHP-Operatoren entsprechen größtenteils den standardisierten Rechenzeichen der Mathematik.

<table>
  <thead>
    <tr>
      <th><strong>Arithmetischer Operator</strong></th>
      <th><strong>Operation</strong></th>
      <th><strong>Ergebnis</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`$zahl1 + $zahl2`</td>
      <td>Addition</td>
      <td>Summe von `$zahl1` und `$zahl2`</td>
    </tr>
    <tr>
      <td>`$zahl1 - $zahl2`</td>
      <td>Subtraktion</td>
      <td>Differenz von `$zahl1` und `$zahl2`</td>
    </tr>
    <tr>
      <td>`$zahl1 * $zahl2`</td>
      <td>Multiplikation</td>
      <td>Produkt von `$zahl1` und `$zahl2`</td>
    </tr>
    <tr>
      <td>`$zahl1 / $zahl2`</td>
      <td>Division</td>
      <td>Quotient von `$zahl1` und `$zahl2`</td>
    </tr>
    <tr>
      <td>`$zahl1 ** $zahl2`</td>
      <td>Potenz</td>
      <td>`$zahl2`-te Potenz von `$zahl1`</td>
    </tr>
  </tbody>
</table>

```php
<?php
$zahl1 = 10;
$zahl2 = 5;
$addition = $zahl1 + $zahl2; //Addition
$subtraktion = $zahl1 - $zahl2; //Subtraktion
$multiplikation = $zahl1 * $zahl2; //Multiplikation
$division = $zahl1 / $zahl2; //Division
$potenz = $zahl1 ** $zahl2; //Potenzrechnung
echo "Ergebnis der Addition: " . $addition ."<br />";
echo "Ergebnis der Subtraktion: " . $subtraktion . "<br />";
echo "Ergebnis der Multiplikation: " . $multiplikation . "<br />";
echo "Ergebnis der Division: " . $division . "<br />";
echo "5-te Potenz von 10 (10^5): " . $potenz . "<br />";
echo "Wurzel von 81: " . sqrt(81) . "<br />";
```

Die Ausgabe sieht wie folgt aus:

[![Bild: Rechnen mit Variablen](https://www.ionos.at/digitalguide/fileadmin/_processed_/1/d/csm_php-tutorial-mit-variablen-rechnen_094558d6d0.webp "Rechnen mit Variablen")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-mit-variablen-rechnen.jpg) Sie können die gängigen Rechenoperationen in PHP auch mit numerischen Variablen durchführen. Für komplexe Berechnungen lassen sich die verschiedenen arithmetischen Operationen in einem Skript kombinieren:

```php
<?php
$zahl1 = 10;
$zahl2 = 5;
$ergebnis = 2 *$zahl1 + 5* $zahl2 - 3 * sqrt(81);
echo "Ergebnis: " . $ergebnis;
```

Der PHP-Interpreter ermittelt die Werte der Variablen und berechnet:

`2 *10 + 5* 5 - 3 * √81 = 20 + 25 – 27 = 18`

Die Funktion `sqrt()` berechnet die Quadratwurzel des eingeklammerten Parameters. Es gilt die klassische **Operator-Rangfolge** der Mathematik: Punkt- vor Strichrechnung. Die Anweisung `echo` gibt das Ergebnis als String für den Webbrowser aus.

**Eingeklammerte Terme** werden auch in PHP zuerst ausgewertet. Wir arbeiten diesmal mit Fließkommazahlen:

```php
<?php
$zahl1 = 2.5;
$zahl2 = 3.7;
$ergebnis = 2 *($zahl1 + 5)* ($zahl2 - 3) * sqrt(81);
echo "Ergebnis: " . $ergebnis;
```

[![Bild: Berechnung mit Fließkommazahlen und eingeklammerten Termen](https://www.ionos.at/digitalguide/fileadmin/_processed_/1/a/csm_php-tutorial-fliesskommazahlen_df5d513cfd.webp "Berechnung mit Fließkommazahlen und eingeklammerten Termen")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-fliesskommazahlen.jpg) Die Berechnungen funktionieren ebenfalls mit Fließkommazahlen. Wie die meisten gängigen Programmiersprachen unterstützt auch PHP Operatoren, um **Zahlenwerte um den Wert 1 zu erhöhen oder zu vermindern**. Man unterscheidet zwischen dem Prä-Inkrementoperator, dem Prä-Dekrementoperator, dem Post-Inkrementoperator und Post-Dekrementoperator.

<table>
  <thead>
    <tr>
      <th><strong>Operation</strong></th>
      <th><strong>Operator</strong></th>
      <th><strong>Ergebnis</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Prä-Inkrement</td>
      <td>`++$zahl`</td>
      <td>Der Operator `++` inkrementiert den Wert der Variable `$zahl`. Dabei wird der Wert um 1 erhöht. Das Ergebnis wird als neuer Wert von `$zahl` zurückgegeben.</td>
    </tr>
    <tr>
      <td>Prä-Dekrement</td>
      <td>`--$zahl`</td>
      <td>Der Operator `--` dekrementiert den Wert der Variable `$zahl`. Dabei wird der Wert um 1 vermindert. Das Ergebnis wird als neuer Wert von `$zahl` zurückgegeben.</td>
    </tr>
    <tr>
      <td>Post-Inkrement</td>
      <td>`$zahl++`</td>
      <td>Der aktuelle Wert von `$zahl` wird zunächst zurückgegeben und anschließend um den Wert 1 erhöht.</td>
    </tr>
    <tr>
      <td>Post-Dekrement</td>
      <td>`$zahl--`</td>
      <td>Der aktuelle Wert von `$zahl` wird zunächst zurückgegeben und anschließend um den Wert 1 vermindert.</td>
    </tr>
  </tbody>
</table>

Wir demonstrieren die Rechenoperationen mit Inkrement- bzw. Dekrementoperatoren am Beispiel der Prä-Inkrementierung. Folgendes Skript erhöht den Wert der Variable `$zahl` um 1, speichert den neuen Wert in der Variable `$ergebnis` und gibt deren Wert anschließend als String aus:

```php
<?php
$zahl = 0;
$ergebnis = ++$zahl;
echo "Ergebnis: " . $ergebnis;
```

Erhöht man den Wert 0 um 1, erhält man das Ergebnis 1.

[![Bild: Prä-Inkrementierung der Zahl 0](https://www.ionos.at/digitalguide/fileadmin/_processed_/4/8/csm_php-tutorial-prae-inkrement_a88b9c8d5c.webp "Prä-Inkrementierung der Zahl 0")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-prae-inkrement.jpg) Die Prä-Inkrementierung erhöht den Wert der Variable, bevor sie ausgegeben wird, um eins. Um das Prä-Dekrement der Variable `$zahl` zu berechnen, bedienen wir uns derselben Skripts, tauschen jedoch den Prä-Inkrementoperator (`++`) gegen den Prä-Dekrementoperator (`--`):

```php
<?php
$zahl = 0;
$ergebnis = --$zahl;
echo "Ergebnis: " . $ergebnis;
```

Wir dekrementieren somit den Wert 0 der Variable `$zahl` und erhalten das Ergebnis -1.

Eine Erhöhung vor und nach der Ausgabe (Prä- vs. Post-…) eines Wertes lässt sich an folgendem Skript verdeutlichen:

```php
<?php
$x = 0;
echo '<p>Ergebnis: ' . ++$x;
echo '<br>x hat den Wert ' . $x;
echo '<p>Ergebnis: ' . $x++;
echo '<br>x hat den Wert ' . $x, '</p>';
```

In beiden Fällen erhalten wir dasselbe Ergebnis. Bei der Prä-Inkrementierung wird der Wert x vor der Ausgabe in Zeile 3 erhöht und bei der Post-Inkrementierung nach der Ausgabe in Zeile 5.

[![Bild: Der Unterschied zwischen Prä- und Post-Inkrementierungen](https://www.ionos.at/digitalguide/fileadmin/_processed_/4/f/csm_php-tutorial-prae-post-inkrement_9edcc7a9d1.webp "Der Unterschied zwischen Prä- und Post-Inkrementierungen")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-prae-post-inkrement.jpg) Bei der Prä-Inkrementierung wird der Wert der Variable vor der Ausgabe erhöht; bei der Post-Inkrementierung danach. ## Skalare Typen und Union Types

PHP ermöglicht es, Variablen, Funktionsparameter und Rückgabewerte mit sogenannten **skalaren Typen** zu versehen. Zu diesen zählen unter anderem `int`, `float`, `string` und `bool`. Durch die explizite Typangabe wird festgelegt, welche Art von Werten eine Funktion erwartet und zurückliefert. Dies erhöht die Lesbarkeit des Codes und hilft dabei, typische Fehler frühzeitig zu erkennen.

```php
function hi(string $name): string {
return "Hallo " . $name;
}
```

In diesem Beispiel erwartet die selbstgeschriebene Funktion `hi()` einen String als Parameter und gibt ebenfalls einen String zurück. Wird ein anderer Datentyp übergeben, meldet PHP einen Fehler. In manchen Situationen soll eine Funktion jedoch mehr als einen Datentyp akzeptieren. Dafür stellt PHP sogenannte **Union Types** zur Verfügung. Diese erlauben es, mehrere mögliche Typen zu definieren, getrennt durch das Pipe-Zeichen `|`:

```php
function formatId(int|string $id): string {
return "ID: " . $id;
}
```

Die Funktion `formatId()` akzeptiert hier sowohl Ganzzahlen als auch Zeichenketten als Parameter. Andere Datentypen sind nicht erlaubt. Union Types ermöglichen damit flexible, aber dennoch kontrollierte Funktionssignaturen.

## Die Superglobals `$_GET` und `$_POST`

Sie kennen jetzt die PHP-Grundlagen, wissen mit Variablen umzugehen, können diese verketten und Berechnungen anstellen. Nun zeigen wir Ihnen, warum Variablen ein zentrales Konzept beim Programmieren von Skripten sind.

Eine wichtige Funktion von Skriptsprachen ist die Möglichkeit, Benutzereingaben auszuwerten und die Werte in ein anderes Skript zu übertragen. PHP stützt sich bei der Datenübergabe auf die Superglobals `$_GET` und `$\_POST` – vordefinierte **System-Variablen**, die in allen Gültigkeitsbereichen verfügbar sind. Als assoziative Arrays (Datenfelder) speichern `$_GET` und `$_POST` einen Satz von Variablen in Form von Strings in einer Variable.

[PHP-Arrays](https://www.ionos.at/digitalguide/websites/web-entwicklung/php-arrays/) können Sie sich wie einen Schrank mit mehreren Schubladen vorstellen. Jede dieser Schubladen bietet Ihnen die Möglichkeit, Daten abzulegen. Damit Sie später noch wissen, was in welcher Schublade steckt, beschriften Sie diese mit einem Variablen-Namen. Je nach Art des Arrays kann es sich dabei um einen **Index oder einen Key (Schlüssel)** handeln. Während Sie bei indizierten Arrays für jede Schublade einen Index in Form einer Zahl vergeben, beschriften Sie die Schubladen eines assoziativen Arrays mit einem Key in Form eines Strings (Zeichenfolge).

Die Superglobals `$_GET` und `$_POST` beinhalten eine Reihe von Variablen in Form von Schlüsseln, die es ermöglichen, an die mit diesen Schlüsseln verbundenen Werte zu gelangen. Wir kommen darauf zurück, wenn wir uns die Superglobals `$_GET` und `$_POST` im Detail anschauen.

### Datenübergabe via `$_GET`

Die Superglobal `$_GET` stellt ein Array von Variablen dar, die einem PHP-Skript mithilfe einer URL übergeben werden.

Falls Sie sich hin und wieder auf **Weblogs** oder in **Onlineshops** und **Internetforen** aufhalten, werden Ihnen möglicherweise die eigenartigen URLs aufgefallen sein, die man dort antrifft. Üblich ist ein Aufbau nach folgendem Schema:

`http://hostname/ordner/dateiname.php?variablenname=variablenwert`

Auf ein Weblog übertragen könnte dieses Schema so aussehen:

`http://www.beispiel-blog.de/index.php?id=1`

Eine solche URL lässt sich ganz einfach aufschlüsseln: Auf einem Webserver mit der Domain „beispiel-blog.de“ findet sich eine Datei namens „index.php“, die der Erstellung einer dynamischen Webseite dient. Diese enthält in der Regel HTML- und PHP-Code sowie Verweise auf ausgelagerte Template-Files und externe Stylesheets – kurz alles, was benötigt wird, um eine Webseite darzustellen.

Dass es sich wahrscheinlich um eine dynamische Webseite handelt, signalisiert der Zusatz nach dem Fragezeichen (`?`): `id=1`. Dieser wird als [HTTP](https://www.ionos.at/digitalguide/hosting/hosting-technik/was-ist-http/)-Query-String bezeichnet und beinhaltet eine Variable (`id`) und einen Wert (`1`), die mit einem Gleichheitszeichen (`=`) verbunden sind. **URL-Parameter** dieser Art werden beispielsweise eingesetzt, um eine dynamische Webpage zu erzeugen, Inhalte aus einer Datenbank zu laden oder ein passendes Template aufzurufen.

Dynamische Webseiten ermöglichen eine **Trennung von Inhalt und Präsentation**. Die „index.php“ beinhaltet zwar alle Informationen über die Struktur der Website, muss jedoch noch mit Inhalten befüllt werden. Diese sind in der Regel in einer **Datenbank** hinterlegt und lassen sich über die Parameter im HTTP-Query-String abrufen. In unserem Beispiel übergibt die URL der „index.php“ den Parameter: `id=1`. Dieser legt fest, welche Inhalte aus der Datenbank ausgelesen und in die „index.php“ geladen werden sollen. Bei einem Weblog handelt es sich meist um die ID eines bestimmten Artikels. In einem Forum ließe sich so ein bestimmter Eintrag abrufen und in einem Onlineshop ein bestimmtes Produkt.

Beinhaltet eine URL mehr als einen Parameter, werden diese mit einem **Et-Zeichen (`&`)** verbunden.

`www.beispiel-blog.de/index.php?page=article&id=1`

Um den Einsatz von `$_GET` an einem Codebeispiel zu veranschaulichen, kommen wir auch ohne Datenbank aus. In folgendem Skript verwenden wir die Superglobal `$_GET`, um die Werte der Variablen `vorname` und `nachname` aus einem HTTP-Query-String auszulesen und in die PHP-Variablen `$variable1` und `$variable2` zu schreiben:

```php
<?php
$variable1 = $_GET['vorname'];
$variable2 = $_GET['nachname'];
echo "Hello " . $variable1 . " " . $variable2 . "!";
```

Der Aufruf der des Skripts erfolgt durch folgende URL:

`localhost/hello.php?vorname=John&nachname=Doe`

Wir übergeben somit die Parameter `vorname=John` und `nachname=Doe`. Die Ausgabe der Werte erfolgt wie bisher mithilfe des Sprachkonstrukts `echo`.

[![Bild: Datenübergabe mittels $_GET](https://www.ionos.at/digitalguide/fileadmin/_processed_/f/f/csm_php-tutorial-datenuebergabe-get_224ddb25ea.webp "Datenübergabe mittels $_GET")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-datenuebergabe-get.jpg) Mit $\_GET können Sie Werte für Ihre Variablen aus der URL lesen. Eine Datenübergabe via `$_GET` führt zwangsläufig dazu, dass die übertragenen **Daten in der Adresszeile sichtbar** sind. Es lässt sich somit jederzeit nachvollziehen, welche Parameter übergeben werden. Dies hat den Vorteil, dass Variablen in Hyperlinks gespeichert werden können. Zudem haben Internetnutzerinnen und -nutzer die Möglichkeit, URLs inklusive HTTP-Query-String als Lesezeichen im Browser abzulegen.

Dass `GET`-Parameter in Klartext in der URL aufgeführt werden, disqualifiziert diese Methode jedoch für die Übergabe sensibler Daten, wie sie beispielsweise bei Onlineformularen anfallen. Darüber hinaus ist der Umfang der Daten, die Mittels `$_GET` übergeben werden können, durch die Maximallänge von URLs begrenzt.

Hinweis Umgehen lassen sich diese Einschränkungen mit der HTTP-Methode `POST`. Die damit übergebenen Daten finden Sie in der Superglobal `$_POST`.

### Datenübergabe via `$_POST`

Die HTTP-Methoden [GET und POST](https://www.ionos.at/digitalguide/websites/web-entwicklung/get-vs-post/) unterscheiden sich in der Art der Datenübergabe: Während die zu übertragenden Daten bei der `GET`-Methode als URL-Parameter übergeben werden, erfolgt die Datenübergabe via `$_POST` im Body einer HTTP-Anfrage. Dies ermöglicht es, auch große Datenmengen von einem Skript an ein anderes zu übergeben.

Ein zentrales Anwendungsfeld der HTTP-`POST`-Methode ist die **Übertragung von HTML-Formulardaten**. Wir demonstrieren das am Beispiel einer Newsletter-Anmeldung. Erstellen Sie dazu eine neue PHP-Datei mit dem Namen „seite1.php“ und übernehmen Sie folgenden Codeblock:

```html
<form method="post" action="seite2.php" >
Bitte senden Sie den Newsletter an: <br />
Ihr Vorname: <input type="text" name="vorname" /><br />
Ihr Nachname: <input type="text" name="nachname" /><br />
Ihre E-Mail-Adresse: <input type="text" name="email" /><br />
<input type="submit" value="Formular absenden" />
</form>
```

Zur Erstellung von Formularen kommt das HTML-Element `<form>` zum Einsatz. Dieses enthält im Start-Tag zwei Attribute: `method` und `action`. Mit dem `method`-Attribut definieren Sie die Übertragungsmethode, in diesem Fall HTTP-`POST`. Im `action`-Attribut wird die URL eines Skripts hinterlegt, das sämtliche Daten empfängt, die über nachfolgende Eingabefelder erfasst werden. Das Beispiel zeigt ein **HTML-Formular mit drei Eingabeelementen** (`input type="text"`) und einem **Absende-Button** (`input type="submit"`). Als Empfänger der Daten ist die Datei „seite2.php“ definiert.

Um die Datenübergabe mittels `$_POST` zu veranschaulichen, nutzen wir für die Auswertung der Formulardaten ein einfaches Skript, das die übermittelten Werte als PHP-Variablen speichert und in Textform ausgibt. Erstellen Sie dazu eine Datei „seite2.php“ und fügen Sie folgenden Programmcode ein:

```php
<?php
$vorname = $_POST["vorname"];
$nachname = $_POST["nachname"];
$email = $_POST["email"];
echo "Hallo " . $vorname . " " . $nachname . ", <br />
Sie haben sich mit folgender E-Mail-Adresse registriert: " . $email . ".";
```

Speichern Sie die beiden PHP-Dateien im „htdocs“-Ordner Ihres Testservers und rufen Sie „seite1.php“ über folgende URL im Webbrowser auf: `http://localhost/seite1.php`. Ihr Browser zeigt Ihnen nun die interaktive Weboberfläche Ihres HTML-Formulars.

[![Bild: Dateneingabe via HTML-Formular](https://www.ionos.at/digitalguide/fileadmin/_processed_/0/f/csm_php-tutorial-html-formular_8c58af26fb.webp "Dateneingabe via HTML-Formular")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-html-formular.jpg) Sie können im HTML-Formular nun Werte eingeben, die zu Ihrem anderen Skript übertragen werden. Geben Sie beliebige Anmeldedaten ein und drücken Sie den Absende-Button, um Variablen von einem Skript zum anderen zu übertragen. Sobald Sie die Eingabe auf „seite1.php“ bestätigt haben, werden Sie umgehend auf „seite2.php“ weitergeleitet. Das Browserfenster zeigt das Ergebnis der Skriptausführung auf Basis der übermittelten Daten.

[![Bild: Ausgabe der Benutzerdaten](https://www.ionos.at/digitalguide/fileadmin/_processed_/e/9/csm_php-tutorial-datenweitergabe-post_6cb6e24efe.webp "Ausgabe der Benutzerdaten")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-datenweitergabe-post.jpg) Die Daten wurden nun zum anderen Skript übertragen. Nutzereingaben, die über die Inputfelder von „seite1.php“ erfasst werden, werden von „seite2.php“ über folgendes Schema abgerufen:

`$_POST["Name des Inputfeldes"]`

So ruft die Zeile `$vorname = $_POST["vorname"]` die Eingabe im Inputfeld `vorname` ab und speichert diese in der Variable `$vorname`. Die Variable `$vorname` wiederum lässt sich mittels `echo` als String ausgeben.

## Das `if`-Konstrukt und die PHP-Vergleichsoperatoren

Bisher haben wir Variablen definiert, diese von einem Skript zum nächsten übertragen und als String ausgegeben. Im nächsten Schritt werden Sie lernen, die Ausführung von Codefragmenten an bestimmte **Bedingungen** zu knüpfen.

Das Sprachkonstrukt `if` gibt Ihnen die Möglichkeit, Skripte so zu schreiben, dass Anweisungen erst dann zum Tragen kommen, wenn eine durch Sie definierte Bedingung erfüllt ist – beispielsweise die Eingabe eines korrekten Passworts.

Bedingungen werden in PHP nach folgendem Grundgerüst definiert:

```php
<?php
if(expression)
{
statement;
}
```

Dieses liest sich folgendermaßen: Nur dann, wenn die Bedingung in der `expression` erfüllt ist, wird das `statement` ausgeführt. Erfüllt ist eine Bedingung immer dann, wenn das `if`-Konstrukt das Ergebnis `TRUE` (wahr) zurückgibt. Andernfalls gilt diese als `FALSE` (falsch). In diesem Fall wird die Anweisung übersprungen.

In der Regel prüft das `if`-Konstrukt, ob der Wert einer Variablen dem entspricht, was in der Bedingung definiert wurde. Realisiert wird diese **Kontrollstruktur** normalerweise auf Basis von Vergleichsoperatoren.

### Vergleichsoperatoren

Vergleichsoperatoren kommen bei der Formulierung von Bedingungen zum Einsatz, um zwei Argumente in eine **logische Beziehung** setzen, die als wahr (`TRUE`) oder falsch (`FALSE`) evaluiert werden kann. Kommen Vergleichsoperatoren in PHP-Kontrollstrukturen zum Einsatz, werden diese auf zwei Variablen in der `expression` eines `if`-Konstrukts angewendet:

```php
if ($a == $b)
{
statement;
}
```

Versprachlicht lautet die Kontrollstruktur: Wenn Variable `$a` ist gleich Variable `$b` gilt, dann werden die im `statement` definierten Anweisungen ausgeführt.

Die **PHP-Vergleichsoperatoren** sind an die Programmiersprache C angelehnt und unterscheiden sich in ihrer Schreibweise zum Teil erheblich von den klassischen Symbolen der Mathematik. Eine Übersicht finden Sie in nachstehender Tabelle.

<table>
  <thead>
    <tr>
      <th><strong>Vergleichsoperator</strong></th>
      <th><strong>Beschreibung</strong></th>
      <th><strong>Bedingung</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`==`</td>
      <td>ist gleich</td>
      <td>Die Bedingung ist erfüllt, wenn `$a` und `$b` den gleichen Wert aufweisen.</td>
    </tr>
    <tr>
      <td>`===`</td>
      <td>ist identisch</td>
      <td>Die Bedingung ist erfüllt, wenn `$a` und `$b` den gleichen Wert aufweisen und demselben Datentyp angehören. Veranschaulichen lässt sich dies an einem Beispiel, bei dem eine Integer (1) mit einem String (“1”) verglichen wird: `1 == "1"` wird zu `TRUE` und `1 === "1"` wird zu `FALSE`. Verwenden Sie für Bedingungen, die die Gleichheit zweier Variablen voraussetzen, am besten immer den Vergleichsoperator `===` (ist identisch).</td>
    </tr>
    <tr>
      <td>`!=`</td>
      <td>ist ungleich</td>
      <td>Die Bedingung ist erfüllt, wenn `$a` und `$b` ungleiche Werte aufweisen.</td>
    </tr>
    <tr>
      <td>`!==`</td>
      <td>nicht identisch</td>
      <td>Die Bedingung ist erfüllt, wenn `$a` und `$b` ungleiche Werte aufweisen oder unterschiedlichen Datentypen angehören.</td>
    </tr>
    <tr>
      <td>`<`</td>
      <td>ist kleiner als</td>
      <td>Die Bedingung ist erfüllt, wenn der Wert von `$a` kleiner ist als der Wert von `$b`.</td>
    </tr>
    <tr>
      <td>`>`</td>
      <td>ist größer als</td>
      <td>Die Bedingung ist erfüllt, wenn der Wert von `$a` größer ist als der Wert von `$b`.</td>
    </tr>
    <tr>
      <td>`<=`</td>
      <td>ist kleiner oder gleich</td>
      <td>Die Bedingung ist erfüllt, wenn der Wert von `$a` kleiner ist als der Wert von `$b` oder `$a` und `$b` den gleichen Wert aufweisen.</td>
    </tr>
    <tr>
      <td>`>=`</td>
      <td>ist größer oder gleich</td>
      <td>Die Bedingung ist erfüllt, wenn der Wert von `$a` größer ist als der Wert von `$b` oder `$a` und `$b` den gleichen Wert aufweisen.</td>
    </tr>
  </tbody>
</table>

Folgendes Skript soll diese Kontrollstruktur verdeutlichen. Verglichen werden zwei Integers. Als Vergleichsoperator kommt `<` (ist kleiner) zum Einsatz:

```php
<?php
$zahl1 = 10;
$zahl2 = 20;
if($zahl1 < $zahl2) {
echo "Die Bedingung ist erfüllt";
}
```

Wir definieren die Variablen `$zahl1` und `$zahl2` und weisen diesen die Werte `10` und `20` zu. Im Anschluss stellen wir eine Bedingung auf: Wenn `$zahl1` kleiner ist als `$zahl2`, soll der in der `echo`-Anweisung aufgeführte String ausgegeben werden.

Das Ergebnis der Skriptausführung enthält die Antwort: 10 ist kleiner als 20. Das `if`-Konstrukt gibt das Ergebnis `TRUE` zurück. Die Bedingung ist erfüllt.

[![Bild: Das Sprachkonstrukt if in der Anwendung](https://www.ionos.at/digitalguide/fileadmin/_processed_/8/6/csm_php-tutorial-if-kleiner_53a47f2b7e.webp "Das Sprachkonstrukt if in der Anwendung")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-if-kleiner.jpg) Der Code nach der if-Anweisung wird ausgeführt, wenn die spezifizierte Bedingung zutrifft. Möchten Sie Anweisungen definieren, die ausgeführt werden, sobald eine Bedingung nicht erfüllt wurde, ergänzen Sie die `if`-Kontrollstruktur um das Sprachkonstrukt `else` zu einem If-Else-Statement in PHP:

```php
<?php
if(Bedingung a)
{
Anweisung b;
}
else
{
Anweisung c;
}
```

Auch dieses Skript prüft, ob die Bedingung a das Ergebnis `TRUE` oder `FALSE` zurückgibt. Ist die Bedingung a erfüllt, wird Anweisung b ausgeführt. Ist die Bedingung a nicht erfüllt (`FALSE`), wird Anweisung b übersprungen und stattdessen Anweisung c ausgeführt.

Wir erweitern unser Skript um das `else`-Konstrukt und tauschen den Vergleichsoperator `<` (ist kleiner) gegen `==` (ist gleich):

```php
<?php
$zahl1 = 10;
$zahl2 = 20;
if($zahl1 == $zahl2)
{
echo "Die Bedingung ist erfüllt";
}
else
{
echo "Die Bedingung ist nicht erfüllt";
}
```

Diesmal gibt das `if`-Konstrukt das Ergebnis `FALSE` zurück. Der Wert der Variable `$zahl1` ist nicht gleich dem Wert der Variable `$zahl2`. Die Bedingung ist nicht erfüllt. Es wird somit nicht die unter `if` aufgeführte Anweisung ausgeführt, sondern die unter `else` definierte.

[![Bild: Das Sprachkonstrukt else in der Anwendung](https://www.ionos.at/digitalguide/fileadmin/_processed_/8/9/csm_php-tutorial-if-else_f5ba5587b0.webp "Das Sprachkonstrukt else in der Anwendung")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-if-else.jpg) Wenn die if-Bedingung nicht zutrifft, wird der Code hinter dem else-Statement ausgeführt.  Hinweis Soll die Ausführung eines Codefragments an die Gleichheit zweier Werte gebunden werden, kommt in PHP ein doppeltes Gleichheitszeichen (`==`) zum Einsatz. Das einfache Gleichheitszeichen (`=`) verwenden Sie ausschließlich bei der Zuweisung von Werten zu Variablen.

Die **Negation von Bedingungen** erfolgt durch ein vorangestelltes Ausrufezeichen (`!`).

```php
<?php
$zahl1 = 10;
$zahl2 = 20;
if ($zahl1 == $zahl2)
{
echo "Die Zahlen sind gleich.";
}
if (!($zahl1 == $zahl2))
{
echo "Die Zahlen sind nicht gleich.";
}
```

Das Beispiel zeigt die Bedingung `$zahl1 == $zahl2` und deren Verneinung. `!($zahl1 == $zahl2)` entspricht `($zahl1 != $zahl2)`.

Eine praktische Anwendung von `if` und `else` ist beispielsweise die **Passwortabfrage** auf Basis eines HTML-Formulars. Wir simulieren diese erneut mithilfe unserer PHP-Dateien „seite1.php“ und „seite2.php“.

Öffnen Sie „seite1.php“ und fügen Sie folgenden Formularcode ein:

```html
<form action="seite2.php" method="post">
Bitte geben Sie Ihr Passwort ein: <input type="password" name="passwort" />
<input type="submit" value="Absenden" />
</form>
```

Der Aufbau entspricht dem bereits erstellten Formular. Diesmal genügt uns jedoch ein Eingabefeld: die Passwortabfrage. Wie zuvor werden Benutzereingaben an das Skript „seite2.php“ übermittelt.

Dieses passen wir mit folgendem Code so an, dass die Passworteingabe **mit einem hinterlegten Passwort abgeglichen** wird:

```php
<?php
$passwort = $_POST["passwort"];
if($passwort=="qwertz123")
{
echo "Das Passwort war korrekt";
}
else
{
echo "Das Passwort war falsch";
}
```

Der Code liest sich wie folgt: Zunächst weisen wir der Variable `$passwort` in Zeile 2 einen Wert zu, den wir über die HTTP-`POST`-Methode abrufen. Im Anschluss definieren wir folgende Kontrollstruktur: Das `if`-Kontrukt in Zeile 3 soll prüfen, ob der Wert der Variable `$passwort` mit dem String `qwertz123` übereinstimmt. Ist dies der Fall, wird der String „Das Passwort war korrekt“ ausgegeben. Gibt `if` das Ergebnis `FALSE` zurück, kommt `else` in Zeile 7 zum Einsatz und es wird der String „Das Passwort war falsch“ ausgegeben.

Nun rufen wir das Skript „seite1.php“ über die URL `http://localhost/seite1.php` auf.

[![Bild: Weboberfläche des HTML-Formulars zur Passwortabfrage](https://www.ionos.at/digitalguide/fileadmin/_processed_/d/1/csm_php-tutorial-html-passwortabfrage_6666e12381.webp "Weboberfläche des HTML-Formulars zur Passwortabfrage")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-html-passwortabfrage.jpg) Im Webformular können Sie nun ein Passwort eingeben. Der Browser präsentiert uns die Webansicht unseres HTML-Formulars zur Passwortabfrage. Wir kommen der Aufforderung nach, geben das in Skript „seite2.php“ definierte Passwort „qwertz123“ ein und klicken auf den Absenden-Button.

[![Bild: Die Passwortabfrage war korrekt](https://www.ionos.at/digitalguide/fileadmin/_processed_/6/7/csm_php-tutorial-if-else-passwort_7554bbd1f4.webp "Die Passwortabfrage war korrekt")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-if-else-passwort.jpg) Wenn Sie das richtige Passwort eingegeben haben, greift die if-Bedingung aus dem Skript und eine Erfolgsmeldung wird angezeigt. Der Webbrowser leitet uns automatisch auf „seite2.php“ um. Im Hintergrund gleicht die `if`-Kontrollstruktur unsere Eingabe mit dem hinterlegten Passwort ab und kommt zu dem Ergebnis „`qwertz123 == qwertz123` ist `TRUE`“ und gibt den String „Das Passwort war korrekt“ aus. Testen Sie selbst, was passiert, wenn Sie ein abweichendes Passwort in das Eingabefeld tippen.

### Logische Operatoren

Bedingungen, die Sie mithilfe von Vergleichsoperatoren in der Expression des `if`-Konstrukts definieren, lassen sich bei Bedarf mit weiteren Bedingungen in derselben Expression verknüpfen. PHP stützt sich dabei auf die logischen Operatoren `AND` und `OR`.

<table>
  <thead>
    <tr>
      <th><strong>Enge Bindung</strong></th>
      <th><strong>Schwache Bindung</strong></th>
      <th><strong>Beschreibung</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`&&`</td>
      <td>`AND`</td>
      <td>Beide Bedingungen, die mit dem Operator verbunden sind, müssen `TRUE` sein.</td>
    </tr>
    <tr>
      <td>`</td><td></td><td>`</td>
    </tr>
  </tbody>
</table>

Um Bedingungen zu verknüpfen, stehen Ihnen in PHP **logische Operatoren mit enger und mit schwacher Bindung** zur Verfügung. Nutzen Sie lediglich eine der beiden Schreibweisen, werden Sie in der Praxis keinen Unterschied bemerken. Kombinieren Sie beide Schreibweisen, werden Sie feststellen, dass `&&` und `||` enger binden als `AND` und `OR`. Vergleichbar ist dies mit der Operator-Rangfolge, wie sie von mathematischen Operatoren bekannt ist (z. B. Punkt vor Strich: `*` bindet enger als `+`).

Ein praxisnahes Beispiel bietet wiederum die **Passwortabfrage**. In der Regel umfassen Anmeldedaten ein geheimes Passwort sowie einen Benutzernamen. Nur wenn beide Eingaben mit den im System hinterlegten Daten übereinstimmen, ist der Log-in erfolgreich.

Wir öffnen erneut unser Formular zur Passwortabfrage in „Seite1.php“ und ergänzen ein Eingabefeld für den Benutzernamen:

```html
<form action="seite2.php" method="post">
Benutzername: <input type="text" name="username" /><br />
Passwort: <input type="password" name="passwort" /><br />
<input type="submit" value="Absenden" />
</form>
```

Im nächsten Schritt müssen wir auch die Kontrollstruktur des `if`-Konstrukts anpassen. Wir nutzen dazu den logischen Operator `AND`, um die Bedingung für die Passwortabfrage mit einer Bedingung für die Abfrage des Benutzernamens zu verknüpfen.

```php
<?php
$username = $_POST["username"];
$passwort = $_POST["passwort"];
if($username=="John Doe" AND $passwort=="qwertz123")
{
echo "Willkommen im internen Bereich " . $username . "!";
}
else
{
echo "Zugriff fehlgeschlagen";
}
```

Unser Skript „seite2.php“ bekommt nun die Werte für `username` und `passwort` übergeben und speichert diese in den Variablen `$username` und `$passwort`. Die Expression des `if`-Konstrukts enthält nun **zwei Bedingungen, die mit dem logischen Operator `AND` verbunden sind**. Nur wenn beide Bedingungen erfüllt sind (`username=="John Doe"` und `$passwort=="qwertz123"`), gibt `if` das Ergebnis `TRUE` zurück.

Da wir durch das Eingabefeld `username` den Benutzernamen erhalten, können wir diesen direkt für die Textausgabe via `echo` verwenden: Auf „Willkommen im internen Bereich“ folgt der Wert der Variable `$username`. Ist eine der beiden Bedingungen nicht erfüllt, erhalten wir die Textausgabe: „Zugriff fehlgeschlagen“.

[![Bild: Passwortabfrage mit zwei Bedingungen](https://www.ionos.at/digitalguide/fileadmin/_processed_/e/6/csm_php-tutorial-logische-operatoren_7b113f3ab8.webp "Passwortabfrage mit zwei Bedingungen")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-logische-operatoren.jpg) Nur, wenn beide Bedingungen, die mit AND verknüpft sind, zu TRUE auswerten, ist die Anmeldung erfolgreich. Logische Operatoren lassen sich beliebig kombinieren. Dabei gilt: `AND` hat eine höhere Operator-Rangfolge als `OR`. Wie bei mathematischen Gleichungen können Sie auch bei PHP Klammern nutzen, um die Rangfolge zu beeinflussen.

### Bedingungen mit `match`

Bisher haben wir Entscheidungen in PHP mit `if`- und `else`-Anweisungen umgesetzt. Wenn jedoch ein einzelner Wert geprüft wird und je nach Wert unterschiedliche Ergebnisse entstehen sollen, kann der Code mit `if` schnell unübersichtlich werden. Genau für solche Fälle gibt es die Anweisung `match`.

```php
<?php
$status = 404;
echo match ($status) {
200 => "OK",
404 => "Nicht gefunden",
default => "Unbekannter Status",
};
```

In diesem Beispiel wird der Wert der Variable `$status` geprüft. Entspricht er dem Wert 200, liefert `match` den Text „OK“ zurück. Ist der Wert 404, wird „Nicht gefunden“ gesetzt. Trifft keiner der genannten Werte zu, greift der `default`-Fall und es wird „Unbekannt“ verwendet.

[![Bild: Meldung „Nicht gefunden“](https://www.ionos.at/digitalguide/fileadmin/_processed_/4/0/csm_php-tutorial-match_9a46dfc93a.webp "Meldung „Nicht gefunden“")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-match.jpg) Da die Variable $status auf den Wert 404 gesetzt ist, greift der zweite Fall der match-Bedingung und wir erhalten die Meldung „Nicht gefunden“. Der wichtigste Unterschied zu `if`-`else` besteht darin, dass match direkt einen Wert zurückgibt, der einer Variablen zugewiesen werden kann. Dadurch entfällt mehrfaches Schreiben von Zuweisungen innerhalb einzelner Bedingungen, und der Code bleibt kürzer, übersichtlicher und leichter verständlich.

## Schleifen (`while`, `for`)

Manchmal ist es notwendig, dass ein Skript einen bestimmten Codeabschnitt mehrmals durchläuft, bevor der restliche Programmcode ausgeführt wird. Programmiersprachen nutzen dafür das Konzept der Schleife – auch [PHP-Loops](https://www.ionos.at/digitalguide/websites/web-entwicklung/php-loops/) genannt. Dabei unterscheidet man **drei Typen von Schleifen**:

- `while`-Schleifen
- `do-while`-Schleifen
- `for`-Schleifen

### `while`-Schleifen

Bei der `while`-Schleife handelt es sich um den simpelsten Schleifentyp, der Ihnen in PHP zur Verfügung steht. Der **Grundaufbau** entspricht folgendem Schema:

```php
while (Bedingung)
{
Schleifenschritt und andere Anweisungen
}
```

Die `while`-Schleife weist PHP an, untergeordnete Anweisungen so lange auszuführen, wie die `while`-Bedingung erfüllt ist. Dazu prüft der PHP-Interpreter die Bedingung zu Beginn eines jeden Schleifendurchgangs. Gestoppt wird die Ausführung des untergeordneten Codes erst dann, wenn die `while`-Bedingung nicht mehr erfüllt ist.

Veranschaulichen lässt sich dieses Prinzip an einem einfachen Zählskript:

```php
<?php
$zahl = 1;
while ($zahl <= 10) {
echo $zahl++ . "<br />";
}
```

Im Abschnitt „Rechnen mit Variablen“ wurde das Prinzip des Inkrementierens eingeführt. In folgendem Skript greifen wir darauf zurück, nutzen diesmal jedoch einen Post-Inkrement-Operator, um den Wert der Integer-Variable `$zahl` pro Schleifendurchgang erst nach der Textausgabe via `echo` um 1 zu erhöhen. Als Bedingung für die `while`-Schleife definieren wir: `$zahl` kleiner/gleich 10. Die Anweisung `echo` wird somit so lange wiederholt, bis die `$zahl` einen Wert größer 10 angenommen hat.

[![Bild: Das Skript zählt bis 10 und bricht dann ab](https://www.ionos.at/digitalguide/fileadmin/_processed_/4/f/csm_php-tutorial-while-schleife_7cada656ce.webp "Das Skript zählt bis 10 und bricht dann ab")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-while-schleife.jpg) Sobald der Wert 10 erreicht ist, bricht die Schleife ab. Das Ergebnis der Skriptausführung ist ein String, der für jeden Schleifendurchgang den Wert der Variable `$zahl` ausgibt, bevor dieser inkrementiert wird. Das Skript zählt somit von 1 bis 10 und beendet die Codeausführung, sobald die `while`-Bedingung nicht mehr erfüllt ist.

### `do-while`-Schleifen

Der Aufbau der `do-while`-Schleife gleicht dem der `while`-Schleife. Der Unterschied ist nur, dass die Bedingung nicht am Anfang jedes Schleifendurchgangs, sondern erst am Ende geprüft wird. Das **Grundschema einer `do-while`-Schleife** entspricht folgendem Beispiel:

```php
do {
Schleifenschritt und andere Anweisungen
}
while (Bedingung)
```

Als `do-while`-Schleife programmiert, würde das vorhergehende Skript folgendermaßen aussehen:

```php
<?php
$zahl = 1;
do {
echo $zahl++ . "<br />";
}
while ($zahl <= 10);
```

Das Ergebnis bleibt in diesem Fall das Gleiche. Das Besondere an der `do-while`-Schleife ist, dass diese mindestens einmal durchlaufen wird, selbst wenn die Bedingung in keinem Schleifendurchgang erfüllt wird.

### `for`-Schleifen

Grundsätzlich hat die `for`-Schleife in einem PHP-Skript dieselbe Funktionalität wie die `while`-Schleife. Anders als bei dieser werden **Startwert, Bedingung und Anweisung jedoch innerhalb einer Zeile notiert** und nicht über drei oder mehr Zeilen verteilt. Der Grundaufbau der `for`-Schleife entspricht folgendem Schema:

```php
for (Startwert; Bedingung; Schleifenschritt)
Anweisungen
```

Das bereits bekannte Beispiel ließe sich somit als `for`-Schleife in kompakter Form notieren:

```php
<?php
for($zahl = 1; $zahl <= 10; $zahl++) {
echo $zahl . "<br /> ";
}
```

Zunächst wird für die Variable `$zahl` der Wert „1“ definiert. Dann prüft PHP, ob die Bedingung `$zahl <= 10` erfüllt ist. Trifft dies zu, wird die Schleife fortgesetzt und die Anweisungen unterhalb der Schleife werden ausgeführt (hier die Anweisung `echo`). Erst danach wird der Schleifenschritt ausgeführt; in diesem Fall spielt es keine Rolle, ob Sie Prä- oder Post-Inkrementierung wählen, weil diese Anweisung auf jeden Fall vor der Ausgabe ausgeführt wird. Ist der Schleifenschritt abgeschlossen, beginnt der nächste Schleifendurchgang.

Startwert, Bedingung und Schleifenschritt sind **optionale Elemente** einer `for`-Schleife. Theoretisch sind selbst leere Schleifen möglich. Diese wären jedoch redundant.

Grundsätzlich ist es Ihnen überlassen, ob Sie Ihre PHP-Skripte mit einer `for`- oder einer `while`-Schleife schreiben. Es gibt jedoch ein Argument, das dafür spricht, `for`-Schleifen zu bevorzugen: Kommen `for`-Schleifen zum Einsatz, haben Sie die Rahmendaten der Schleife besser im Blick. Dies beugt der Gefahr vor, aus Versehen eine Forever-Schleife zu schreiben, die so lange läuft, bis der Speicher des Interpreters voll ist. Dies passiert Ihnen in Bezug auf das vorhergehende Beispiel dann, wenn Sie vergessen, den Wert der Variable `$zahl` zu erhöhen.

Soll die Schleife unabhängig von der Bedingung jedoch mindestens einmal durchlaufen werden, ist die `do-while`-Schleife die Schleife der Wahl.

### `break` und `continue`

Der Ablauf einer `while`-, `do-while`- oder `for`-Schleife lässt sich durch die Anweisungen `break` und `continue` beeinflussen. Nutzen Sie `break`, um den Ablauf einer Schleife an einer beliebigen Stelle zu unterbrechen, und `continue`, um einen Schleifendurchgang zu überspringen. Beide Anweisungen werden mittels `if` an eine Bedingung gebunden. Folgendes Beispiel zeigt unser Zählskript mit einem `break`:

```php
<?php
for ($zahl = 1; $zahl <= 10; $zahl++) {
if ($zahl == 5) {
echo "Bei 5 brechen wir das Skript ab!";
break;
}
echo $zahl . "<br /> ";
}
```

In der `for`-Schleife haben wir definiert, dass der Wert der Variable `$zahl` ausgehend von einem Startwert 1 in jeder Schleifenrunde um den Wert 1 erhöht werden soll, bis die Variable den Wert 10 erreicht hat. Diese **Schleife stoppen wir nun vorzeitig** mit der Anweisung `break`, sobald `$zahl` den Wert 5 erreicht hat. Das Sprachkonstrukt `echo` gibt somit lediglich die Zahlen 1 bis 4 aus.

[![Bild: for-Schleife mit break](https://www.ionos.at/digitalguide/fileadmin/_processed_/c/8/csm_php-tutorial-break-statement_f5b4a36070.webp "for-Schleife mit break")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-break-statement.jpg) Mit break können Sie aus einer Schleife herausspringen, sobald eine bestimmte if-Bedingung erfüllt ist. Möchten wir lediglich die **Ausgabe der fünften Runde überspringen**, nicht jedoch den gesamten Schleifenablauf stoppen, ersetzen wir die Anweisung `break` durch `continue`:

```php
<?php
for ($zahl=1; $zahl <= 10; $zahl++) {
if ($zahl == 5) {
echo "Die 5 lassen wir aus!<br />";
continue;
}
echo $zahl . "<br /> ";
}
```

Statt der Ziffer 5 gibt uns PHP den unter `if` definierten Textstring „Die 5 lassen wir aus!“ aus.

[![Bild: for-Schleife mit continue-Anweisung](https://www.ionos.at/digitalguide/fileadmin/_processed_/9/1/csm_php-tutorial-continue-statement_5efe340a13.webp "for-Schleife mit continue-Anweisung")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-continue-statement.jpg) Mit continue können Sie einen Schleifendurchlauf überspringen, wenn eine bestimmte Bedingung eintritt. ## Dateioperationen

Dynamischen Webinhalten liegt eine Trennung von Inhalt und Präsentation zugrunde. Skriptsprachen wie PHP stellen daher verschiedene Funktionalitäten zur Verfügung, die es ermöglichen, **Inhalte aus externen Datenquellen** in zentrale Template-Files zu laden. In der Praxis handelt es sich bei diesen Datenquellen meist um Datenbanken, die mithilfe von Managementsystemen wie MySQL verwaltet werden. Darüber hinaus besteht die Möglichkeit, **Daten aus Dateien einzubinden**. Im Folgenden zeigen wir Ihnen, wie Sie Dateien als String in einem PHP-Skript einlesen und Textausgaben Ihres Skripts in Dateien speichern.

### Dateien einlesen

Um den Inhalt einer Datei einzulesen, stellt PHP diverse Funktionen bereit, von denen sich für unsere Zwecke insbesondere `file()` und `file_get_contents()` anbieten. Während die Funktion `file_get_contents()` den gesamten Inhalt einer Datei in einen String liest, speichert die Funktion `file()` den Inhalt als Array. Jedes Element des Arrays entspricht einer Zeile der Datei. Mittels `file()` ist es somit einfacher möglich, jede Zeile einzeln auszugeben.

Wir demonstrieren die PHP-Dateioperationen an der Textdatei „beispiel.txt“, die wir im Ordner „htdocs“ unseres Testservers ablegen. Inhalt der Datei sind vier Zeilen Blindtext:

[![Bild: Textdatei mir vier Zeilen Beispieltext](https://www.ionos.at/digitalguide/fileadmin/_processed_/5/5/csm_php-tutorial-beispiel-txt_107bf8109b.webp "Textdatei mir vier Zeilen Beispieltext")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-beispiel-txt.jpg) In unserer Textdatei sind vier Beispiel-Blindtextzeilen. Zunächst lesen wir die gesamte Datei als String ein. Dazu müssen wir der Funktion `file_get_contents()` den Namen der entsprechenden Datei als Parameter zuweisen. Dies geschieht nach folgendem Schema:

`file_get_contents('beispiel.txt')`

Nun haben wir die Möglichkeit, mit dem eingelesenen String zu arbeiten. Wir können diesen beispielsweise einer Variablen zuweisen und als Text im Webbrowser ausgeben:

```php
<?php
$beispiel = file_get_contents('beispiel.txt');
echo $beispiel;
```

In der Browseransicht sehen wir, dass der Textstring ohne Absätze ausgeben wird. Die Zeilenumbrüche der Originaldatei werden nicht sichtbar. Dies hängt damit zusammen, dass der Webbrowser die Textausgabe des Skripts als HTML-Code interpretiert. Umbrüche, die in Texteditoren definiert wurden, gehen dabei verloren.

[![Bild: Das Skript liest die Datei beispiel.txt aus](https://www.ionos.at/digitalguide/fileadmin/_processed_/b/a/csm_php-tutorial-file-get-contents_cfcfc5faf4.webp "Das Skript liest die Datei beispiel.txt aus")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-file-get-contents.jpg) Mit der Funktion file\_get\_contents() können Sie den Inhalt einer Datei lessn und dann in PHP verarbeiten. Möchten Sie an der ursprünglichen Struktur festhalten, haben Sie verschiedene Möglichkeiten. Sie können die HTML-Codierung für den Zeilenumbruch (`<br>`) in der Ausgangsdatei manuell mittels Suchen und Ersetzen ergänzen, ein `<pre>` um den Datei-Inhalt setzen, dem Bereich die [CSS](https://www.ionos.at/digitalguide/websites/webdesign/was-ist-css/)-Eigenschaft `white-space: pre-wrap` zuweisen oder Sie nutzen die Funktion `nl2br()`, um PHP zu signalisieren, dass Zeilenumbrüche automatisch in HTML-Zeilenumbrüche umgewandelt werden sollen. Die Funktion verwenden Sie nach folgendem Schema:

```php
<?php
$beispiel = file_get_contents('beispiel.txt');
echo nl2br($beispiel);
```

Wird das Sprachkonstrukt `echo` in Kombination mit `nl2br()` verwendet, fügt PHP vor jeder neuen Zeile einen HTML-Zeilenumbruch ein.

[![Bild: Die Funktion nl2br() in der Anwendung](https://www.ionos.at/digitalguide/fileadmin/_processed_/5/b/csm_php-tutorial-nl2br_cdf78eb41c.webp "Die Funktion nl2br() in der Anwendung")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-nl2br.jpg) Mit der PHP-Funktion nl2br() können Sie Zeilenumbrüche erzeugen. Möchten Sie die **Zeilen einer Datei einzeln ausgeben**, bietet sich die Funktion `file()` an. Diese liest eine Datei ein, nummeriert alle Zeilen beginnend mit 0 durch und speichert deren Inhalte als Elemente eines Arrays. Übertragen auf unser Beispiel ergibt sich somit folgende Zuordnung:

`[0] = Lorem ipsum dolor sit amet, consectetuer adipiscing elit`

`[1] = Aenean commodo ligula eget dolor. Aenean massa.`

`[2] = Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.`

`[3] = Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.`

Um die jeweiligen Inhalte mittels `echo` auszugeben, müssen Sie lediglich die gewünschte Zeilennummer angeben. So liefert uns das folgende Skript beispielsweise lediglich die erste Zeile der Datei „beispiel.txt“ als Ausgabe für den Browser:

```php
<?php
$beispiel = file("beispiel.txt");
echo $beispiel [0];
```

[![Bild: Die Funktion file() in der Anwendung](https://www.ionos.at/digitalguide/fileadmin/_processed_/f/c/csm_php-tutorial-file_cd3b282789.webp "Die Funktion file() in der Anwendung")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-file.jpg) Die Funktion file() eiget sich zum Auslesen einzelner Zeilen aus einer Datei. ### Dateien schreiben

Mit PHP lassen sich nicht nur Dateien auslesen. Die Skriptsprache gibt Ihnen auch die Möglichkeit, Dateien zu erstellen und diese mit Inhalten zu beschreiben.

Wir nutzen dazu die PHP-Funktion `file\_put_contents()`. Diese erwartet **zwei Parameter**: Den Namen der Datei, die erstellt oder aktualisiert werden soll, sowie die Daten in Form eines Strings oder Arrays. Folgendes Skript erstellt die Datei test.txt und schreibt den String *Das ist ein Test!* in die erste Zeile. Der Zusatz `\r\n` führt zu einem Zeilenumbruch in der Zieldatei.

```php
<?php
file_put_contents("test.txt", "Das ist ein Test! \r\n");
echo "test.txt wurde erstellt!";
```

Da uns `file_put_contents` keine Ausgabe für den Browser liefert, ergänzen wir eine `echo`-Anweisung, die uns ausgibt, welche Aktion durchgeführt wird.

[![Bild: Dateioperationen: Dateien schreiben](https://www.ionos.at/digitalguide/fileadmin/_processed_/5/3/csm_php-tutorial-file-put-contents_3a0f8272d2.webp "Dateioperationen: Dateien schreiben")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-file-put-contents.jpg) Mit der Funktion file\_put\_contents() können Sie Dateien schreiben. Findet sich im Zielordner bereits eine gleichnamige Datei, wird diese überschrieben. Dies verhindern Sie, indem Sie den Parameter `FILE_APPEND` setzen:

```php
<?php
file_put_contents("test.txt","Der Test war erfolgreich! \r\n", FILE_APPEND);
echo "test.txt wurde aktualisiert!";
```

Nutzen Sie `file_put_contents()` mit dem Parameter `FILE_APPEND`, werden neue Inhalte an bereits bestehende angehängt.

[![Bild: Dateioperationen: Dateien aktualisieren](https://www.ionos.at/digitalguide/fileadmin/_processed_/c/9/csm_php-tutorial-parameter-file-appends_b66027e50e.webp "Dateioperationen: Dateien aktualisieren")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-parameter-file-appends.jpg) Wenn Sie den Parameter FILE\_APPEND hinzufügen, dann werden die Inhalte, die Sie file\_put\_contents übergeben, an Ihre Datei angehangen. Was PHP in die Zieldatei schreibt, muss nicht zwangsläufig im Skript definiert werden. Alternativ haben Sie die Möglichkeit, **Inhalte von einer Datei in eine andere zu übertragen**. Folgendes Skript liest den Inhalt von *beispiel.txt* aus und fügt diesen in die Datei test.txt ein:

```php
<?php
$beispiel = file_get_contents("beispiel.txt");
file_put_contents("test.txt", $beispiel, FILE_APPEND);
echo "test.txt wurde aktualisiert!";
```

## Objektorientierte Programmierung

Die [objektorientierte Programmierung (OOP)](https://www.ionos.at/digitalguide/websites/web-entwicklung/objektorientierte-programmierung-oop/) ist eine Methode, um Programme in **kleine, überschaubare Bausteine, die sogenannten Objekte, zu unterteilen**. Jedes Objekt gehört zu einer Klasse, die beschreibt, welche Eigenschaften und Methoden es besitzt. Eigenschaften sind dabei Variablen, die Merkmale des Objekts speichern, während Methoden Funktionen sind, die das Objekt ausführen kann. OOP hilft, den Code besser zu strukturieren, wiederverwendbar zu machen und **leichter zu warten**, insbesondere bei größeren Projekten.

### Klassen

Eine Klasse ist die **Vorlage für ein Objekt**. Man kann sich eine Klasse wie einen Bauplan vorstellen, zum Beispiel für ein Auto, während ein Objekt das konkrete Auto ist, das nach diesem Bauplan erstellt wurde. Sie definiert, welche Daten ein Objekt enthält und welche Funktionen es ausführen kann. Im folgenden Beispiel sehen wir die Klasse `Auto`:

```php
class Auto {
public string $marke;
public string $modell;
public function fahren() {
echo "Das Auto fährt!";
}
}
$meinAuto = new Auto();
$meinAuto->marke = "VW";
$meinAuto->modell = "Golf";
$meinAuto->fahren();
```

In diesem Beispiel wird die Klasse `Auto` definiert, die zwei Eigenschaften, `$marke` und `$modell`, sowie eine Methode `fahren()` besitzt. Danach wird ein Objekt dieser Klasse erstellt, indem `$meinAuto` die Klasse „Auto“ zugewiesen wird. Mit `->` greifen wir auf die Eigenschaften des Objekts zu und setzen `$marke` auf `VW` und `$modell` auf `Golf`. Anschließend rufen wir die Methode `fahren()`auf, die den Text „Das Auto fährt!“ ausgibt. Das Schlüsselwort `$this` würde innerhalb der Methode auf das aktuelle Objekt verweisen.

[![Bild: Objekt der Auto-Klasse](https://www.ionos.at/digitalguide/fileadmin/_processed_/5/8/csm_php-tutorial-klassen_62b5ef1845.webp "Objekt der Auto-Klasse")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-klassen.jpg) Nachdem Sie ein Objekt der Auto-Klasse definiert haben, liefert ein Funktionsaufruf von fahren() eine entsprechende Ausgabe. ### Constructor Property Promotion

Seit PHP 8.0 kann man Eigenschaften **direkt im Konstruktor**, also der Methode, die beim Erstellen eines Objektes einer Klasse automatisch aufgerufen wird, **definieren und initialisieren**. Dadurch entfällt die Notwendigkeit, sie vorher in der Klasse separat zu deklarieren, was den Code kürzer und übersichtlicher macht.

```php
class Produkt {
public function __construct(
public string $name,
public float $preis
) {}
}
$produkt = new Produkt("Tasse", 12.99);
echo $produkt->name;
echo $produkt->preis;
```

In diesem Beispiel werden die Eigenschaften `name` und `preis` direkt im Konstruktor deklariert. Beim Erstellen des Objekts `Produkt` werden die Werte „Tasse“ und „12.99“ übergeben. Mit `$produkt->name` und `$produkt->preis` greifen wir auf die Werte zu, die automatisch gesetzt wurden. Constructor Property Promotion **spart also Schreibarbeit** und macht den Code einfacher zu lesen.

### Interfaces

Ein Interface legt fest, **welche Methoden eine Klasse haben muss**, ohne deren konkrete Umsetzung vorzugeben. Klassen, die das Interface implementieren, müssen diese Methoden definieren, sodass unterschiedliche Klassen einheitlich behandelt werden können.

```php
interface Fahrbar {
public function fahren();
}
class Auto implements Fahrbar {
public function fahren() {
echo "Das Auto fährt!";
}
}
$meinAuto = new Auto();
$meinAuto->fahren();
```

Hier definiert das Interface `Fahrbar`, dass jede implementierende Klasse eine Methode `fahren()` haben muss. Die Klasse `Auto` implementiert dieses Interface und definiert die Methode entsprechend. Anschließend wird ein Objekt der Klasse erstellt und die Methode aufgerufen, wodurch der Text „Das Auto fährt!“ ausgegeben wird.

[![Bild: Objekt der Auto-Klasse nach dem Interface Fahrbar](https://www.ionos.at/digitalguide/fileadmin/_processed_/7/a/csm_php-tutorial-interfaces_004bf56d70.webp "Objekt der Auto-Klasse nach dem Interface Fahrbar")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-interfaces.jpg) Ein Interface definiert, dass unsere Klasse eine Methode namens fahren() beinhalten muss. ### Intersection Types

Intersection Types ermöglichen es, dass ein Objekt **mehrere Interfaces gleichzeitig erfüllen können muss**. Das ist besonders praktisch, wenn eine Funktion sicherstellen soll, dass ein Objekt bestimmte Fähigkeiten besitzt.

```php
interface JsonSerializable {}
interface Loggable {}
function speichere(JsonSerializable&Loggable $objekt) {
echo "Objekt kann JSON speichern und protokollieren";
}
```

In diesem Beispiel müssen Objekte, die an die Funktion `speichere()` übergeben werden, sowohl das Interface `JsonSerializable` als auch `Loggable` implementieren. Die Kombination der beiden Interfaces wird durch das `&` dargestellt. Dadurch ist garantiert, dass die Funktion nur Objekte verwendet, die beide Eigenschaften besitzen.

### Readonly Properties

Readonly Properties können nur **einmal beim Erstellen eines Objekts gesetzt werden** und danach nicht mehr verändert werden. Das ist besonders nützlich, um sensible Daten vor unbeabsichtigten Änderungen zu schützen.

```php
class Benutzer {
public function __construct(
public readonly string $name
) {}
}
$benutzer = new Benutzer("Max");
echo $benutzer->name;
```

In diesem Beispiel wird die Eigenschaft `name` direkt im Konstruktor gesetzt und als `readonly` markiert. Das bedeutet, dass der Wert „Max“ nach der Erstellung des Objekts nicht mehr verändert werden kann. Versuche, den Wert später zu ändern, führen zu einem Fehler. Readonly Properties eignen sich gut für **Daten, die unveränderlich bleiben sollen**, wie Benutzer-IDs oder Konfigurationswerte.

### Property Hooks

Property Hooks erlauben es seit PHP-Version 8.4, Logik direkt beim Setzen oder Auslesen einer Eigenschaft auszuführen. Das ist praktisch, wenn Werte automatisch verarbeitet werden sollen.

```php
class User {
public string $email {
set => strtolower($value);
get => strtoupper($this->email);
}
}
$user = new User();
$user->email = "Test@Example.com";
echo $user->email;
```

In diesem Beispiel wird beim Zuweisen eines Werts an die Eigenschaft `email` automatisch alles in Kleinbuchstaben umgewandelt, während beim Auslesen automatisch alles in Großbuchstaben dargestellt wird. Dadurch kann man Daten konsistent verarbeiten, ohne zusätzliche Methoden schreiben zu müssen.

### Asymmetrische Sichtbarkeit

Mit asymmetrischer Sichtbarkeit, die ebenfalls erst mit PHP-Version 8.4 eingeführt wurde, kann man festlegen, dass eine **Eigenschaft öffentlich gelesen, aber nur intern innerhalb der Klasse geschrieben** werden darf. Das schützt wichtige Daten vor unkontrollierten Änderungen.

```php
class Konto {
public private(set) float $guthaben = 0.0;
public function einzahlen(float $betrag) {
$this->guthaben += $betrag;
}
}
$konto = new Konto();
$konto->einzahlen(50);
echo $konto->guthaben;
```

In diesem Beispiel kann das Guthaben des Kontos öffentlich ausgelesen werden, aber nur innerhalb der Klasse verändert werden. Die Methode `einzahlen()` erlaubt eine kontrollierte Erhöhung des Guthabens. Versuche, direkt auf `$guthaben` zu schreiben, führen zu einem Fehler. Auf diese Weise können wichtige Daten geschützt werden, während der Zugriff für erlaubte Operationen weiterhin möglich bleibt.

## Sauberen PHP-Code schreiben

Mit zunehmender Größe eines Projektes steigt auch die Bedeutung von gut strukturiertem und sauber geschriebenem Code. Sauberer PHP-Code ist leichter zu lesen, einfacher zu warten und weniger fehleranfällig. PHP-Anwendungen folgen deshalb **bestimmten Konventionen** und nutzen Werkzeuge, die Ordnung, Übersicht und Sicherheit fördern.

### Composer und PSR-4 (automatisches Laden von Klassen)

Composer ist ein zentrales Werkzeug in der PHP-Entwicklung. Es dient dazu, externe Bibliotheken zu verwalten und PHP-Klassen automatisch zu laden. Ohne Composer müssten Klassen mit `require` oder `include` manuell eingebunden werden, was bei größeren Projekten schnell unübersichtlich wird. Composer nutzt in der Regel den **Autoload-Standard PSR-4**. Dieser Standard legt fest, wie Klassen anhand ihres Namens und ihres Speicherorts gefunden werden. Der Name einer Klasse entspricht dabei der Ordnerstruktur, in der sie gespeichert ist.

Ein einfaches Beispiel verdeutlicht dieses Prinzip. Befindet sich eine Klasse `User` im Namespace `App\Model`, liegt die entsprechende Datei in einem Ordner „src/Model“:

```php
<?php
namespace App\Model;
class User {
public function getName() {
return "Max Mustermann";
}
}
```

Dank PSR-4 kann diese Klasse an jeder Stelle im Projekt verwendet werden, ohne die Datei manuell einzubinden. PHP lädt sie automatisch, sobald sie benötigt wird. Das macht den Code übersichtlicher und reduziert Fehlerquellen.

### Namespaces für klare Trennung von Code

Namespaces helfen dabei, Klassen logisch zu gruppieren und Namenskonflikte zu vermeiden. In kleinen Skripten ist es problemlos möglich, Klassen einfach `User` oder `Database` zu nennen. In größeren Anwendungen kann es jedoch vorkommen, dass mehrere Klassen denselben Namen tragen, aber unterschiedliche Aufgaben erfüllen. Durch Namespaces lassen sich diese Klassen eindeutig voneinander trennen. So kann es beispielsweise eine Klasse `User` für die Datenbank und eine weitere Klasse `User` für die Darstellung im Frontend geben, ohne dass es zu Konflikten kommt.

Folgendes Beispiel zeigt die Verwendung eines Namespaces:

```php
<?php
namespace App\Service;
class Mailer {
public function send() {
echo "E-Mail wurde versendet.";
}
}
```

Beim Einsatz der Klasse wird der vollständige Name inklusive Namespace verwendet oder per `use` eingebunden. Dadurch bleibt der Code eindeutig und gut strukturiert.

### Projektstruktur: .env-Dateien und .gitignore

Eine klare Projektstruktur ist ein wichtiger Bestandteil sauberen PHP-Codes. PHP-Projekte trennen den eigentlichen Programmcode von öffentlich erreichbaren Dateien und Konfigurationsdaten. Häufig liegt der PHP-Code in einem eigenen Ordner, während der Webserver nur auf ein öffentliches Verzeichnis zugreifen darf.

Konfigurationswerte wie Datenbank-Zugangsdaten oder [API](https://www.ionos.at/digitalguide/websites/web-entwicklung/was-ist-eine-api/)-Schlüssel werden meist nicht direkt im Code gespeichert. Stattdessen nutzt man sogenannte .env-Dateien, in denen solche Werte zentral abgelegt werden. Das **erhöht die Sicherheit** und erleichtert den Wechsel zwischen Entwicklungs- und Produktivumgebung.

Ein einfaches Beispiel für eine .env-Datei könnte so aussehen:

```txt
DB_HOST=localhost
DB_USER=root
DB_PASSWORD=secret
```

Diese Datei wird bewusst **nicht in der Versionsverwaltung gespeichert**. Dafür sorgt die .gitignore-Datei, die festlegt, welche Dateien oder Ordner von [Git](https://www.ionos.at/digitalguide/websites/web-entwicklung/git-tutorial/) ignoriert werden sollen. In der .gitignore wird die .env-Datei explizit ausgeschlossen, damit sensible Daten nicht versehentlich veröffentlicht werden.

### Fehlerbehandlung und Logging

Der Umgang mit Fehlern unterscheidet sich zwischen Entwicklungs- und Produktivumgebung. Während der Entwicklung ist es sinnvoll, PHP-Fehlermeldungen direkt anzuzeigen. Dadurch lassen sich Probleme schnell erkennen und beheben.

In produktiven Anwendungen sollten Fehlermeldungen hingegen **nicht sichtbar sein**, da sie interne Informationen preisgeben könnten. Stattdessen werden Fehler in Logdateien geschrieben, die nur für Entwicklerinnen und Entwickler zugänglich sind.

In einer Entwicklungsumgebung kann die Fehlerausgabe beispielsweise so aktiviert werden:

```php
<?php
ini_set('display_errors', 1);
error_reporting(E_ALL);
```

In einer produktiven Umgebung wird die Anzeige von Fehlern deaktiviert und das Logging aktiviert. PHP schreibt auftretende Fehler dann in eine Logdatei, ohne diese den Besucherinnen und Besuchern der Webseite anzuzeigen. So bleibt die Anwendung stabil und sicher, während Fehler dennoch nachvollziehbar dokumentiert werden.

## Datenbank-Basics mit PHP: Ein einfaches PDO-Beispiel

Um Daten mit PHP zu speichern oder auszulesen, benötigt man eine Datenbank. In diesem Beispiel verwenden wir [MySQL](https://www.ionos.at/digitalguide/server/knowhow/was-ist-mysql/), das standardmäßig in XAMPP enthalten ist. PHP kann über **PDO, also PHP Data Objects, sicher mit der Datenbank kommunizieren**. PDO stellt sicher, dass Befehle korrekt ausgeführt werden und dass Benutzereingaben keine Sicherheitslücken verursachen.

### Datenbank und Tabelle erstellen

Zuerst erstellen wir in phpMyAdmin eine neue Datenbank mit dem Namen `testdb`. Innerhalb dieser Datenbank legen wir eine Tabelle namens `users` an. Diese Tabelle enthält drei Spalten: `id` für die eindeutige Identifikation jedes Benutzers, `username` für den Benutzernamen und `email` für die E-Mail-Adresse. In SQL sieht das so aus:

```sql
CREATE TABLE users (
id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(50) NOT NULL,
email VARCHAR(100) NOT NULL
);
```

### Datenbankoperationen in PHP

Jetzt erstellen wir eine Datei „crud.php“ im XAMPP-Ordner „htdocs“. Wir stellen in diesem Beispiel eine Verbindung zur Datenbank her zeigen zunächst die grundlegenden Operationen `CREATE`, `READ`, `UPDATE` und `DELETE` ([CRUD](https://www.ionos.at/digitalguide/websites/web-entwicklung/crud-die-wichtigsten-datenbankoperationen/)):

```php
<?php
// Verbindung zur Datenbank herstellen
$host = '127.0.0.1';
$db = 'testdb';
$user = 'root';
$pass = '';
$charset = 'utf8mb4';
$dsn = "mysql:host=$host;dbname=$db;charset=$charset";
$options = [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, // Fehler sichtbar machen
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, // Daten als Array
];
try {
$pdo = new PDO($dsn, $user, $pass, $options);
} catch (PDOException $e) {
echo "Verbindung fehlgeschlagen: " . $e->getMessage();
exit;
}
// CREATE: neuen User einfügen
$stmt = $pdo->prepare("INSERT INTO users (username, email) VALUES (:username, :email)");
$stmt->execute([
'username' => 'Max Mustermann',
'email' => 'max@example.com'
]);
// READ: alle User auslesen
$stmt = $pdo->query("SELECT * FROM users");
$users = $stmt->fetchAll();
// Ausgabe der Benutzerliste
echo "<h2>Benutzerliste</h2>";
foreach ($users as $user) {
echo "ID: " . $user['id'] . " – Name: " . htmlspecialchars($user['username']) . " – E-Mail: " . htmlspecialchars($user['email']) . "<br>";
}
// UPDATE: E-Mail eines Users ändern
$stmt = $pdo->prepare("UPDATE users SET email = :email WHERE username = :username");
$stmt->execute([
'email' => 'max.mustermann@example.com',
'username' => 'Max Mustermann'
]);
echo "<p>Die E-Mail-Adresse von Max Mustermann wurde aktualisiert.</p>";
// DELETE: User löschen
$stmt = $pdo->prepare("DELETE FROM users WHERE username = :username");
$stmt->execute([
    'username' => 'Max Mustermann'
]);
?>
```

Zuerst wird mit PDO eine Verbindung zur Datenbank aufgebaut. Wir geben dazu Host, Datenbankname, Benutzername, Passwort und Zeichensatz an. PDO sorgt dafür, dass SQL-Befehle sicher ausgeführt werden und Fehler sichtbar werden.

Anschließend zeigen wir die vier grundlegenden Operationen:

- `CREATE` (Einfügen von Daten): Mit `INSERT INTO` fügen wir einen neuen User ein. Die Platzhalter `:username` und `:email` sorgen dafür, dass Benutzereingaben sicher verarbeitet werden.
- `READ` (Daten auslesen): Mit `SELECT * FROM users` holen wir alle vorhandenen Datensätze. Mit `fetchAll()` speichern wir die Ergebnisse in einem Array und geben sie in einer übersichtlichen Liste aus.
- `UPDATE` (Daten ändern): Mit `UPDATE` können wir die E-Mail-Adresse eines Users ändern. Wir verwenden wieder Platzhalter, um die Werte sicher einzusetzen.
- `DELETE` (Daten löschen): Mit `DELETE FROM users WHERE username = :username` entfernen wir einen bestimmten User aus der Datenbank. Der Platzhalter `:username` sorgt dafür, dass die Eingabe sicher verarbeitet wird, ohne dass ein Angreifer die Datenbank manipulieren kann. So können wir gezielt einzelne Datensätze löschen, ohne die ganze Tabelle zu beeinflussen.

## Sichere Benutzereingaben und Datenverarbeitung

Sobald PHP mit Benutzereingaben arbeitet, entsteht ein **Sicherheitsrisiko**. Besucherinnen und Besucher können Formularfelder manipulieren, unerwartete Daten senden oder gezielt versuchen, eine Anwendung zu missbrauchen. Deshalb stellt PHP verschiedene Funktionen bereit, mit denen Eingaben geprüft, verarbeitet und sicher gespeichert werden können.

### Daten sicher in Datenbanken speichern: Prepared Statements

Eine der häufigsten Sicherheitslücken in PHP-Anwendungen entsteht bei der Arbeit mit Datenbanken. Werden Benutzereingaben direkt in [SQL](https://www.ionos.at/digitalguide/server/knowhow/was-ist-sql/)-Abfragen eingebaut, kann eine sogenannte [SQL-Injection](https://www.ionos.at/digitalguide/server/sicherheit/sql-injection-grundlagen-und-schutzmassnahmen/) auftreten. Dabei schleusen Angreiferinnen und Angreifer **eigenen SQL-Code** ein.

Prepared Statements verhindern dieses Problem, indem SQL-Code und Benutzerdaten strikt voneinander getrennt werden. PHP stellt dafür die Datenbankschnittstelle PDO zur Verfügung.

```php
<?php
$stmt = $pdo->prepare("SELECT * FROM users WHERE username = :username");
$stmt->execute([
'username' => $username
]);
```

Der Code bereitet eine Datenbankabfrage vor, mit der alle Nutzenden aus der Tabelle `users` gesucht werden, deren Benutzername einem bestimmten Wert entspricht. Statt den Benutzernamen direkt in den SQL-Befehl zu schreiben, wird der Platzhalter `:username` verwendet, der erst beim Ausführen der Abfrage mit einem konkreten Wert gefüllt wird. Dadurch trennt PHP den SQL-Code von den Benutzerdaten und verhindert, dass Eingaben den Befehl manipulieren können.

### Ausgaben absichern: Output-Escaping

Nicht nur das Speichern von Daten, sondern auch **deren Ausgabe kann gefährlich sein**. Gibt man Benutzereingaben ungefiltert im Browser aus, kann sogenanntes [Cross-Site-Scripting (XSS)](https://www.ionos.at/digitalguide/websites/web-entwicklung/was-ist-xss-bzw-cross-site-scripting/) auftreten. Dabei wird schädlicher Code im Browser anderer Nutzerinnen und Nutzer ausgeführt. Um das zu verhindern, werden Ausgaben maskiert. In PHP geschieht dies meist mit der Funktion `htmlspecialchars()` und der Text wird angezeigt, aber nicht als Code interpretiert.

```php
<?php
echo htmlspecialchars("<h1>Hello World!</h1>", ENT_QUOTES, 'UTF-8');
```

[![Bild: PHP-Funktion htmlspecialchars()](https://www.ionos.at/digitalguide/fileadmin/_processed_/2/5/csm_php-tutorial-htmlspecialchars_648f755bfc.webp "PHP-Funktion htmlspecialchars()")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/php-tutorial-htmlspecialchars.jpg) Wenn Sie htmlspecialchars() nutzen, wird HTML-Code als einfacher String interpretiert. ### Benutzereingaben filtern: `filter_input()`

PHP bietet mit `filter_input()` eine Möglichkeit, **Benutzereingaben bereits beim Einlesen zu prüfen** und zu bereinigen. So lassen sich ungültige oder unerwünschte Werte frühzeitig erkennen.Ein einfaches Beispiel ist das Einlesen einer E-Mail-Adresse:

```php
<?php
$email = filter_input(INPUT_POST, 'email', FILTER_VALIDATE_EMAIL);
```

Ist die Eingabe keine gültige E-Mail-Adresse, liefert die Funktion `false` zurück. Auf diese Weise kann der Code gezielt reagieren, bevor mit den Daten weitergearbeitet wird.

### Passwörter sicher speichern mit `password_hash()`

Passwörter dürfen **niemals im Klartext gespeichert** werden. Selbst eine einfache Verschlüsselung ist nicht ausreichend. PHP stellt dafür die Funktion `password_hash()` bereit, die Passwörter sicher hasht.

```php
<?php
$hash = password_hash($password, PASSWORD_DEFAULT);
```

Beim späteren Login wird das eingegebene Passwort mit `password_verify()` überprüft:

```php
<?php
if (password_verify($password, $hash)) {
echo "Login erfolgreich";
}
```

Der eigentliche Passwortwert ist dabei nie wieder sichtbar. Selbst bei einem Datenbankleck bleiben die Passwörter geschützt.

### Schutz vor Formularmanipulation: CSRF-Tokens

Bei Formularen besteht die Gefahr, dass sie ohne Wissen der Nutzerinnen und Nutzer abgeschickt werden. Um dies zu verhindern, werden sogenannte CSRF-Tokens eingesetzt. Dabei handelt es sich um zufällige Zeichenfolgen, die bei jedem Formularaufruf neu erzeugt werden.

```php
<?php
$_SESSION['token'] = bin2hex(random_bytes(32));
```

Diese Zeile erzeugt einen zufälligen, schwer erratbaren Sicherheitscode und speichert ihn in der aktuellen Sitzung des Users. Die Funktion `random_bytes(32)` erstellt 32 zufällige Bytes, also Rohdaten, die nicht direkt lesbar sind. Mit `bin2hex()` werden diese Rohdaten in eine gut lesbare Zeichenfolge aus Buchstaben und Zahlen umgewandelt. Der erzeugte Wert wird in `$_SESSION['token']` gespeichert und später verwendet, um zu prüfen, ob ein Formular **wirklich von derselben Sitzung stammt**.

### Datei-Uploads mit Validierung

Auch Datei-Uploads sind besonders sensible und können Sicherheitsrisiken einbringen, da hier fremde Dateien auf den Server gelangen. Deshalb sollten Dateityp und Dateigröße immer geprüft werden.

Ein einfaches Beispiel für eine Dateigrößenprüfung könnte so aussehen:

```php
<?php
if ($_FILES['upload']['size'] > 1000000) {
echo "Datei ist zu groß.";
}
```

Der Code prüft, **wie groß die hochgeladene Datei ist**, und vergleicht sie mit einem festgelegten Maximalwert von 1.000.000 Bytes. Ist die Datei größer als erlaubt, wird eine Fehlermeldung ausgegeben und der Upload kann abgelehnt werden. So wird verhindert, dass zu große Dateien auf den Server geladen werden. Zusätzlich sollte geprüft werden, ob es sich wirklich um den erwarteten Dateityp handelt, etwa ein Bild. Dateien sollten niemals ungeprüft ausführbar auf dem Server abgelegt werden.


This is a markdown version of: [https://www.ionos.at/digitalguide/websites/webseiten-erstellen/php-lernen-leicht-gemacht-das-grosse-einsteiger-tutorial/](https://www.ionos.at/digitalguide/websites/webseiten-erstellen/php-lernen-leicht-gemacht-das-grosse-einsteiger-tutorial/) for AI/LLM consumption.