PHP
Kommandoradsgränssnitt (CLI)

Argumenthantering

Argument överförs till programmet på ett sätt som liknar de flesta språk i C-stil. $argc är ett heltal som innehåller antalet argument inklusive programnamnet, och $argv är en matris som innehåller argument till programmet. Det första elementet i $argv är namnet på programmet.

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

Att ringa ovanstående applikation med php example.php foo bar (där example.php innehåller ovanstående kod) kommer att resultera i följande utgång:

Du kallade programmet exempel.php med två argument
Argument 1 är foo
Argument 2 är bar

Observera att $argc och $argv är globala variabler, inte superglobalvariabler. De måste importeras till det lokala omfånget med hjälp av det global nyckelordet om de behövs i en funktion.

Det här exemplet visar hur argument grupperas när rymningar som "" eller \ används.

Exempel manus

var_dump($argc, $argv);

Kommandorad

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

Om PHP-skriptet körs med -r :

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

Eller kod pipade in i STDIN för php :

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

Ingångs- och utgångshantering

När de körs från CLI är konstanterna STDIN , STDOUT och STDERR fördefinierade. Dessa konstanter är filhandtag och kan betraktas som likvärdiga med resultaten för att köra följande kommandon:

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

Konstanterna kan användas var som helst som ett standardfilhandtag skulle vara:

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

Den inbyggda strömadressen som tidigare nämnts ( php://stdin , php://stdout och php://stderr ) kan användas i stället för filnamn i de flesta sammanhang:

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

Som ett alternativ kan du också använda readline () för inmatning, och du kan också använda eko eller utskrift eller andra strängutskriftsfunktioner för utdata.

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

Returkoder

Utgångskonstruktionen kan användas för att skicka en returkod till den exekverande miljön.

#!/usr/bin/php

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

Som standard returneras en utgångskod på 0 om ingen tillhandahålls, dvs exit är densamma som exit(0) . Eftersom exit inte är en funktion krävs inte parenteser om ingen returkod ges.

Returkoder måste ligga inom intervallet 0 till 254 (255 är reserverat av PHP och ska inte användas). Som en konvention, avslutar med en returkod på 0 berättar det ringande programmet att PHP-skriptet kördes framgångsrikt. Använd en returkod utan noll för att berätta det samtalande programmet att ett specifikt feltillstånd inträffade.

Hantera programalternativ

Programalternativ kan hanteras med getopt() -funktionen. Det fungerar med en liknande syntax som POSIX getopt kommandot, med ytterligare stöd för långa alternativ i 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

Det här skriptet kan testas så:

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

Observera att den sista metoden inte fungerar eftersom -v 5 inte är giltig.

Obs: Från PHP getopt är getopt operativsystemoberoende och fungerar också på Windows.

Begränsa skriptutförandet till kommandoraden

Funktionen php_sapi_name() och konstanten PHP_SAPI båda typen av gränssnitt ( S erver API ) som används av PHP. De kan användas för att begränsa exekveringen av ett skript till kommandoraden genom att kontrollera om utgången från funktionen är lika med cli .

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

drupal_is_cli() är ett exempel på en funktion som upptäcker om ett skript har körts från kommandoraden:

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

Kör ditt manus

På antingen Linux / UNIX eller Windows kan ett skript skickas som ett argument till den PHP-körbara, med det skriptets alternativ och argument följande:

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

Detta passerar foo och bar som argument till example.php .

På Linux / UNIX är den föredragna metoden att köra skript att använda en shebang (t.ex. #!/usr/bin/env php ) som den första raden i en fil och ställa in den körbara biten i filen. Förutsatt att skriptet är på din väg kan du sedan ringa det direkt:

example.php foo bar

Att använda /usr/bin/env php gör att PHP kan köras med PATH. Efter hur PHP installeras kanske det inte finns på samma plats (som /usr/bin/php eller /usr/local/bin/php ), till skillnad från env som vanligtvis finns från /usr/bin/env .

På Windows kan du ha samma resultat genom att lägga till PHP: s katalog och ditt skript till PATH och redigera PATHEXT för att tillåta .php att upptäckas med PATH. En annan möjlighet är att lägga till en fil med namnet example.bat eller example.cmd i samma katalog som ditt PHP-skript och skriva den här raden i den:

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

Eller om du har lagt till PHP: s katalog i PATH för bekväm användning:

php "%~dp0example.php" %*

Beteende skillnader på kommandoraden

När du kör från CLI uppvisar PHP vissa beteenden än när de körs från en webbserver. Dessa skillnader bör komma ihåg, särskilt när samma skript kan köras från båda miljöerna.

• Ingen katalogändring När du kör ett skript från en webbserver är den aktuella katalogen för arbetet alltid den för själva skriptet. Koden require("./stuff.inc"); antar att filen finns i samma katalog som skriptet. På kommandoraden är den nuvarande arbetskatalogen den katalog du befinner dig i när du ringer skriptet. Skript som kommer att anropas från kommandoraden bör alltid använda absoluta sökvägar. (Observera att __DIR__ och __FILE__ fortsätter att fungera som förväntat och returnera platsen för skriptet.)
• Ingen utgångsbuffring php.ini direktiven output_buffering och implicit_flush standard till false respektive true . Buffring är fortfarande tillgänglig, men måste vara uttryckligen aktiverad, annars visas alltid output i realtid.
• Ingen tidsgräns php.ini direktivet max_execution_time är inställt på noll, så skript kommer inte att avbrytas som standard.
• Inga HTML-fel Om du har aktiverat php.ini direktivet html_errors , ignoreras det på kommandoraden.
• Olika php.ini kan laddas . När du använder php från cli kan den använda olika php.ini än webbservern gör. Du kan veta vilken fil som används genom att köra php --ini .

Kör inbyggd webbserver

Från version 5.4 kommer PHP med inbyggd server. Det kan användas för att köra applikationer utan att behöva installera annan http-server som nginx eller apache. Den inbyggda servern är utformad endast i kontrollmiljö för utvecklings- och teständamål.

Det kan köras med kommandot php -S:

För att testa den skapar du index.php fil som innehåller

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

och kör kommandot php -S localhost:8080

Nu borde du kunna se innehåll i webbläsaren. För att kontrollera detta navigerar du till http://localhost:8080

Varje åtkomst bör resultera i loggpost skrivet till terminalen

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

Kanten fall av getopt ()

Detta exempel visar getopt beteende när användarinmatningen är ovanligt:

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

Från detta exempel kan man se att:

• Enskilda alternativ (ingen kolon) har alltid ett booleskt värde av false om det är aktiverat.
• Om ett alternativ upprepas blir respektive värde i utgången från getopt en matris.
• Obligatoriska argumentalternativ (en kolon) accepterar ett utrymme eller inget utrymme (som valfritt argumentalternativ) som separator
• Efter ett argument som inte kan mappas till några alternativ kommer alternativen bakom inte heller att kartläggas.