PHP
Befehlszeilenschnittstelle (CLI)

Argumentbehandlung

Argumente werden ähnlich wie die meisten C-Sprachen an das Programm übergeben. $argc ist eine ganze Zahl, die die Anzahl der Argumente einschließlich des Programmnamens enthält, und $argv ist ein Array, das Argumente für das Programm enthält. Das erste Element von $argv ist der Name des Programms.

#!/usr/bin/php

printf("You called the program %s with %d arguments\n", $argv[0], $argc - 1);
unset($argv[0]);
foreach ($argv as $i => $arg) {
    printf("Argument %d is %s\n", $i, $arg);
}

Das Aufrufen der obigen Anwendung mit php example.php foo bar (wobei example.php den obigen Code enthält) führt zu folgender Ausgabe:

Sie haben das Programm example.php mit 2 Argumenten aufgerufen
Argument 1 ist foo
Argument 2 ist bar

Beachten Sie, dass $argc und $argv globale Variablen sind, keine superglobalen Variablen. Sie müssen mit dem global Schlüsselwort in den lokalen Bereich importiert werden, wenn sie in einer Funktion benötigt werden.

Dieses Beispiel zeigt, wie Argumente gruppiert werden, wenn Escape-Zeichen wie "" oder \ verwendet werden.

Beispielskript

var_dump($argc, $argv);

Befehlszeile

$ php argc.argv.php --this-is-an-option three\ words\ together or "in one quote"     but\ multiple\ spaces\ counted\ as\ one
int(6)
array(6) {
  [0]=>
  string(13) "argc.argv.php"
  [1]=>
  string(19) "--this-is-an-option"
  [2]=>
  string(20) "three words together"
  [3]=>
  string(2) "or"
  [4]=>
  string(12) "in one quote"
  [5]=>
  string(34) "but multiple spaces counted as one"
}

Wenn das PHP-Skript mit -r :

$ php -r 'var_dump($argv);'
array(1) {
  [0]=>
  string(1) "-"
}

Oder Code in STDIN von php :

$ echo '<?php var_dump($argv);' | php
array(1) {
  [0]=>
  string(1) "-"
}

Eingabe- und Ausgabeverarbeitung

Bei Ausführung über die CLI sind die Konstanten STDIN , STDOUT und STDERR vordefiniert. Diese Konstanten sind Dateihandles und können den Ergebnissen der Ausführung der folgenden Befehle als äquivalent angesehen werden:

STDIN = fopen("php://stdin", "r");
STDOUT = fopen("php://stdout", "w");
STDERR = fopen("php://stderr", "w");

Die Konstanten können überall dort verwendet werden, wo ein Standard-Dateihandle wäre:

#!/usr/bin/php

while ($line = fgets(STDIN)) {
    $line = strtolower(trim($line));
    switch ($line) {
        case "bad":
            fprintf(STDERR, "%s is bad" . PHP_EOL, $line);
            break;
        case "quit":
            exit;
        default:
            fprintf(STDOUT, "%s is good" . PHP_EOL, $line);
            break;
    }
}

Die eingebauten Stream-Adressen, auf die zuvor verwiesen wurde ( php://stdin , php://stdout und php://stderr ), können in den meisten Kontexten anstelle von Dateinamen verwendet werden:

file_put_contents('php://stdout', 'This is stdout content');
file_put_contents('php://stderr', 'This is stderr content');

// Open handle and write multiple times.
$stdout = fopen('php://stdout', 'w');

fwrite($stdout, 'Hello world from stdout' . PHP_EOL);
fwrite($stdout, 'Hello again');

fclose($stdout);

Alternativ können Sie auch readline () für die Eingabe verwenden, und Sie können auch Echo oder Drucken oder beliebige andere Zeichenfolgen-Druckfunktionen für die Ausgabe verwenden.

$name = readline("Please enter your name:");
print "Hello, {$name}.";

Rückgabecodes

Das Exit- Konstrukt kann verwendet werden, um einen Rückkehrcode an die Ausführungsumgebung zu übergeben.

#!/usr/bin/php

if ($argv[1] === "bad") {
    exit(1);
} else {
    exit(0);
}

Standardmäßig wird ein Exit-Code von 0 zurückgegeben, wenn keiner angegeben wird. exit exit(0) . Da exit keine Funktion ist, sind keine Klammern erforderlich, wenn kein Rückkehrcode übergeben wird.

Rückkehrcodes müssen im Bereich von 0 bis 254 liegen (255 sind von PHP reserviert und sollten nicht verwendet werden). Das Beenden mit einem Rückgabewert von 0 teilt dem aufrufenden Programm mit, dass das PHP-Skript erfolgreich ausgeführt wurde. Verwenden Sie einen Rückgabecode ungleich Null, um dem aufrufenden Programm mitzuteilen, dass eine bestimmte Fehlerbedingung aufgetreten ist.

Programmoptionen behandeln

Programmoptionen können mit der Funktion getopt() werden. Es arbeitet mit einer ähnlichen Syntax wie der POSIX-Befehl " getopt und unterstützt zusätzlich lange Optionen im GNU-Stil.

#!/usr/bin/php

// a single colon indicates the option takes a value
// a double colon indicates the value may be omitted
$shortopts = "hf:v::d";
// GNU-style long options are not required
$longopts = ["help", "version"];
$opts = getopt($shortopts, $longopts);

// options without values are assigned a value of boolean false
// you must check their existence, not their truthiness
if (isset($opts["h"]) || isset($opts["help"])) {
    fprintf(STDERR, "Here is some help!\n");
    exit;
}

// long options are called with two hyphens: "--version"
if (isset($opts["version"])) {
    fprintf(STDERR, "%s Version 223.45" . PHP_EOL, $argv[0]);
    exit;
}

// options with values can be called like "-f foo", "-ffoo", or "-f=foo"
$file = "";
if (isset($opts["f"])) {
    $file = $opts["f"];
}
if (empty($file)) {
    fprintf(STDERR, "We wanted a file!" . PHP_EOL);
    exit(1);
}
fprintf(STDOUT, "File is %s" . PHP_EOL, $file);

// options with optional values must be called like "-v5" or "-v=5"
$verbosity = 0;
if (isset($opts["v"])) {
    $verbosity = ($opts["v"] === false) ? 1 : (int)$opts["v"];
}
fprintf(STDOUT, "Verbosity is %d" . PHP_EOL, $verbosity);

// options called multiple times are passed as an array
$debug = 0;
if (isset($opts["d"])) {
    $debug = is_array($opts["d"]) ? count($opts["d"]) : 1;
}
fprintf(STDOUT, "Debug is %d" . PHP_EOL, $debug);

// there is no automated way for getopt to handle unexpected options

Dieses Skript kann wie folgt getestet werden:

./test.php --help
./test.php --version
./test.php -f foo -ddd
./test.php -v -d -ffoo
./test.php -v5 -f=foo
./test.php -f foo -v 5 -d

Beachten Sie, dass die letzte Methode nicht funktioniert, da -v 5 nicht gültig ist.

Hinweis: getopt ist seit PHP 5.3.0 unabhängig vom Betriebssystem und funktioniert auch unter Windows.

Schränken Sie die Skriptausführung auf die Befehlszeile ein

Die Funktion php_sapi_name() und die Konstante PHP_SAPI beide geben die Art der Schnittstelle (S erver API) , die von PHP verwendet wird. Sie können verwendet werden, um die Ausführung eines Skripts auf die Befehlszeile zu beschränken, indem Sie prüfen, ob die Ausgabe der Funktion gleich cli .

if (php_sapi_name() === 'cli') {
    echo "Executed from command line\n";
} else {
    echo "Executed from web browser\n";
}

Die Funktion drupal_is_cli() ist ein Beispiel für eine Funktion, die erkennt, ob ein Skript über die Befehlszeile ausgeführt wurde:

function drupal_is_cli() {
    return (!isset($_SERVER['SERVER_SOFTWARE']) && (php_sapi_name() == 'cli' || (is_numeric($_SERVER['argc']) && $_SERVER['argc'] > 0)));
}

Führen Sie Ihr Skript aus

Unter Linux / UNIX oder Windows kann ein Skript als Argument an die ausführbare PHP-Datei übergeben werden. Die Optionen und Argumente dieses Skripts lauten:

php ~/example.php foo bar
c:\php\php.exe c:\example.php foo bar

Damit werden foo und bar als Argumente an example.php .

Unter Linux / UNIX wird als bevorzugte Methode zum Ausführen von Skripts ein Shebang (z. B. #!/usr/bin/env php ) als erste Zeile einer Datei verwendet und das ausführbare Bit in der Datei festgelegt. Wenn sich das Skript in Ihrem Pfad befindet, können Sie es direkt aufrufen:

example.php foo bar

Wenn Sie /usr/bin/env php wird die ausführbare PHP-Datei mithilfe des PFADs gefunden. Nach der Installation von PHP befindet sich das Programm möglicherweise nicht an derselben Stelle (z. B. /usr/bin/php oder /usr/local/bin/php ), anders als bei env das normalerweise unter /usr/bin/env verfügbar ist.

Unter Windows können Sie dasselbe Ergebnis erzielen, indem Sie das Verzeichnis von PHP und Ihr Skript zum PATH hinzufügen und PATHEXT bearbeiten, um zu ermöglichen, dass .php mithilfe des PATH erkannt wird. Eine andere Möglichkeit ist, eine Datei mit dem Namen example.bat oder example.cmd im selben Verzeichnis wie Ihr PHP-Skript hinzuzufügen und diese Zeile darin zu schreiben:

c:\php\php.exe "%~dp0example.php" %*

Wenn Sie das Verzeichnis PHP in PATH hinzugefügt haben, können Sie es bequem verwenden:

php "%~dp0example.php" %*

Verhaltensunterschiede in der Befehlszeile

Beim Ausführen über die CLI zeigt PHP einige andere Verhaltensweisen als bei der Ausführung auf einem Webserver. Diese Unterschiede sollten beachtet werden, insbesondere wenn das gleiche Skript in beiden Umgebungen ausgeführt wird.

• Keine Verzeichnisänderung Wenn Sie ein Skript von einem Webserver ausführen, ist das aktuelle Arbeitsverzeichnis immer das des Skripts selbst. Der Code require("./stuff.inc"); geht davon aus, dass sich die Datei im selben Verzeichnis wie das Skript befindet. In der Befehlszeile ist das aktuelle Arbeitsverzeichnis das Verzeichnis, in dem Sie sich befinden, wenn Sie das Skript aufrufen. Skripts, die von der Befehlszeile aus aufgerufen werden, sollten immer absolute Pfade verwenden. (Beachten Sie, dass die magischen Konstanten __DIR__ und __FILE__ weiterhin wie erwartet funktionieren und die Position des Skripts zurückgeben.)
• Keine Ausgabepufferung Die php.ini Direktiven output_buffering und implicit_flush standardmäßig auf false bzw. true . Die Pufferung ist weiterhin verfügbar, muss jedoch explizit aktiviert werden, andernfalls wird die Ausgabe immer in Echtzeit angezeigt.
• Keine php.ini Die php.ini Direktive max_execution_time ist auf null gesetzt, sodass für Skripts standardmäßig kein php.ini max_execution_time .
• Keine HTML-Fehler php.ini Sie die php.ini Direktive html_errors , wird sie in der Befehlszeile ignoriert.
• Verschiedene php.ini können geladen werden . Wenn Sie php von cli verwenden, kann es andere php.ini als der Webserver verwenden. Sie können wissen, welche Datei verwendet wird, indem Sie php --ini .

Eingebauter Webserver ausführen

Ab Version 5.4 ist PHP mit einem integrierten Server ausgestattet. Es kann verwendet werden, um Anwendungen auszuführen, ohne dass andere http-Server wie nginx oder apache installiert werden müssen. Der eingebaute Server ist nur in der Controller-Umgebung für Entwicklungs- und Testzwecke konzipiert.

Es kann mit dem Befehl php -S ausgeführt werden:

Um es zu testen, erstellen Sie eine index.php Datei mit

<?php
echo "Hello World from built-in PHP server";

und führen Sie den Befehl php -S localhost:8080

Jetzt sollten Sie den Inhalt im Browser sehen können. Um dies zu überprüfen, navigieren Sie zu http://localhost:8080

Jeder Zugriff sollte dazu führen, dass der Protokolleintrag in das Terminal geschrieben wird

[Mon Aug 15 18:20:19 2016] ::1:52455 [200]: /

Randfälle von getopt ()

Dieses Beispiel zeigt das Verhalten von getopt wenn die Benutzereingaben ungewöhnlich sind:

var_dump(
    getopt("ab:c::", ["delta", "epsilon:", "zeta::"])
);

$ php getopt.php -a -a -bbeta -b beta -cgamma --delta --epsilon --zeta --zeta=f  -c gamma
array(6) {
  ["a"]=>
  array(2) {
    [0]=>
    bool(false)
    [1]=>
    bool(false)
  }
  ["b"]=>
  array(2) {
    [0]=>
    string(4) "beta"
    [1]=>
    string(4) "beta"
  }
  ["c"]=>
  array(2) {
    [0]=>
    string(5) "gamma"
    [1]=>
    bool(false)
  }
  ["delta"]=>
  bool(false)
  ["epsilon"]=>
  string(6) "--zeta"
  ["zeta"]=>
  string(1) "f"
}

Aus diesem Beispiel ist ersichtlich, dass:

• Einzelne Optionen (kein Doppelpunkt) tragen immer den booleschen Wert false wenn sie aktiviert sind.
• Wenn eine Option wiederholt wird, wird der entsprechende Wert in der Ausgabe von getopt zu einem Array.
• Erforderliche Argumentoptionen (ein Doppelpunkt) akzeptieren ein Leerzeichen oder kein Leerzeichen (wie optionale Argumentoptionen) als Trennzeichen
• Nach einem Argument, das keiner Option zugeordnet werden kann, werden auch die Optionen dahinter nicht zugeordnet.