# php — Die PHP-Kommandozeile

> Praxis-Guide zur PHP-CLI: Skripte ausführen, eingebauten Webserver starten, Code linten, Erweiterungen prüfen und die PHP-Umgebung inspizieren.

Source: https://www.jpkc.com/db/cheatsheets/build-languages/php/

<!-- PROSE:intro -->
Das `php`-Binary ist nicht nur der Interpreter hinter deinem Webserver, sondern auch ein vollwertiges Kommandozeilen-Werkzeug für den Alltag. Du führst damit Skripte aus, startest mit `-S` blitzschnell einen eingebauten Webserver für die lokale Entwicklung, öffnest mit `-a` eine interaktive REPL und prüfst mit `-l` die Syntax einer Datei ohne sie auszuführen. Mit `-i` und `-r` inspizierst du Konfiguration und Umgebung oder lässt PHP-Code direkt aus der Shell laufen – ideal für schnelle Einzeiler, Debugging und Automatisierung. Dieser Guide zeigt dir die wichtigsten Schalter von der Skriptausführung über Linting bis zu Xdebug.
<!-- PROSE:intro:end -->

## Skripte ausführen

`php <file>` — Führt ein PHP-Skript aus.

```bash
php script.php
```

`php -f <file>` — Gibt die auszuführende Datei explizit an (gleichbedeutend mit dem Aufruf ohne -f).

```bash
php -f migrate.php
```

`php -r '<code>'` — Führt PHP-Code direkt von der Kommandozeile aus, ohne Datei.

```bash
php -r 'echo PHP_VERSION . PHP_EOL;'
```

`php -r '<code>' -- <arg1> <arg2>` — Führt Inline-Code mit Argumenten aus. Zugriff über $argv.

```bash
php -r 'var_dump($argv);' -- hello world
```

`echo '<input>' | php <file>` — Leitet Daten über stdin in ein PHP-Skript.

```bash
echo '{"name":"John"}' | php -r 'echo json_decode(file_get_contents("php://stdin"))->name;'
```

`php -a` — Startet die interaktive PHP-Shell (REPL).

```bash
php -a
```

`php -B '<before>' -R '<each_line>' <file>` — Verarbeitet jede Eingabezeile. -B läuft einmal vorab, -R für jede Zeile ($argn = aktuelle Zeile).

```bash
cat data.txt | php -B 'echo "Start\n";' -R 'echo strtoupper($argn) . PHP_EOL;'
```

## Eingebauter Webserver

`php -S localhost:<port>` — Startet den eingebauten Entwicklungs-Webserver.

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

`php -S localhost:<port> -t <docroot>` — Startet den Server mit einem bestimmten Document-Root-Verzeichnis.

```bash
php -S localhost:8000 -t public/
```

`php -S 0.0.0.0:<port>` — Startet den Server erreichbar für andere Geräte im Netzwerk.

```bash
php -S 0.0.0.0:8000
```

`php -S localhost:<port> <router>` — Startet den Server mit einem eigenen Router-Skript.

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

`PHP_CLI_SERVER_WORKERS=<n> php -S localhost:<port>` — Startet den Server mit mehreren Workern für parallele Request-Verarbeitung (PHP 7.4+).

```bash
PHP_CLI_SERVER_WORKERS=4 php -S localhost:8000 -t public/
```

## Syntax-Prüfung & Linting

`php -l <file>` — Prüft eine Datei auf Syntaxfehler, ohne sie auszuführen.

```bash
php -l index.php
```

`find <dir> -name '*.php' -exec php -l {} \;` — Lintet alle PHP-Dateien in einem Verzeichnis rekursiv.

```bash
find ./src/ -name '*.php' -exec php -l {} \;
```

`find <dir> -name '*.php' -print0 | xargs -0 -n1 php -l` — Lintet alle PHP-Dateien sicher, auch bei Dateinamen mit Leerzeichen.

```bash
find ./src/ -name '*.php' -print0 | xargs -0 -n1 php -l
```

`php -l <file> 2>&1 | grep -v 'No syntax errors'` — Lintet eine Datei und zeigt die Ausgabe nur bei Fehlern.

```bash
find . -name '*.php' -exec php -l {} \; 2>&1 | grep -v 'No syntax errors'
```

## Version & Umgebung

`php -v` — Zeigt PHP-Version, Zend-Engine-Version und geladene Module.

```bash
php -v
```

`php -i` — Zeigt die vollständige phpinfo()-Ausgabe auf der Kommandozeile.

```bash
php -i
```

`php -i | grep <setting>` — Sucht nach einer bestimmten Einstellung in der PHP-Konfiguration.

```bash
php -i | grep memory_limit
```

`php -r 'phpinfo();' | grep '<directive>'` — Alternativer Weg, um PHP-Konfigurationswerte zu durchsuchen.

```bash
php -r 'phpinfo();' | grep 'upload_max_filesize'
```

`php -r 'echo php_ini_loaded_file() . PHP_EOL;'` — Zeigt den Pfad zur geladenen php.ini-Datei.

```bash
php -r 'echo php_ini_loaded_file() . PHP_EOL;'
```

`php --ini` — Zeigt alle geladenen Konfigurationsdateien (php.ini und zusätzliche .ini-Dateien).

```bash
php --ini
```

`php -r 'echo PHP_INT_SIZE * 8 . "-bit" . PHP_EOL;'` — Prüft, ob PHP im 32-Bit- oder 64-Bit-Modus läuft.

```bash
php -r 'echo PHP_INT_SIZE * 8 . "-bit" . PHP_EOL;'
```

## Erweiterungen & Module

`php -m` — Listet alle geladenen PHP-Erweiterungen auf.

```bash
php -m
```

`php -m | grep <extension>` — Prüft, ob eine bestimmte Erweiterung geladen ist.

```bash
php -m | grep mbstring
```

`php -r 'echo extension_loaded("<ext>") ? "yes" : "no";'` — Prüft programmatisch, ob eine Erweiterung verfügbar ist.

```bash
php -r 'echo extension_loaded("redis") ? "yes" : "no";'
```

`php --re <extension>` — Zeigt ausführliche Informationen zu einer Erweiterung (Klassen, Funktionen, Konstanten).

```bash
php --re json
```

`php --ri <extension>` — Zeigt Konfigurationsinformationen zu einer Erweiterung (wie ein phpinfo()-Abschnitt).

```bash
php --ri opcache
```

`php -d extension=<name> <file>` — Lädt eine Erweiterung nur für diese Ausführung.

```bash
php -d extension=xdebug script.php
```

## Konfiguration überschreiben

`php -d <directive>=<value> <file>` — Überschreibt eine php.ini-Direktive für diese Ausführung.

```bash
php -d memory_limit=512M import.php
```

`php -d memory_limit=-1 <file>` — Hebt das Speicherlimit auf (unbegrenzt). Nützlich für die Verarbeitung großer Datenmengen.

```bash
php -d memory_limit=-1 migrate.php
```

`php -d display_errors=On -d error_reporting=E_ALL <file>` — Aktiviert die vollständige Fehlerausgabe zum Debuggen.

```bash
php -d display_errors=On -d error_reporting=E_ALL buggy-script.php
```

`php -d max_execution_time=0 <file>` — Hebt das Zeitlimit für lang laufende Skripte auf.

```bash
php -d max_execution_time=0 long-import.php
```

`php -d opcache.enable_cli=1 <file>` — Aktiviert OPcache für CLI-Skripte (standardmäßig deaktiviert).

```bash
php -d opcache.enable_cli=1 benchmark.php
```

`php -n <file>` — Läuft ohne jede php.ini-Datei. Nützlich zum Testen mit unveränderten PHP-Standardeinstellungen.

```bash
php -n -r 'echo ini_get("memory_limit");'
```

`php -c <ini_path> <file>` — Verwendet eine bestimmte php.ini-Datei oder ein Verzeichnis.

```bash
php -c /etc/php/cli/php.ini script.php
```

## Code-Analyse & Debugging

`php -w <file>` — Entfernt alle Kommentare und Whitespace aus einer PHP-Datei.

```bash
php -w verbose-script.php
```

`php --rf <function>` — Zeigt Signatur und Details einer eingebauten Funktion (Reflection).

```bash
php --rf array_map
```

`php --rc <class>` — Zeigt Signatur, Methoden und Eigenschaften einer eingebauten Klasse.

```bash
php --rc DateTime
```

`php -r 'print_r(get_defined_functions()["internal"]);'` — Listet alle verfügbaren eingebauten Funktionen auf.

```bash
php -r 'print_r(get_defined_functions()["internal"]);'
```

`php -r 'var_dump(get_loaded_extensions());'` — Zeigt alle geladenen Erweiterungen als indiziertes Array.

```bash
php -r 'var_dump(get_loaded_extensions());'
```

## Einzeiler & Datenverarbeitung

`php -r 'echo json_encode(<data>, JSON_PRETTY_PRINT);'` — Gibt JSON-Daten formatiert aus.

```bash
php -r 'echo json_encode(["name" => "John", "age" => 30], JSON_PRETTY_PRINT);'
```

`php -r 'echo base64_encode("<text>");'` — Kodiert eine Zeichenkette als Base64.

```bash
php -r 'echo base64_encode("Hello World") . PHP_EOL;'
```

`php -r 'echo base64_decode("<encoded>");'` — Dekodiert eine Base64-Zeichenkette.

```bash
php -r 'echo base64_decode("SGVsbG8gV29ybGQ=") . PHP_EOL;'
```

`php -r 'echo urlencode("<text>");'` — URL-kodiert eine Zeichenkette.

```bash
php -r 'echo urlencode("hello world & foo=bar") . PHP_EOL;'
```

`php -r 'echo password_hash("<password>", PASSWORD_DEFAULT);'` — Erzeugt einen sicheren Passwort-Hash.

```bash
php -r 'echo password_hash("MySecretPass", PASSWORD_DEFAULT) . PHP_EOL;'
```

`php -r 'echo bin2hex(random_bytes(<n>));'` — Erzeugt eine kryptografisch sichere zufällige Hex-Zeichenkette.

```bash
php -r 'echo bin2hex(random_bytes(32)) . PHP_EOL;'
```

`php -r 'echo hash("sha256", "<text>");'` — Erzeugt einen Hash einer Zeichenkette.

```bash
php -r 'echo hash("sha256", "Hello World") . PHP_EOL;'
```

`php -r 'echo date("Y-m-d H:i:s", <timestamp>);'` — Wandelt einen Unix-Timestamp in ein lesbares Datum um.

```bash
php -r 'echo date("Y-m-d H:i:s", 1700000000) . PHP_EOL;'
```

`php -r 'echo strtotime("<date>");'` — Wandelt eine Datums-Zeichenkette in einen Unix-Timestamp um.

```bash
php -r 'echo strtotime("2024-06-15 12:00:00") . PHP_EOL;'
```

`php -r 'echo serialize(<data>);'` — Serialisiert einen PHP-Wert zur Speicherung.

```bash
php -r 'echo serialize(["a" => 1, "b" => 2]) . PHP_EOL;'
```

## Xdebug & Profiling

`php -d xdebug.mode=debug -d xdebug.start_with_request=yes <file>` — Führt ein Skript mit aktiviertem Xdebug-Step-Debugging aus.

```bash
php -d xdebug.mode=debug -d xdebug.start_with_request=yes script.php
```

`php -d xdebug.mode=profile <file>` — Profilt ein Skript. Erzeugt eine Cachegrind-Datei zur Analyse.

```bash
php -d xdebug.mode=profile -d xdebug.output_dir=/tmp slow-script.php
```

`php -d xdebug.mode=trace <file>` — Verfolgt alle Funktionsaufrufe. Erzeugt eine Trace-Datei.

```bash
php -d xdebug.mode=trace -d xdebug.output_dir=/tmp script.php
```

`XDEBUG_MODE=off php <file>` — Deaktiviert Xdebug komplett für bessere Performance (z. B. bei Composer).

```bash
XDEBUG_MODE=off php composer.phar install
```

## Pakete & Archive

`php -r 'echo Phar::running();'` — Prüft, ob das aktuelle Skript aus einem PHAR-Archiv heraus läuft.

```bash
php -r 'echo Phar::running() ?: "Not in a PHAR" . PHP_EOL;'
```

`php <phar_file>` — Führt eine PHAR-Datei (PHP Archive) direkt aus.

```bash
php composer.phar install
```

`php -d phar.readonly=0 <file>` — Erlaubt das Erstellen oder Verändern von PHAR-Archiven (aus Sicherheitsgründen standardmäßig deaktiviert).

```bash
php -d phar.readonly=0 build-phar.php
```

<!-- PROSE:outro -->
## Fazit

Die PHP-Kommandozeile ist weit mehr als nur ein Skript-Runner: Mit `-l` linten, mit `-a` experimentieren, mit `-i` und `--re` die Umgebung inspizieren und mit `-d` einzelne ini-Direktiven gezielt überschreiben – das deckt fast jeden Entwicklungs- und Debugging-Bedarf ab. Zwei Dinge solltest du dir merken: Der eingebaute Webserver `php -S` ist ausschließlich für die lokale Entwicklung gedacht und gehört niemals produktiv ins Netz, weil er keinerlei Härtung oder Lastfestigkeit bietet. Und `-r` bzw. `-B`/`-R` führen beliebigen PHP-Code aus – gib solche Einzeiler also nie aus ungeprüften Quellen weiter und prüfe, was du ausführst.

## Weiterführende Links

- [PHP-Handbuch: Die Kommandozeilen-Schnittstelle](https://www.php.net/manual/de/features.commandline.php) – offizielle deutschsprachige Dokumentation zur PHP-CLI
- [PHP-Handbuch: Eingebauter Webserver](https://www.php.net/manual/de/features.commandline.webserver.php) – Details und Sicherheitshinweise zu `php -S`
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [artisan](https://www.jpkc.com/db/cheatsheets/build-languages/artisan/) – Kommandozeilen-Werkzeug des Laravel-Frameworks
- [cargo](https://www.jpkc.com/db/cheatsheets/build-languages/cargo/) – Paketmanager und Build-Tool für Rust
- [composer](https://www.jpkc.com/db/cheatsheets/build-languages/composer/) – Abhängigkeits-Manager für PHP-Projekte