PHP Cheat Sheet
Das PHP Cheat Sheet ist eine umfassende Referenz für Entwickler, die schnell auf zentrale PHP-Funktionen, Syntax, Datenstrukturen und Best Practices zugreifen möchten. Es dient als unverzichtbares Werkzeug, um die Entwicklungszeit zu verkürzen, häufige Fehler zu vermeiden und komplexe Probleme effizient zu lösen. Besonders in professionellen Projekten, bei denen Wartbarkeit, Performance und Sicherheit entscheidend sind, bietet ein Cheat Sheet PHP-Entwicklern die Möglichkeit, schnell bewährte Methoden anzuwenden.
Leser dieses Cheat Sheets lernen, wie sie ihre PHP-Projekte strukturieren, OOP-Prinzipien effizient anwenden und robuste Fehlerbehandlung implementieren. Sie erfahren, wie sie Daten sicher verarbeiten, Algorithmen effizient gestalten und die Performance ihrer Anwendungen steigern. Im Kontext der Systemarchitektur unterstützt das PHP Cheat Sheet Entwickler dabei, skalierbare, wartbare und sichere PHP-Anwendungen zu erstellen.
Grundlegendes Beispiel
php<?php
// Einfaches Beispiel: Assoziatives Array und Iteration
$user = [
'name' => 'Anna',
'age' => 30,
'role' => 'Entwicklerin'
];
function displayUser(array $user): void {
foreach ($user as $key => $value) {
echo ucfirst($key) . ": " . $value . PHP_EOL;
}
}
displayUser($user);
?>In diesem grundlegenden Beispiel wird ein assoziatives Array $user erstellt, das Benutzerdaten speichert. Dies veranschaulicht die Nutzung von PHP-Datenstrukturen zur organisierten Speicherung von Informationen. Die Funktion displayUser nimmt ein Array als Parameter, wobei strikte Typisierung (array $user) eingesetzt wird, um Typfehler zu vermeiden.
Die foreach-Schleife iteriert über das Array, während ucfirst die erste Buchstabe jeder Schlüsselbezeichnung großschreibt. PHP_EOL sorgt für systemunabhängige Zeilenumbrüche. Dieses Beispiel demonstriert zentrale Konzepte des PHP Cheat Sheets, wie Arrays, Funktionsdefinitionen, Typisierung und formatiertes Output. In realen Projekten könnte diese Funktion erweitert werden, um Datenbankergebnisse zu verarbeiten oder komplexe Datenstrukturen zu handhaben.
Praktisches Beispiel
php<?php
// OOP-Beispiel: Benutzerverwaltung
class User {
private string $name;
private int $age;
private string $role;
public function __construct(string $name, int $age, string $role) {
$this->name = $name;
$this->age = $age;
$this->role = $role;
}
public function getInfo(): string {
return "Name: {$this->name}, Alter: {$this->age}, Rolle: {$this->role}";
}
}
$users = [
new User('Ben', 35, 'Ingenieur'),
new User('Clara', 28, 'Architektin')
];
foreach ($users as $user) {
echo $user->getInfo() . PHP_EOL;
}
?>Advanced PHP Implementation
php<?php
// Fortgeschrittenes Beispiel: OOP, Exception Handling, Optimierung
class Calculator {
public function divide(float $a, float $b): float {
if ($b === 0.0) {
throw new InvalidArgumentException("Division durch Null nicht erlaubt.");
}
return $a / $b;
}
}
try {
$calc = new Calculator();
echo $calc->divide(100, 4) . PHP_EOL;
echo $calc->divide(10, 0) . PHP_EOL;
} catch (InvalidArgumentException $e) {
echo "Fehler: " . $e->getMessage();
}
?>Dieses fortgeschrittene Beispiel demonstriert die Anwendung von PHP Cheat Sheet-Konzepten in einem realen Szenario. Die Klasse Calculator kapselt die Divisionslogik und überprüft die Eingabe, um Divisionen durch Null zu vermeiden. Durch die Verwendung von try/catch wird eine strukturierte Fehlerbehandlung implementiert, sodass der Programmfluss trotz Fehler stabil bleibt.
Dieses Beispiel zeigt wichtige PHP-Konzepte wie strikte Typisierung, Kapselung, objektorientiertes Design und effiziente Fehlerbehandlung. In professionellen Projekten kann dieses Muster für APIs oder komplexe Module verwendet werden, um robuste und wartbare Software zu entwickeln.
Best Practices in PHP umfassen den Einsatz strikter Typisierung, geeigneter Datenstrukturen, optimierter Algorithmen und objektorientierter Designmuster. Häufige Fehler, die vermieden werden sollten, sind Speicherlecks, nicht behandelte Exceptions, ineffiziente Schleifen und unvalidierte Eingaben.
Für Debugging und Troubleshooting sind var_dump, print_r und debug_backtrace unverzichtbar. Performance kann durch Caching, OPcache, effiziente Schleifen und optimierte Algorithmen verbessert werden. Sicherheit sollte durch Input-Validierung, Output-Escaping, SQL-Injection-Prävention und sicheren Umgang mit sensiblen Daten gewährleistet sein. Die konsequente Anwendung dieser Best Practices unterstützt die Umsetzung des PHP Cheat Sheets in professionellen Projekten.
📊 Umfassende Referenz
| PHP Element/Method | Description | Syntax | Example | Notes |
|---|---|---|---|---|
| echo | Gibt Daten aus | echo "Text"; | echo "Hallo"; | Hauptausgabe |
| Gibt Daten aus und return 1 | print "Text"; | print "Hallo"; | Return Wert 1 | |
| array | Array erstellen | array(1,2,3) | $arr = array(1,2,3); | Alternative: [] |
| count | Elemente zählen | count($arr); | count($arr); | Anzahl Elemente |
| foreach | Array durchlaufen | foreach($arr as $val) | foreach($arr as $val) echo $val; | Häufige Schleife |
| isset | Variable prüfen | isset($var); | isset($name); | Boolescher Wert |
| empty | Prüft, ob leer | empty($var); | empty($name); | Beinhaltet null,0,"" |
| array_push | Element hinzufügen | array_push($arr,$val); | array_push($arr,4); | Am Ende hinzufügen |
| array_pop | Letztes Element entfernen | array_pop($arr); | array_pop($arr); | Gibt entferntes Element zurück |
| explode | String in Array | explode(" ",$str); | explode(" ","a b"); | String teilen |
| implode | Array zu String | implode(",",$arr); | implode(",",[1,2]); | CSV/Text |
| strlen | Stringlänge | strlen($str); | strlen("Hallo"); | Beinhaltet Leerzeichen |
| substr | Teilstring | substr($str,0,5); | substr("abcdef",0,3); | Substring |
| str_replace | Text ersetzen | str_replace("a","b",$str); | str_replace("a","b","abc"); | Textmanipulation |
| json_encode | In JSON konvertieren | json_encode($arr); | json_encode(["a"=>1]); | API |
| json_decode | JSON zu Array | json_decode($str,true); | json_decode('{"a":1}',true); | Parsing |
| file_get_contents | Datei lesen | file_get_contents("file.txt"); | file_get_contents("data.txt"); | Einfaches Lesen |
| file_put_contents | Datei schreiben | file_put_contents("file.txt",$data); | file_put_contents("data.txt","abc"); | Überschreibt Inhalt |
| fopen | Datei öffnen | fopen("file.txt","r"); | fopen("data.txt","r"); | Mit fread/fwrite |
| fclose | Datei schließen | fclose($handle); | fclose($fp); | Ressource freigeben |
| date | Datum formatieren | date("Y-m-d"); | date("Y-m-d"); | Mit time() kombinierbar |
| time | Aktueller Timestamp | time(); | time(); | Sekunden seit Epoch |
| strtotime | String zu Timestamp | strtotime("next Monday"); | strtotime("2025-10-01"); | Planung |
| session_start | Session starten | session_start(); | session_start(); | Mehrseitenspeicherung |
| session_destroy | Session löschen | session_destroy(); | session_destroy(); | Daten entfernen |
| setcookie | Cookie erstellen | setcookie("name","value"); | setcookie("user","php"); | Session Management |
| header | HTTP-Header senden | header("Location: url"); | header("Location: /home"); | Weiterleitung |
| require | Datei einbinden | required "file.php"; | require "config.php"; | Fatal bei Fehlen |
| include | Datei einbinden | include "file.php"; | include "header.php"; | Warnung bei Fehlen |
| require_once | Einmalig einbinden | required_once "file.php"; | require_once "config.php"; | Vermeidet Duplikate |
| include_once | Einmalig einbinden | include_once "file.php"; | include_once "header.php"; | Vermeidet Duplikate |
| function | Funktion definieren | function name(){} | function test(){} | Mit Typisierung |
| return | Wert zurückgeben | return $val; | return 5; | Beendet Funktion |
| class | Klasse definieren | class Name{} | class User{} | Basis OOP |
| public | Öffentlich | public $var; | public $name; | Überall zugänglich |
| private | Privat | private $var; | private $age; | Nur in Klasse |
| protected | Geschützt | protected $var; | protected $role; | Nur in Klasse/Subklasse |
| __construct | Konstruktor | function __construct(){} | function __construct($a){} | Initialisierung Objekt |
| __destruct | Destruktor | function __destruct(){} | function __destruct(){} | Ressourcenfreigabe |
| try/catch | Exception Handling | try{}catch(Exception $e){} | try{}catch(Exception $e){} | Strukturierte Fehler |
| throw | Exception auslösen | throw new Exception("msg"); | throw new Exception("Fehler"); | Exception Mechanismus |
| spl_autoload_register | Autoload Klasse | spl_autoload_register(fn($c)=>include "$c.php"); | spl_autoload_register(fn($c)=>include "$c.php"); | Automatische Einbindung |
| var_dump | Debug | var_dump($var); | var_dump($user); | Typ und Wert |
| print_r | Debug Array/Objekt | print_r($arr); | print_r($users); | Lesbar |
| die | Script beenden | die("msg"); | die("Fehler"); | Sofortige Beendigung |
| exit | Script beenden | exit("msg"); | exit("Ende"); | Sofortige Beendigung |
| htmlspecialchars | HTML escapen | htmlspecialchars("<a>"); | htmlspecialchars("<b>"); | XSS-Prävention |
| trim | Leerzeichen entfernen | trim(" abc "); | trim(" abc "); | Input Reinigung |
| array_key_exists | Schlüssel prüfen | array_key_exists("a",$arr); | array_key_exists("a",["a"=>1]); | Existenz prüfen |
| method_exists | Methode prüfen | method_exists($obj,"func"); | method_exists($user,"getInfo"); | Fehler vermeiden |
| class_exists | Klasse prüfen | class_exists("User"); | class_exists("User"); | Dynamische Prüfung |
| interface_exists | Interface prüfen | interface_exists("IUser"); | interface_exists("IUser"); | Dynamische Prüfung |
| trait_exists | Trait prüfen | trait_exists("T"); | trait_exists("T"); | Code Wiederverwendung |
| ob_start | Output Buffer | ob_start(); | ob_start(); | Performance Optimierung |
| ob_get_clean | Buffer holen & reinigen | ob_get_clean(); | ob_get_clean(); | Output Kontrolle |
| uniqid | Eindeutige ID | uniqid(); | uniqid(); | Schnelle ID |
| mt_rand | Zufallszahl | mt_rand(1,10); | mt_rand(1,10); | Schneller als rand() |
| shuffle | Array mischen | shuffle($arr); | shuffle([1,2,3]); | Randomisierung |
| in_array | Wert im Array | in_array(3,$arr); | in_array(3,[1,2,3]); | Boolescher Rückgabewert |
| array_merge | Arrays zusammenfügen | array_merge($a,$b); | array_merge([1],[2]); | Kombiniert Arrays |
| sort | Array sortieren | sort($arr); | sort([3,1,2]); | Aufsteigend |
| rsort | Array absteigend | rsort($arr); | rsort([3,1,2]); | Absteigend |
| asort | Assoziativ sortieren | asort($arr); | asort(["b"=>2,"a"=>1]); | Schlüssel erhalten |
| ksort | Keys sortieren | ksort($arr); | ksort(["b"=>2,"a"=>1]); | Aufsteigend Keys |
| arsort | Assoziativ absteigend | arsort($arr); | arsort(["b"=>2,"a"=>1]); | Keys erhalten |
| krsort | Keys absteigend | krsort($arr); | krsort(["b"=>2,"a"=>1]); | Keys absteigend |
| array_filter | Array filtern | array_filter($arr, fn($v)=>$v>1); | array_filter([1,2,3],fn($v)=>$v>1); | Callback |
| array_map | Array mappen | array_map(fn($v)=>$v*2,$arr); | array_map(fn($v)=>$v*2,[1,2]); | Callback |
| array_reduce | Array reduzieren | array_reduce($arr, fn($c,$v)=>$c+$v,0); | array_reduce([1,2,3],fn($c,$v)=>$c+$v,0); | Aggregation |
| password_hash | Passwort hash | password_hash($pwd,PASSWORD_DEFAULT); | password_hash("123",PASSWORD_DEFAULT); | Sicherheit |
| password_verify | Passwort prüfen | password_verify($pwd,$hash); | password_verify("123",$hash); | Authentifizierung |
| filter_var | Daten validieren | filter_var($email,FILTER_VALIDATE_EMAIL); | filter_var("[[email protected]](mailto:[email protected])",FILTER_VALIDATE_EMAIL); | Sanitization |
| microtime | Aktuelle Zeit | microtime(true); | microtime(true); | Performance |
| ceil | Aufrunden | ceil(4.2); | ceil(4.2); | Mathematik |
| floor | Abrunden | floor(4.8); | floor(4.8); | Mathematik |
| round | Runden | round(4.5); | round(4.5); | Mathematik |
| abs | Betrag | abs(-5); | abs(-5); | Mathematik |
📊 Complete PHP Properties Reference
| Property | Values | Default | Description | PHP Support |
|---|---|---|---|---|
| memory_limit | Integer | string | 128M | Maximaler Speicher |
| error_reporting | Integer | E_ALL | Fehlerlevel | Alle Versionen |
| display_errors | On/Off | On | Fehler anzeigen | Alle Versionen |
| max_execution_time | Integer | 30 | Max. Ausführungszeit | Alle Versionen |
| upload_max_filesize | Integer | string | 2M | Max. Uploadgröße |
| post_max_size | Integer | string | 8M | Max. POST-Größe |
| default_charset | String | UTF-8 | Standardzeichenkodierung | PHP 5.6+ |
| date.timezone | String | UTC | Zeitzone | PHP 5.1+ |
| session.gc_maxlifetime | Integer | 1440 | Session Lebensdauer | Alle Versionen |
| opcache.enable | On/Off | Off | OPcache aktivieren | PHP 5.5+ |
| max_input_vars | Integer | 1000 | Max. Input-Variablen | PHP 5.3+ |
| precision | Integer | 14 | Fließkomma Präzision | Alle Versionen |
Zusammenfassend bietet das PHP Cheat Sheet eine schnelle, zuverlässige Referenz, um Code effizient, sicher und wartbar zu gestalten. Entwickler lernen, wie man Syntax, Datenstrukturen, OOP und Algorithmen korrekt anwendet, und wie man typische Fallstricke vermeidet. Für weiterführende Studien empfehlen sich Frameworks wie Laravel oder Symfony, Patterns wie Singleton oder Factory, Performance-Optimierungen und Sicherheitskonzepte wie Input-Validierung und XSS-Prävention. Mit der konsequenten Anwendung dieses Wissens können Entwickler professionelle, skalierbare und sichere PHP-Anwendungen erstellen.
🧠 Testen Sie Ihr Wissen
Testen Sie Ihr Wissen
Fordern Sie sich mit diesem interaktiven Quiz heraus und sehen Sie, wie gut Sie das Thema verstehen
📝 Anweisungen
- Lesen Sie jede Frage sorgfältig
- Wählen Sie die beste Antwort für jede Frage
- Sie können das Quiz so oft wiederholen, wie Sie möchten
- Ihr Fortschritt wird oben angezeigt