PHP
Interfejs wiersza poleceń (CLI)

Obsługa argumentów

Argumenty są przekazywane do programu w sposób podobny do większości języków w stylu C. $argc jest liczbą całkowitą zawierającą liczbę argumentów, w tym nazwę programu, a $argv to tablica zawierająca argumenty dla programu. Pierwszym elementem $argv jest nazwa programu.

#!/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);
}

Wywołanie powyższej aplikacji za pomocą php example.php foo bar (gdzie example.php zawiera powyższy kod) da następujące wyniki:

Wywołałeś program example.php z 2 argumentami
Argument 1 jest foo
Argument 2 to bar

Zauważ, że $argc i $argv są zmiennymi globalnymi, a nie zmiennymi superglobalnymi. Muszą zostać zaimportowane do zasięgu lokalnego za pomocą global słowa kluczowego, jeśli są potrzebne w funkcji.

Ten przykład pokazuje, w jaki sposób argumenty są grupowane, gdy używane są znaki specjalne, takie jak "" lub \ .

Przykładowy skrypt

var_dump($argc, $argv);

Wiersz poleceń

$ 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"
}

Jeśli skrypt PHP jest uruchamiany przy użyciu opcji -r :

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

Lub kod przesłany do STDIN php :

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

Obsługa danych wejściowych i wyjściowych

Po uruchomieniu z interfejsu CLI stałe STDIN , STDOUT i STDERR są predefiniowane. Te stałe są uchwytami plików i można je uznać za równoważne z wynikami uruchomienia następujących poleceń:

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

Stałe mogą być używane wszędzie tam, gdzie standardowy uchwyt pliku byłby:

#!/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;
    }
}

Wbudowane adresy strumieni, o których wcześniej wspomniano ( php://stdin , php://stdout i php://stderr ) mogą być używane zamiast nazw plików w większości kontekstów:

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

Alternatywnie, możesz również użyć readline () do wprowadzania danych, a także możesz użyć echa lub drukowania lub innych funkcji drukowania ciągów dla wyjścia.

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

Kody zwrotne

Konstrukcja wyjściowa może być użyta do przekazania kodu powrotu do środowiska wykonawczego.

#!/usr/bin/php

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

Domyślnie kod wyjścia 0 zostanie zwrócony, jeśli nie zostanie podany, tzn. exit jest takie samo jak exit(0) . Ponieważ exit nie jest funkcją, nawiasy nie są wymagane, jeśli nie zostanie przekazany kod powrotu.

Kody zwrotne muszą zawierać się w przedziale od 0 do 254 (255 jest zarezerwowane przez PHP i nie należy ich używać). Zgodnie z konwencją wyjście z kodem powrotu równym 0 informuje program wywołujący, że skrypt PHP działał poprawnie. Użyj niezerowego kodu powrotu, aby poinformować program wywołujący, że wystąpił określony warunek błędu.

Obsługa opcji programu

Opcje programu można obsługiwać za pomocą funkcji getopt() . Działa z podobną składnią jak polecenie getopt POSIX, z dodatkową obsługą długich opcji w stylu GNU.

#!/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

Ten skrypt można przetestować w następujący sposób:

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

Uwaga: ostatnia metoda nie będzie działać, ponieważ -v 5 jest niepoprawna.

Uwaga: Od PHP 5.3.0 getopt jest niezależny od systemu operacyjnego i działa również w systemie Windows.

Ogranicz wykonywanie skryptu do wiersza poleceń

Funkcja php_sapi_name() a stałe PHP_SAPI zwracają typu interfejsu (S erwerze API), który jest używany przez PHP. Można ich użyć do ograniczenia wykonywania skryptu do wiersza poleceń poprzez sprawdzenie, czy wynik funkcji jest równy cli .

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

Funkcja drupal_is_cli() jest przykładem funkcji, która wykrywa, czy skrypt został wykonany z wiersza poleceń:

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

Uruchamianie skryptu

W systemie Linux / UNIX lub Windows skrypt można przekazać jako argument do pliku wykonywalnego PHP, a opcje i argumenty tego skryptu są następujące:

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

To przekazuje foo i bar jako argumenty do example.php .

W Linux / UNIX preferowaną metodą uruchamiania skryptów jest użycie shebang (np. #!/usr/bin/env php ) jako pierwszego wiersza pliku i ustawienie bitu wykonywalnego na pliku. Zakładając, że skrypt znajduje się na twojej ścieżce, możesz wywołać go bezpośrednio:

example.php foo bar

Użycie /usr/bin/env php powoduje, że plik wykonywalny PHP można znaleźć za pomocą PATH. Po zainstalowaniu PHP może nie znajdować się w tym samym miejscu (takim jak /usr/bin/php lub /usr/local/bin/php ), w przeciwieństwie do env który jest powszechnie dostępny z /usr/bin/env .

W systemie Windows można uzyskać ten sam wynik, dodając katalog PHP i skrypt do ŚCIEŻKI oraz edytując ŚCIEŻKĘ, aby umożliwić wykrycie pliku .php przy użyciu ŚCIEŻKI. Inną możliwością jest dodanie pliku o nazwie example.bat lub example.cmd w tym samym katalogu co skrypt PHP i zapisanie w nim tej linii:

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

Lub, jeśli dodałeś katalog PHP do ŚCIEŻKI, dla wygody:

php "%~dp0example.php" %*

Różnice behawioralne w wierszu poleceń

Podczas uruchamiania z interfejsu CLI PHP wykazuje inne zachowania niż podczas uruchamiania z serwera WWW. Należy pamiętać o tych różnicach, szczególnie w przypadku, gdy ten sam skrypt można uruchomić z obu środowisk.

• Bez zmiany katalogu Podczas uruchamiania skryptu z serwera WWW bieżącym katalogiem roboczym jest zawsze katalog samego skryptu. Kod require("./stuff.inc"); zakłada, że plik znajduje się w tym samym katalogu co skrypt. W wierszu poleceń bieżący katalog roboczy to katalog, w którym znajdujesz się podczas wywoływania skryptu. Skrypty, które będą wywoływane z wiersza poleceń, zawsze powinny używać ścieżek bezwzględnych. (Uwaga: magiczne stałe __DIR__ i __FILE__ nadal działają zgodnie z oczekiwaniami i zwracają lokalizację skryptu).
• Brak buforowania danych wyjściowych Dyrektywy php.ini output_buffering i implicit_flush domyślnie mają odpowiednio wartość false i true . Buforowanie jest nadal dostępne, ale musi być wyraźnie włączone, w przeciwnym razie dane wyjściowe będą zawsze wyświetlane w czasie rzeczywistym.
• Brak limitu czasu Dyrektywa php.ini max_execution_time jest ustawiona na zero, więc skrypty domyślnie nie przekroczą limitu czasu .
• Brak błędów HTML W przypadku włączenia dyrektywy php.ini html_errors , zostanie ona zignorowana w wierszu poleceń.
• Można załadować różne php.ini . Kiedy używasz php z cli, może używać innego php.ini niż serwer WWW. Możesz wiedzieć, jakiego pliku używa, uruchamiając php --ini .

Uruchamianie wbudowanego serwera WWW

Od wersji 5.4 PHP posiada wbudowany serwer. Można go używać do uruchamiania aplikacji bez potrzeby instalowania innego serwera http, takiego jak nginx lub apache. Wbudowany serwer jest zaprojektowany tylko w środowisku kontrolera do celów programistycznych i testowych.

Można go uruchomić za pomocą komendy php -S:

Aby to przetestować, utwórz plik index.php zawierający

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

i uruchom polecenie php -S localhost:8080

Teraz powinieneś być w stanie zobaczyć zawartość w przeglądarce. Aby to sprawdzić, przejdź do http://localhost:8080

Każdy dostęp powinien skutkować zapisaniem dziennika w terminalu

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

Edge Cases of getopt ()

Ten przykład pokazuje zachowanie getopt gdy dane wejściowe użytkownika są rzadkie:

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"
}

Z tego przykładu widać, że:

• Poszczególne opcje (bez dwukropka) zawsze mają wartość logiczną false jeśli jest włączona.
• Jeśli opcja się powtórzy, odpowiednia wartość na wyjściu getopt stanie się tablicą.
• Wymagane opcje argumentów (jeden dwukropek) akceptują jedną spację lub brak spacji (jak opcjonalne opcje argumentów) jako separator
• Po jednym argumencie, którego nie można zmapować na żadną opcję, opcje za nim również nie zostaną zmapowane.