PHP Spickzettel

Q: Was ist der Unterschied zwischen == und === in PHP?

`==` ist ein loser Vergleich: Er wandelt die Operanden vor dem Vergleich in einen gemeinsamen Typ um, sodass sich `0 == "0"` und sogar `0 == ""` über Versionen hinweg überraschend verhalten können. `===` ist ein strenger Vergleich: Er gibt nur dann true zurück, wenn die Werte gleich und vom selben Typ sind, sodass `0 === "0"` false ergibt. Bevorzuge `===`, um Bugs durch Typumwandlung zu vermeiden.

Zuletzt aktualisiert 27. Mai 2026

Live im PHP-Playground ausprobieren PHP kostenlos lernen

Hello World & Tags

PHP-Code lebt innerhalb von <?php ... ?>-Tags; alles außerhalb wird als reine Ausgabe gesendet.

Operation	Syntax
PHP öffnen / schließen	`<?php ... ?>`
Text ausgeben	`echo "Hello, World!";`
Formatiert ausgeben	`printf("%d items", $n);`
Kurzes Echo (in HTML)	`<?= $name ?>`
Einzeiliger Kommentar	`// comment` oder `# comment`
Blockkommentar	`/* comment */`
Anweisungsabschluss	`;`
Eine Datei ausführen (CLI)	`php index.php`

Variablen & Typen

Variablen beginnen mit $ und sind dynamisch typisiert.

Operation	Syntax
Eine Variable deklarieren	`$name = "Ada";`
Konstante	`const PI = 3.14;` oder `define("PI", 3.14);`
Skalare Typen	`int`, `float`, `string`, `bool`
Null	`$x = null;`
Den Typ prüfen	`gettype($x)`, `is_int($x)`, `is_array($x)`
Einen Typ casten	`(int) $str`, `(string) $num`
Variable existiert / gesetzt	`isset($x)`, `empty($x)`
String-Interpolation	`echo "Hi $name";`

Strings

Doppelte Anführungszeichen interpolieren Variablen; einfache sind wörtlich.

Operation	Syntax
Verketten	`$a . $b`
Länge	`strlen($s)`
Groß-/Kleinschreibung	`strtoupper($s)`, `strtolower($s)`
Teilstring	`substr($s, 0, 5)`
Position finden	`strpos($s, "x")`
Ersetzen	`str_replace("a", "b", $s)`
In Array aufteilen	`explode(",", $csv)`
Ein Array zusammenfügen	`implode(",", $arr)`
Leerzeichen entfernen	`trim($s)`
Einen String formatieren	`sprintf("%05.2f", $n)`

Arrays (inkl. assoziative)

Ein Array-Typ deckt sowohl indizierte Listen als auch Schlüssel-Wert-Maps ab.

Operation	Syntax
Indiziertes Array	`$nums = [1, 2, 3];`
Assoziatives Array	`$user = ["name" => "Ada", "age" => 30];`
Auf ein Element zugreifen	`$nums[0]`, `$user["name"]`
Anhängen	`$nums[] = 4;`
Einen Schlüssel setzen	`$user["role"] = "admin";`
Länge	`count($nums)`
Einen Schlüssel prüfen	`isset($user["name"])`, `array_key_exists("name", $user)`
Ein Element entfernen	`unset($nums[1]);`
Arrays zusammenführen	`array_merge($a, $b)`
Schlüssel => Wert durchlaufen	`foreach ($user as $k => $v) { ... }`

Kontrollfluss

Bedingungen und Schleifen folgen der C-Stil-Syntax.

Operation	Syntax
If / elseif / else	`if ($x > 0) { ... } elseif (...) { ... } else { ... }`
Ternär	`$y = $x > 0 ? "pos" : "neg";`
Null-Coalescing	`$name = $_GET["name"] ?? "guest";`
Switch	`switch ($day) { case 1: ...; break; default: ... }`
For-Schleife	`for ($i = 0; $i < 10; $i++) { ... }`
While-Schleife	`while ($x < 100) { ... }`
Foreach	`foreach ($items as $item) { ... }`
Match-Ausdruck	`$r = match($x) { 1 => "one", default => "?" };`
Break / continue	`break;`, `continue;`

Funktionen

Funktionen können Typen, Standardwerte und variadische Parameter deklarieren.

Operation	Syntax
Einfache Funktion	`function add($a, $b) { return $a + $b; }`
Typisierte Parameter & Rückgabe	`function add(int $a, int $b): int { ... }`
Standardwert	`function greet($name = "guest") { ... }`
Variadische Parameter	`function sum(...$nums) { ... }`
Übergabe per Referenz	`function inc(&$x) { $x++; }`
Anonyme Funktion	`$f = function($x) { return $x * 2; };`
Arrow-Funktion	`$f = fn($x) => $x * 2;`
Äußere Variable verwenden	`function() use ($n) { ... }`

Superglobals

Eingebaute Arrays, die in jedem Geltungsbereich verfügbar sind, meist für Request-Daten.

Superglobal	Was es enthält
`$_GET`	Query-String-Parameter aus der URL
`$_POST`	Per POST gesendete Formulardaten
`$_REQUEST`	Kombiniert `$_GET`, `$_POST` und `$_COOKIE`
`$_SESSION`	Benutzerbezogene Sitzungsdaten (nach `session_start()`)
`$_COOKIE`	Vom Browser gesendete Cookies
`$_SERVER`	Server- und Request-Infos (`REQUEST_METHOD` usw.)
`$_FILES`	Metadaten hochgeladener Dateien
`$_ENV`	Umgebungsvariablen

Häufige Array-Funktionen

PHP bringt Hunderte von Array-Helfern mit; diese sind die Arbeitstiere.

Funktion	Was sie macht
`array_map($fn, $arr)`	Jedes Element transformieren
`array_filter($arr, $fn)`	Elemente behalten, bei denen der Callback true ist
`array_reduce($arr, $fn, $init)`	Zu einem einzelnen Wert zusammenfalten
`in_array($v, $arr)`	Prüfen, ob ein Wert vorhanden ist
`array_keys($arr)` / `array_values($arr)`	Schlüssel oder Werte holen
`sort($arr)` / `rsort($arr)`	An Ort und Stelle sortieren (auf / ab)
`usort($arr, $cmp)`	Mit einem eigenen Vergleicher sortieren
`array_slice($arr, 1, 3)`	Einen Ausschnitt extrahieren
`array_push($arr, $v)` / `array_pop($arr)`	Am Ende hinzufügen / entfernen

Klassen & OOP

PHP unterstützt Klassen, Vererbung, Interfaces und Sichtbarkeitsmodifizierer.

Operation	Syntax
Eine Klasse definieren	`class User { ... }`
Eigenschaft mit Sichtbarkeit	`public string $name;`
Konstruktor	`function __construct($name) { $this->name = $name; }`
Konstruktor-Promotion	`function __construct(public string $name) {}`
Eine Instanz erstellen	`$u = new User("Ada");`
Auf einen Member zugreifen	`$u->name`, `$u->save()`
Statischer Member	`User::$count`, `User::create()`
Vererbung	`class Admin extends User { ... }`
Interface	`interface Saveable { public function save(); }`
Ein Interface implementieren	`class User implements Saveable { ... }`

Die PHP-Syntax, die du am häufigsten brauchst, auf einer Seite. Dieser PHP-Spickzettel ist eine Schnellreferenz für die Kernsprache - Variablen und Typen, Strings, Arrays (einschließlich assoziativer Arrays), Kontrollfluss, Funktionen, die Superglobals wie $_GET und $_POST sowie Klassen.

Alles hier ist Standard-PHP, das auf modernen Versionen läuft. Kopiere, was du brauchst, oder probiere jeden Codeschnipsel live im PHP-Playground aus - kein Server einzurichten.

PHP-Spickzettel FAQ

Ist dieser PHP-Spickzettel kostenlos?

Ja. Dieser PHP-Spickzettel ist völlig kostenlos, ohne erforderliche Anmeldung. Setze ein Lesezeichen und komm jederzeit wieder, wenn du eine String-Funktion, einen Array-Helfer oder ein Superglobal nachschlagen möchtest.

Was ist der Unterschied zwischen == und === in PHP?

== ist ein loser Vergleich: Er wandelt die Operanden vor dem Vergleich in einen gemeinsamen Typ um, sodass sich 0 == "0" und sogar 0 == "" über Versionen hinweg überraschend verhalten können. === ist ein strenger Vergleich: Er gibt nur dann true zurück, wenn die Werte gleich und vom selben Typ sind, sodass 0 === "0" false ergibt. Bevorzuge ===, um Bugs durch Typumwandlung zu vermeiden.

Was sind assoziative Arrays in PHP?

Ein assoziatives Array ist ein PHP-Array, das benannte String-Schlüssel statt (oder neben) numerischen Indizes verwendet, etwa ["name" => "Ada", "age" => 30]. PHP hat einen einzigen Array-Typ, der sowohl als geordnete Liste als auch als Schlüssel-Wert-Map dient, sodass du Werte per Schlüssel mit $user["name"] abrufst und mit foreach ($user as $key => $value) durchläufst.

Kann ich PHP online üben?

Ja. Öffne den PHP-Playground, um jeden Codeschnipsel aus diesem Spickzettel in deinem Browser auszuführen - kein Server oder lokale PHP-Installation nötig. Wenn du Struktur möchtest, führt dich Coddys kostenloser interaktiver PHP-Kurs Schritt für Schritt von Variablen und Arrays zu Funktionen und OOP.

Ist dieser Spickzettel für Anfänger geeignet?

Ja. Er ist von den häufigsten Themen (Variablen, Strings, Arrays, Kontrollfluss) hin zu den fortgeschrittenen (Superglobals und OOP) gegliedert, sodass du die oberen Abschnitte schon am ersten Tag nutzen und in den Rest hineinwachsen kannst.