php — Die PHP-Kommandozeile

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.

Skripte ausführen

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

php script.php

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

php -f migrate.php

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

php -r 'echo PHP_VERSION . PHP_EOL;'

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

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

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

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

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

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).

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.

php -S localhost:8000

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

php -S localhost:8000 -t public/

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

php -S 0.0.0.0:8000

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

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+).

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.

php -l index.php

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

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.

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.

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.

php -v

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

php -i

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

php -i | grep memory_limit

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

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

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

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

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

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.

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

Erweiterungen & Module

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

php -m

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

php -m | grep mbstring

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

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

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

php --re json

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

php --ri opcache

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

php -d extension=xdebug script.php

Konfiguration überschreiben

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

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.

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.

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.

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).

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.

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

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

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

Code-Analyse & Debugging

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

php -w verbose-script.php

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

php --rf array_map

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

php --rc DateTime

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

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

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

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

Einzeiler & Datenverarbeitung

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

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

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

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

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

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

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

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

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

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.

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

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

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.

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.

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

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

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.

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.

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.

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).

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.

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

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

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).

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

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 – offizielle deutschsprachige Dokumentation zur PHP-CLI
PHP-Handbuch: Eingebauter Webserver – Details und Sicherheitshinweise zu php -S