DevPanicZone Logo DevPanicZone! Cheatsheets.

PHP Basics - Die Grundlagen

Von "Was ist PHP?" bis zu deinem ersten funktionierenden Code. Easy, verständlich und sicher.

Was ist PHP überhaupt?

PHP steht für "Hypertext Preprocessor" (ja, die Abkürzung macht rekursiv Sinn... oder auch nicht 😄). Es ist eine serverseitige Programmiersprache, die speziell für die Webentwicklung entwickelt wurde.

Was heißt "serverseitig"?

Das bedeutet, dass PHP-Code auf dem Server ausgeführt wird, bevor die Seite an den Browser geschickt wird. Der Browser sieht nur das fertige HTML-Ergebnis - nicht deinen PHP-Code. Das ist ein großer Unterschied zu JavaScript, das im Browser läuft.

Was kannst du mit PHP machen?

  • Dynamische Webseiten erstellen (Inhalte ändern sich je nach Nutzer, Zeit, Daten...)
  • Formulare verarbeiten (Kontaktformulare, Login-Systeme, etc.)
  • Mit Datenbanken arbeiten (Daten speichern und abrufen)
  • Dateien hochladen und verwalten
  • Sessions und Cookies verwalten (Nutzer eingeloggt halten)
  • APIs erstellen und nutzen
Wichtig für Anfänger

PHP kann sehr mächtig sein - aber auch gefährlich, wenn du Sicherheitsaspekte ignorierst. Wir werden in diesem Tutorial die sichere Variante lernen, auch wenn das manchmal etwas mehr Code bedeutet. In einem separaten Tutorial gehen wir dann tiefer auf PHP Security ein.

PHP zum Laufen bringen

Um PHP zu nutzen, brauchst du einen lokalen Server. PHP-Dateien kannst du nicht einfach wie HTML-Dateien im Browser öffnen - der Server muss den PHP-Code erst verarbeiten.

Optionen für lokale Entwicklung

Option 1: XAMPP (empfohlen für Anfänger)

  • Download: apachefriends.org
  • Beinhaltet Apache (Webserver), PHP und MySQL (Datenbank)
  • Einfach zu installieren und zu nutzen
  • Läuft auf Windows, Mac und Linux

Option 2: MAMP (für Mac)

  • Download: mamp.info
  • Ähnlich wie XAMPP, speziell für Mac optimiert

Option 3: PHP Built-in Server (für Quick Tests)

Wenn du PHP bereits installiert hast, kannst du einen einfachen Server starten:

PHP 
# Im Terminal/Kommandozeile:
cd /pfad/zu/deinem/projekt
php -S localhost:8000

Dann kannst du über http://localhost:8000 auf deine Dateien zugreifen.

Wo speichere ich meine PHP-Dateien?
  • Bei XAMPP: im Ordner htdocs (z.B. C:\xampp\htdocs\mein-projekt)
  • Bei MAMP: im Ordner htdocs innerhalb des MAMP-Verzeichnisses
  • Dann erreichst du deine Datei über: http://localhost/mein-projekt/datei.php

Dein erstes PHP-Programm

Lass uns mit dem klassischen "Hello World" starten!

PHP-Tags: Der Anfang und das Ende

PHP-Code wird in speziellen Tags geschrieben:

PHP 
<?php
// Dein PHP-Code hier
?>
Die PHP-Tags im Detail
  • <?php - Öffnet PHP-Code
  • ?> - Schließt PHP-Code (am Dateiende oft weggelassen)
  • Alles außerhalb dieser Tags wird als HTML behandelt
  • Mit // kannst du einen Kommentar einfügen

Hello World Beispiel

Erstelle eine Datei hello.php:

PHP 
<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <title>Mein erstes PHP-Programm</title>
</head>
<body>
    <h1>
        <?php
        echo "Hello World!";
        ?>
    </h1>
    
    <p>Das aktuelle Datum ist: 
        <?php
        echo date("d.m.Y");
        ?>
    </p>
</body>
</html>
Was passiert hier?
  • echo gibt Text oder Variablen aus
  • Jede PHP-Anweisung endet mit einem Semikolon ;
  • date("d.m.Y") gibt das aktuelle Datum formatiert aus
  • Du kannst PHP-Code überall in dein HTML einbetten
Sicherheitshinweis

Wenn du Nutzereingaben ausgibst (z.B. aus Formularen), nutze NIEMALS einfach echo! Verwende stattdessen htmlspecialchars() - mehr dazu gleich.

Kommentare in PHP

Kommentare sind super wichtig, um deinen Code zu dokumentieren:

PHP 
<?php
// Das ist ein einzeiliger Kommentar

# Das ist auch ein einzeiliger Kommentar (seltener verwendet)

/*
    Das ist ein mehrzeiliger Kommentar
    Er kann über mehrere Zeilen gehen
    Praktisch für längere Erklärungen
*/

echo "Dieser Code wird ausgeführt"; // Kommentar am Ende der Zeile
?>

Variablen in PHP

Variablen in PHP beginnen immer mit einem Dollarzeichen $.

Variablen erstellen

PHP 
<?php
// Variablen deklarieren und zuweisen
$name = "Leo";
$alter = 16;
$preis = 19.99;
$istAktiv = true;

// Variablen ausgeben
echo $name; // Gibt "Leo" aus
echo "Hallo, " . $name . "!"; // Gibt "Hallo, Leo!" aus
?>
Wichtige Regeln für Variablennamen
  • Variablennamen beginnen immer mit $
  • Danach muss ein Buchstabe oder Unterstrich kommen (keine Zahl!)
  • Dürfen Buchstaben, Zahlen und Unterstriche enthalten
  • Sind case-sensitive: $name ≠ $Name
  • Keine Leerzeichen erlaubt

Strings zusammenfügen (Concatenation)

In PHP verwendest du den Punkt . zum Verketten von Strings:

PHP 
<?php
$vorname = "Leo";
$nachname = "Müller";

// Mit Punkt verketten
$vollname = $vorname . " " . $nachname;
echo $vollname; // Gibt "Leo Müller" aus

// Alternative: Variablen in doppelten Anführungszeichen
echo "Hallo, $vorname $nachname!"; // Gibt "Hallo, Leo Müller!" aus

// Bei einfachen Anführungszeichen funktioniert das NICHT
echo 'Hallo, $vorname!'; // Gibt wörtlich "Hallo, $vorname!" aus
?>

Datentypen

PHP ist dynamisch typisiert - das bedeutet, du musst den Typ nicht angeben. PHP erkennt ihn automatisch.

PHP 
<?php
// String (Text)
$text = "Das ist ein String";

// Integer (Ganzzahl)
$zahl = 42;

// Float / Double (Dezimalzahl)
$preis = 19.99;

// Boolean (Wahr/Falsch)
$istWahr = true;
$istFalsch = false;

// Array (Liste von Werten)
$farben = ["rot", "grün", "blau"];

// NULL (kein Wert)
$nichts = null;

// Den Typ einer Variable prüfen
var_dump($zahl); // Zeigt: int(42)
?>

Type Juggling (Automatische Typumwandlung)

PHP wandelt Typen automatisch um, wenn nötig:

PHP 
<?php
$zahl = "5";      // String
$ergebnis = $zahl + 3; // PHP wandelt "5" automatisch in 5 um
echo $ergebnis;   // Gibt 8 aus (als Integer)

// Das kann manchmal zu unerwartetem Verhalten führen!
$text = "10 Äpfel";
echo $text + 5;   // Gibt 15 aus (PHP nimmt die 10 am Anfang)
?>
Vorsicht mit automatischer Typumwandlung!

Die automatische Typumwandlung kann praktisch sein, aber auch zu Bugs führen. Achte darauf, welche Typen deine Variablen haben, besonders bei Vergleichen!

Arrays - Listen von Werten

Arrays sind super praktisch, um mehrere Werte in einer Variable zu speichern.

Einfaches Array (numerisch indiziert)

PHP 
<?php
// Array erstellen
$farben = ["rot", "grün", "blau"];
// Index:    0       1       2
// Wert:  "rot"  "grün"  "blau"

// Alternative (ältere Syntax)
$farben = array("rot", "grün", "blau");

// Auf Elemente zugreifen (Index beginnt bei 0)
echo $farben[0]; // Gibt "rot" aus
echo $farben[1]; // Gibt "grün" aus

// Element hinzufügen
$farben[] = "gelb";

// Anzahl der Elemente
echo count($farben); // Gibt 4 aus
?>
Wichtig: Der Index beginnt bei 0!

In der Programmierung beginnt man beim Zählen fast immer bei 0 statt bei 1

Assoziatives Array (mit benannten Keys)

Statt Zahlen kannst du auch eigene Schlüssel (Keys) verwenden:

PHP 
<?php
// Assoziatives Array
$person = [
    "name" => "Leo",
    "alter" => 18,
    "stadt" => "Berlin"
];

// Zugriff über Keys
echo $person["name"];  // Gibt "Leo" aus
echo $person["alter"]; // Gibt 18 aus

// Neues Key-Value-Paar hinzufügen
$person["beruf"] = "Webentwickler";
?>

Mehrdimensionale Arrays

Arrays können auch andere Arrays enthalten:

PHP 
<?php
$personen = [
    [
        "name" => "Leo",
        "alter" => 18
    ],
    [
        "name" => "Andrea",
        "alter" => 16
    ]
];

// Zugriff auf verschachtelte Werte
echo $personen[0]["name"]; // Gibt "Leo" aus
echo $personen[1]["alter"]; // Gibt 16 aus
?>

Array durchlaufen

PHP 
<?php
$farben = ["rot", "grün", "blau"];

// Mit foreach durchlaufen
foreach ($farben as $farbe) {
    echo $farbe . "<br>";
}

// Bei assoziativen Arrays: Key und Value
$person = ["name" => "Leo", "alter" => 18];

foreach ($person as $key => $value) {
    echo "$key: $value<br>";
}
// Ausgabe:
// name: Leo
// alter: 18
?>

Operatoren

Arithmetische Operatoren

PHP 
<?php
$a = 10;
$b = 3;

echo $a + $b;  // Addition: 13
echo $a - $b;  // Subtraktion: 7
echo $a * $b;  // Multiplikation: 30
echo $a / $b;  // Division: 3.333...
echo $a % $b;  // Modulo (Rest): 1
echo $a ** $b; // Potenz: 1000 (10³)
?>

Vergleichsoperatoren

PHP 
<?php
$a = 5;
$b = "5";

// Gleich (Wert)
var_dump($a == $b);  // true (5 ist gleich "5" als Wert)

// Identisch (Wert UND Typ)
var_dump($a === $b); // false (5 ist nicht identisch mit "5")

// Ungleich
var_dump($a != $b);  // false
var_dump($a !== $b); // true (verschiedene Typen)

// Größer/Kleiner
var_dump($a > 3);    // true
var_dump($a < 10);   // true
var_dump($a >= 5);   // true
var_dump($a <= 4);   // false
?>
Wichtig: == vs. ===
  • == vergleicht nur den Wert (mit Typumwandlung)
  • === vergleicht Wert UND Typ (strenger, sicherer)
  • Best Practice: Nutze immer === und !==

Logische Operatoren

PHP 
<?php
$a = true;
$b = false;

// UND (AND)
var_dump($a && $b);  // false (beide müssen true sein)

// ODER (OR)
var_dump($a || $b);  // true (einer muss true sein)

// NICHT (NOT)
var_dump(!$a);       // false (kehrt um)
?>

String-Operatoren

PHP 
<?php
$vorname = "Leo";
$nachname = "Müller";

// Verkettung mit Punkt
$name = $vorname . " " . $nachname;

// Verkettung mit Zuweisung
$text = "Hallo";
$text .= " Welt"; // Entspricht: $text = $text . " Welt"
echo $text; // Gibt "Hallo Welt" aus
?>

Bedingungen: if, else, elseif

Mit Bedingungen kannst du deinen Code unterschiedlich ausführen, je nachdem, ob etwas wahr oder falsch ist.

Einfaches if

PHP 
<?php
$alter = 18;

if ($alter >= 18) {
    echo "Du bist volljährig!";
}
?>

if-else

PHP 
<?php
$alter = 16;

if ($alter >= 18) {
    echo "Du bist volljährig!";
} else {
    echo "Du bist noch minderjährig.";
}
?>

if-elseif-else

PHP 
<?php
$note = 85;

if ($note >= 90) {
    echo "Sehr gut!";
} elseif ($note >= 80) {
    echo "Gut!";
} elseif ($note >= 70) {
    echo "Befriedigend.";
} else {
    echo "Nicht bestanden.";
}
?>

Switch-Case (für viele Bedingungen)

PHP 
<?php
$tag = "Montag";

switch ($tag) {
    case "Montag":
        echo "Wochenstart!";
        break;
    case "Freitag":
        echo "Fast Wochenende!";
        break;
    case "Samstag":
    case "Sonntag":
        echo "Wochenende!";
        break;
    default:
        echo "Ein normaler Wochentag.";
}
?>
Das break-Keyword

Das break in jedem case ist wichtig! Ohne break werden auch die folgenden Cases ausgeführt (sogenannter "Fall-Through"). Das kann manchmal nützlich sein, ist aber meistens ein Bug.

Schleifen: Code wiederholen

Schleifen wiederholen Code automatisch - super praktisch!

while-Schleife

Führt Code aus, solange eine Bedingung wahr ist:

PHP 
<?php
$zahl = 1;

while ($zahl <= 5) {
    echo "Durchlauf: $zahl<br>";
    $zahl++; // Erhöht $zahl um 1
}
// Ausgabe: Durchlauf 1, 2, 3, 4, 5
?>

do-while-Schleife

Wie while, aber der Code wird mindestens einmal ausgeführt:

PHP 
<?php
$zahl = 1;

do {
    echo "Durchlauf: $zahl<br>";
    $zahl++;
} while ($zahl <= 5);
?>

for-Schleife

Wenn du genau weißt, wie oft du etwas wiederholen willst:

PHP 
<?php
// for (Start; Bedingung; Inkrement)
for ($i = 1; $i <= 5; $i++) {
    echo "Durchlauf: $i<br>";
}
?>

foreach-Schleife (für Arrays)

Die beste Wahl für Arrays:

PHP 
<?php
$farben = ["rot", "grün", "blau"];

foreach ($farben as $farbe) {
    echo "Farbe: $farbe<br>";
}

// Mit Index und Wert
foreach ($farben as $index => $farbe) {
    echo "Index $index: $farbe<br>";
}
?>

break und continue

PHP 
<?php
// break: Schleife komplett beenden
for ($i = 1; $i <= 10; $i++) {
    if ($i === 5) {
        break; // Stoppt bei 5
    }
    echo "$i ";
}
// Ausgabe: 1 2 3 4

echo "<br>";

// continue: Nur aktuellen Durchlauf überspringen
for ($i = 1; $i <= 5; $i++) {
    if ($i === 3) {
        continue; // Überspringt 3
    }
    echo "$i ";
}
// Ausgabe: 1 2 4 5
?>

Funktionen: Code wiederverwenden

Funktionen sind Codeblöcke, die du mit einem Namen versehen und dann immer wieder aufrufen kannst.

Einfache Funktion

PHP 
<?php
// Funktion definieren
function gruss() {
    echo "Hallo Welt!";
}

// Funktion aufrufen
gruss(); // Gibt "Hallo Welt!" aus
?>

Funktion mit Parametern

PHP 
<?php
function grussPersonal($name) {
    echo "Hallo, $name!";
}

grussPersonal("Leo"); // Gibt "Hallo, Leo!" aus
grussPersonal("Andrea");    // Gibt "Hallo, Andrea!" aus
?>

Funktion mit Rückgabewert

PHP 
<?php
function addiere($a, $b) {
    return $a + $b;
}

$ergebnis = addiere(5, 3);
echo $ergebnis; // Gibt 8 aus

// Direkt in echo verwenden
echo addiere(10, 20); // Gibt 30 aus
?>

Standardwerte für Parameter

PHP 
<?php
function gruss($name = "Gast") {
    echo "Hallo, $name!";
}

gruss();          // Gibt "Hallo, Gast!" aus (nutzt Standardwert)
gruss("Leo");  // Gibt "Hallo, Leo!" aus
?>

Type Declarations (empfohlen!)

Ab PHP 7 kannst du Typen für Parameter und Rückgabewerte angeben:

PHP 
<?php
// Parameter-Typ und Rückgabe-Typ angeben
function addiere(int $a, int $b): int {
    return $a + $b;
}

echo addiere(5, 3); // 8

// Fehler: addiere("5", "3") würde einen TypeError werfen
// (außer strict_types ist nicht aktiviert)
?>
Strict Types aktivieren

Füge am Anfang deiner PHP-Datei hinzu:

PHP 
<?php
declare(strict_types=1);

// Ab hier werden Typen streng geprüft

Wichtige Sicherheitsgrundlagen

Auch wenn wir ein separates Security-Tutorial haben werden, sind ein paar Basics schon jetzt wichtig:

Nutzereingaben IMMER bereinigen

Wenn du Daten ausgibst, die von Nutzern kommen (z.B. aus Formularen), nutze htmlspecialchars():

Strict Types aktivieren

Füge am Anfang deiner PHP-Datei hinzu:

PHP 
<?php
// FALSCH - gefährlich!
$name = $_POST['name'] ?? '';
echo $name; // ❌ Niemals so!

// RICHTIG - sicher
$name = $_POST['name'] ?? '';
echo htmlspecialchars($name, ENT_QUOTES, 'UTF-8'); // ✅ Immer so!
?>
Warum ist das wichtig?

Ohne htmlspecialchars() könnte ein Nutzer JavaScript-Code eingeben, der dann auf deiner Seite ausgeführt wird (XSS-Angriff). Mit htmlspecialchars() werden gefährliche Zeichen wie < in harmlose Zeichen wie &lt; umgewandelt.

Formulardaten sicher empfangen

PHP 
<?php
// Prüfe, ob Daten per POST gesendet wurden
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    
    // Hol Daten mit Fallback (wenn nicht vorhanden)
    $name = $_POST['name'] ?? '';
    $email = $_POST['email'] ?? '';
    
    // Daten validieren
    if (empty($name)) {
        echo "Name ist erforderlich!";
    } elseif (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        echo "Ungültige E-Mail-Adresse!";
    } else {
        // Sicher ausgeben
        echo "Hallo, " . htmlspecialchars($name, ENT_QUOTES, 'UTF-8') . "!";
    }
}
?>

Passwörter niemals im Klartext speichern

PHP 
<?php
// Passwort hashen (verschlüsseln)
$passwort = "GeheimesPasswort123";
$hash = password_hash($passwort, PASSWORD_DEFAULT);

// $hash in Datenbank speichern, NICHT das Klartext-Passwort!

// Später beim Login: Passwort überprüfen
$eingabe = "GeheimesPasswort123";
if (password_verify($eingabe, $hash)) {
    echo "Login erfolgreich!";
} else {
    echo "Falsches Passwort!";
}
?>
Mehr zu Security

Das sind nur die absoluten Basics! In einem separaten Tutorial werden wir tiefer in PHP Security eintauchen: SQL Injection, CSRF-Schutz, Session-Sicherheit und mehr.

Zum Tutorial PHP Security ↵

Dateien einbinden: include und require

Du kannst PHP-Code aus anderen Dateien einbinden - praktisch für Header, Footer, Funktionen etc.

Die vier Varianten

PHP 
<?php
// include: Bindet Datei ein, Warnung bei Fehler
include 'header.php';

// require: Bindet Datei ein, Fatal Error bei Fehler (stoppt Script)
require 'config.php';

// include_once: Bindet Datei nur einmal ein (verhindert Mehrfach-Einbindung)
include_once 'functions.php';

// require_once: Wie require, aber nur einmal (Best Practice!)
require_once 'database.php';
?>
Wann was nutzen?
  • require_once: Für wichtige Dateien (Funktionen, Klassen, Config)
  • include: Für optionale Inhalte (z.B. Template-Parts)
  • _once-Varianten verhindern, dass Code doppelt geladen wird

Praktisches Beispiel

Datei: header.php

PHP 
<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <title>Meine Website</title>
</head>
<body>
    <header>
        <h1>Willkommen!</h1>
    </header>

Datei: footer.php

PHP 
    <footer>
        <p>© 2025 Meine Website</p>
    </footer>
</body>
</html>

Datei: index.php

PHP 
<?php require_once 'header.php'; ?>

<main>
    <h1>Inhalt der Startseite</h1>
    <p>Hier ist der Hauptinhalt.</p>
</main>

<?php require_once 'footer.php'; ?>

Superglobals: Vordefinierte Variablen

PHP stellt automatisch einige Arrays bereit, die wichtige Informationen enthalten:

Die wichtigsten Superglobals

$_GET - URL-Parameter

Daten, die über die URL übergeben werden:

PHP 
<?php
// URL: index.php?name=Leo&alter=18

$name = $_GET['name'] ?? 'Unbekannt';
$alter = $_GET['alter'] ?? 0;

echo "Name: " . htmlspecialchars($name); // Immer bereinigen!
echo "Alter: " . htmlspecialchars($alter);
?>

$_POST - Formulardaten

Daten aus Formularen:

PHP 
<?php
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $name = $_POST['name'] ?? '';
    $email = $_POST['email'] ?? '';
    
    // Sicher ausgeben
    echo htmlspecialchars($name);
}
?>

$_SERVER - Server-Informationen

PHP 
<?php
// Aktuelle URL
echo $_SERVER['REQUEST_URI'];

// Request-Methode (GET, POST, etc.)
echo $_SERVER['REQUEST_METHOD'];

// User Agent (Browser-Info)
echo $_SERVER['HTTP_USER_AGENT'];

// Server-Name
echo $_SERVER['SERVER_NAME'];
?>

$_SESSION - Session-Daten

Daten, die über mehrere Seiten hinweg gespeichert werden:

PHP 
<?php
// Session starten (immer am Anfang!)
session_start();

// Daten speichern
$_SESSION['username'] = 'Leo';
$_SESSION['logged_in'] = true;

// Daten abrufen
if (isset($_SESSION['logged_in']) && $_SESSION['logged_in'] === true) {
    echo "Willkommen, " . htmlspecialchars($_SESSION['username']);
}

// Session beenden
session_destroy();
?>
Wichtig bei Superglobals
  • NIEMALS direkt ausgeben ohne htmlspecialchars()
  • Immer prüfen, ob der Key existiert (mit ?? oder isset())
  • Bei $_GET und $_POST IMMER validieren!

Praktisches Beispiel: Einfaches Kontaktformular

Lass uns alles Gelernte in einem praktischen Beispiel zusammenführen:

PHP 
<?php
// kontakt.php
declare(strict_types=1);

// Variablen für Formular
$name = '';
$email = '';
$nachricht = '';
$errors = [];
$success = false;

// Formular verarbeiten
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    
    // Daten holen und trimmen (Leerzeichen entfernen)
    $name = trim($_POST['name'] ?? '');
    $email = trim($_POST['email'] ?? '');
    $nachricht = trim($_POST['nachricht'] ?? '');
    
    // Validierung
    if (empty($name)) {
        $errors[] = 'Bitte gib deinen Namen an.';
    }
    
    if (empty($email)) {
        $errors[] = 'Bitte gib deine E-Mail an.';
    } elseif (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        $errors[] = 'Bitte gib eine gültige E-Mail an.';
    }
    
    if (empty($nachricht)) {
        $errors[] = 'Bitte gib eine Nachricht ein.';
    }
    
    // Wenn keine Fehler: Verarbeiten
    if (empty($errors)) {
        // Hier würdest du die Daten verarbeiten:
        // - E-Mail senden
        // - In Datenbank speichern
        // - etc.
        
        $success = true;
        
        // Formular zurücksetzen
        $name = '';
        $email = '';
        $nachricht = '';
    }
}
?>

<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <title>Kontaktformular</title>
    <style>
        body { font-family: Arial, sans-serif; max-width: 600px; margin: 50px auto; }
        .error { color: red; }
        .success { color: green; padding: 10px; background: #d4edda; }
        input, textarea { width: 100%; padding: 8px; margin: 5px 0; }
        button { padding: 10px 20px; background: #007bff; color: white; border: none; cursor: pointer; }
    </style>
</head>
<body>
    <h1>Kontaktformular</h1>
    
    <?php if ($success): ?>
        <div class="success">
            Vielen Dank! Deine Nachricht wurde gesendet.
        </div>
    <?php endif; ?>
    
    <?php if (!empty($errors)): ?>
        <div class="error">
            <ul>
                <?php foreach ($errors as $error): ?>
                    <li><?php echo htmlspecialchars($error, ENT_QUOTES, 'UTF-8'); ?></li>
                <?php endforeach; ?>
            </ul>
        </div>
    <?php endif; ?>
    
    <form method="post" action="">
        <label for="name">Name:</label>
        <input type="text" id="name" name="name" 
               value="<?php echo htmlspecialchars($name, ENT_QUOTES, 'UTF-8'); ?>">
        
        <label for="email">E-Mail:</label>
        <input type="email" id="email" name="email" 
               value="<?php echo htmlspecialchars($email, ENT_QUOTES, 'UTF-8'); ?>">
        
        <label for="nachricht">Nachricht:</label>
        <textarea id="nachricht" name="nachricht" rows="5"><?php 
            echo htmlspecialchars($nachricht, ENT_QUOTES, 'UTF-8'); 
        ?></textarea>
        
        <button type="submit">Absenden</button>
    </form>
</body>
</html>
Was passiert hier?
  • Formulardaten werden per POST gesendet
  • Alle Eingaben werden validiert
  • Fehler werden gesammelt und angezeigt
  • Bei Erfolg wird eine Meldung angezeigt
  • Alle Ausgaben werden mit htmlspecialchars() gesichert
  • Das Formular behält bei Fehlern die eingegebenen Werte

Nützliche PHP-Funktionen für den Alltag

String-Funktionen

PHP 
<?php
$text = "  Hallo Welt  ";

// Länge eines Strings
echo strlen($text); // 14 (inkl. Leerzeichen)

// Leerzeichen entfernen
echo trim($text); // "Hallo Welt"

// Groß-/Kleinschreibung
echo strtoupper($text); // "  HALLO WELT  "
echo strtolower($text); // "  hallo welt  "

// String ersetzen
echo str_replace("Welt", "PHP", $text); // "  Hallo PHP  "

// String in Array splitten
$woerter = explode(" ", trim($text)); // ["Hallo", "Welt"]

// Array zu String zusammenfügen
echo implode("-", $woerter); // "Hallo-Welt"

// Teil eines Strings
echo substr("Hallo Welt", 0, 5); // "Hallo"

// Prüfen, ob String etwas enthält
if (str_contains($text, "Hallo")) {
    echo "Gefunden!";
}
?>

Array-Funktionen

PHP 
<?php
$zahlen = [5, 2, 8, 1, 9];

// Anzahl der Elemente
echo count($zahlen); // 5

// Sortieren
sort($zahlen); // [1, 2, 5, 8, 9]
rsort($zahlen); // [9, 8, 5, 2, 1]

// Element am Ende hinzufügen
array_push($zahlen, 10);

// Letztes Element entfernen
$letztes = array_pop($zahlen);

// Prüfen, ob Wert existiert
if (in_array(5, $zahlen)) {
    echo "5 ist im Array!";
}

// Keys eines Arrays
$person = ["name" => "Leo", "alter" => 18];
$keys = array_keys($person); // ["name", "alter"]

// Werte eines Arrays
$werte = array_values($person); // ["Leo", 18]

// Arrays zusammenführen
$array1 = [1, 2, 3];
$array2 = [4, 5, 6];
$merged = array_merge($array1, $array2); // [1, 2, 3, 4, 5, 6]
?>

Datum und Zeit

PHP 
<?php
// Aktuelles Datum und Zeit
echo date("d.m.Y"); // z.B. 26.11.2025
echo date("H:i:s"); // z.B. 14:30:00
echo date("d.m.Y H:i"); // z.B. 26.11.2025 14:30

// Unix-Timestamp (Sekunden seit 1.1.1970)
echo time(); // z.B. 1732627200

// Datum von Timestamp
echo date("d.m.Y", time()); // Heutiges Datum

// Datum berechnen (z.B. morgen)
$morgen = time() + (24 * 60 * 60); // +1 Tag in Sekunden
echo date("d.m.Y", $morgen);
?>

Mathematische Funktionen

PHP 
<?php
// Aufrunden/Abrunden
echo ceil(4.3);  // 5
echo floor(4.8); // 4
echo round(4.5); // 5

// Zufallszahl
echo rand(1, 100); // Zufällige Zahl zwischen 1 und 100

// Minimum/Maximum
echo min(5, 3, 8, 1); // 1
echo max(5, 3, 8, 1); // 8

// Absolutwert
echo abs(-5); // 5

// Potenz
echo pow(2, 3); // 8 (2³)

// Quadratwurzel
echo sqrt(16); // 4
?>

Best Practices für sauberen PHP-Code

1. Nutze aussagekräftige Variablennamen

Gut 
<?php
$benutzername = "Leo";
$alter = 18;
$vollstaendigeInfo = $benutzername . ", " . $alter;
?>
Schlecht 
<?php
$x = "Leo";
$y = 18;
$z = $x . ", " . $y;
?>

2. Verwende Konstanten für feste Werte

PHP 
<?php
// Konstanten mit define()
define('SITE_NAME', 'DevPanicZone');
define('MAX_LOGIN_ATTEMPTS', 3);

// Oder mit const (moderner)
const DB_HOST = 'localhost';
const DB_NAME = 'meine_datenbank';

echo SITE_NAME; // DevPanicZone
?>

3. Aktiviere Error Reporting während der Entwicklung

PHP 
<?php
// Am Anfang deiner PHP-Datei (nur für Entwicklung!)
error_reporting(E_ALL);
ini_set('display_errors', 1);

// Für Produktiv-Server: Fehler in Log-Datei schreiben
// error_reporting(E_ALL);
// ini_set('display_errors', 0);
// ini_set('log_errors', 1);
?>

4. Nutze Type Declarations

PHP 
<?php
declare(strict_types=1);

function berechnePreis(float $netto, float $mehrwertsteuer): float {
    return $netto * (1 + $mehrwertsteuer);
}

$bruttoPreis = berechnePreis(100.0, 0.19); // 119.0
?>

5. Verwende immer === statt ==

Gut 
<?php
$zahl = 5;
$string = "5";

// ✓ Strenger Vergleich (empfohlen)
if ($zahl === $string) {
    echo "Gleich";
} else {
    echo "Nicht gleich"; // Das wird ausgegeben
}
?>
Schlecht 
<?php
$zahl = 5;
$string = "5";

// ✗ Schwacher Vergleich (nicht empfohlen)
if ($zahl == $string) { 
    echo "Gleich"; // true (Typumwandlung)
}
?>

6. Nutze den Null Coalescing Operator

Gut 
<?php
// ✅ Modern und kurz
$name = $_GET['name'] ?? 'Gast';

// Auch mit mehreren Fallbacks möglich
$name = $_GET['name'] ?? $_POST['name'] ?? 'Gast';
?>
Schlecht 
<?php
// ❌ Alt und umständlich
$name = isset($_GET['name']) ? $_GET['name'] : 'Gast';
?>
Weitere Best Practices
  • Code immer einrücken und formatieren
  • Kommentare für komplexe Logik hinzufügen
  • Funktionen klein halten (eine Aufgabe pro Funktion)
  • Keine hartcodierten Werte - nutze Konstanten oder Config-Dateien
  • Code in sinnvolle Dateien aufteilen (z.B. functions.php, config.php)

Zusammenfassung: Das hast du gelernt

Wow, das war eine Menge! Aber jetzt hast du eine solide Basis für PHP. Hier nochmal die wichtigsten Punkte:

  • PHP ist eine serverseitige Sprache für dynamische Webseiten
  • PHP-Code steht zwischen <?php und ?> Tags
  • Variablen beginnen mit $ und sind dynamisch typisiert
  • Nutze echo zur Ausgabe, aber immer mit htmlspecialchars() bei Nutzerdaten
  • Arrays können numerisch oder assoziativ sein
  • Bedingungen: if, elseif, else, switch
  • Schleifen: while, do-while, for, foreach
  • Funktionen mit function definieren, Type Declarations nutzen
  • Sicherheit first: Nutzereingaben immer bereinigen und validieren
  • Superglobals wie $_GET, $_POST, $_SERVER kennen
  • Code mit require_once in andere Dateien auslagern
Wie geht's weiter?
  • PHP Security - XSS, SQL Injection, CSRF und mehr
  • Objektorientierte Programmierung (OOP) - Klassen, Objekte, Vererbung
  • Datenbanken mit PHP - MySQL, PDO, CRUD-Operationen
  • Sessions und Cookies - Login-Systeme, User-Authentifizierung
  • Formulare und File-Uploads - Sicherer Umgang mit Nutzereingaben

Mehr aus PHP

Tutorials werden geladen...