PHP
Command Line Interface (CLI)

Argumentafhandeling

Argumenten worden op dezelfde manier doorgegeven aan het programma als de meeste talen in C-stijl. $argc is een geheel getal dat het aantal argumenten bevat, inclusief de programmanaam, en $argv is een array met argumenten voor het programma. Het eerste element van $argv is de naam van het programma.

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

Het aanroepen van de bovenstaande applicatie met php example.php foo bar (waar example.php de bovenstaande code bevat) zal resulteren in de volgende uitvoer:

U noemde het programma example.php met 2 argumenten
Argument 1 is foo
Argument 2 is balk

Merk op dat $argc en $argv globale variabelen zijn, geen superglobal-variabelen. Ze moeten in het lokale bereik worden geïmporteerd met het global trefwoord als ze nodig zijn in een functie.

Dit voorbeeld laat zien hoe argumenten worden gegroepeerd wanneer escapes zoals "" of \ worden gebruikt.

Voorbeeld script

var_dump($argc, $argv);

Opdrachtregel

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

Als het PHP-script wordt uitgevoerd met -r :

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

Of code in STDIN van php :

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

Input en output handling

Wanneer de CLI wordt uitgevoerd, zijn de constanten STDIN , STDOUT en STDERR vooraf gedefinieerd. Deze constanten zijn bestandshandles en kunnen als gelijkwaardig worden beschouwd aan de resultaten van het uitvoeren van de volgende opdrachten:

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

De constanten kunnen overal worden gebruikt waar een standaard bestandsingang zou kunnen zijn:

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

De ingebouwde streamadressen waarnaar eerder werd verwezen ( php://stdin , php://stdout en php://stderr ) kunnen in de meeste contexten worden gebruikt in plaats van bestandsnamen:

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

Als alternatief kunt u ook readline () gebruiken voor invoer en u kunt ook echo of afdrukken of andere tekenreeksafdrukfuncties gebruiken voor uitvoer.

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

Retourcodes

De exit- constructie kan worden gebruikt om een retourcode door te geven aan de uitvoerende omgeving.

#!/usr/bin/php

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

Standaard wordt een exitcode van 0 geretourneerd als er geen wordt opgegeven, dwz exit is hetzelfde als exit(0) . Aangezien exit geen functie is, zijn haakjes niet vereist als er geen retourcode wordt doorgegeven.

Retourcodes moeten tussen 0 en 254 liggen (255 is gereserveerd door PHP en mag niet worden gebruikt). Volgens afspraak, uitstappen met een return code van 0 vertelt het oproepende programma dat de PHP-script liep met succes. Gebruik een niet-nul retourcode om het aanroepende programma te vertellen dat er een specifieke fout is opgetreden.

Omgaan met programma-opties

Programma-opties kunnen worden afgehandeld met de functie getopt() . Het werkt met een soortgelijke syntaxis als de opdracht POSIX getopt , met extra ondersteuning voor lange opties in GNU-stijl.

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

Dit script kan als volgt worden getest:

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

Merk op dat de laatste methode niet werkt omdat -v 5 niet geldig is.

Opmerking: vanaf PHP 5.3.0 is getopt onafhankelijk van het besturingssysteem en werkt het ook op Windows.

Beperk scriptuitvoering tot opdrachtregel

De functie php_sapi_name() en de constante PHP_SAPI beide het type interface ( S erver API ) dat door PHP wordt gebruikt. Ze kunnen worden gebruikt om de uitvoering van een script te beperken tot de opdrachtregel, door te controleren of de uitvoer van de functie gelijk is aan cli .

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

De functie drupal_is_cli() is een voorbeeld van een functie die detecteert of een script is uitgevoerd vanaf de opdrachtregel:

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

Uw script uitvoeren

Op Linux / UNIX of Windows kan een script als argument worden doorgegeven aan het uitvoerbare PHP, met de opties en argumenten van dat script als volgt:

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

Dit geeft foo en bar als argumenten door aan example.php .

Op Linux / UNIX is de voorkeursmethode voor het uitvoeren van scripts het gebruik van een shebang (bijvoorbeeld #!/usr/bin/env php ) als de eerste regel van een bestand en stelt u het uitvoerbare bit in op het bestand. Ervan uitgaande dat het script op uw pad ligt, kunt u het direct aanroepen:

example.php foo bar

Met /usr/bin/env php wordt het PHP-uitvoerbare bestand gevonden met behulp van de PATH. In navolging van de manier waarop PHP is geïnstalleerd, bevindt deze zich mogelijk niet op dezelfde plaats (zoals /usr/bin/php of /usr/local/bin/php ), in tegenstelling tot env dat gewoonlijk beschikbaar is via /usr/bin/env .

In Windows zou u hetzelfde resultaat kunnen hebben door de directory van de PHP en uw script aan de PATH toe te voegen en PATHEXT te bewerken zodat .php kan worden gedetecteerd met behulp van de PATH. Een andere mogelijkheid is om een bestand met de naam example.bat of example.cmd toe te voegen in dezelfde map als je PHP-script en deze regel erin te schrijven:

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

Of, als u de directory van PHP aan het PATH hebt toegevoegd, voor handig gebruik:

php "%~dp0example.php" %*

Gedragsverschillen op de opdrachtregel

Bij het uitvoeren vanaf de CLI vertoont PHP een ander gedrag dan wanneer het wordt uitgevoerd vanaf een webserver. Deze verschillen moeten in gedachten worden gehouden, vooral in het geval waarin hetzelfde script vanuit beide omgevingen kan worden uitgevoerd.

• Geen directorywijziging Bij het uitvoeren van een script vanaf een webserver is de huidige werkmap altijd die van het script zelf. De code require("./stuff.inc"); gaat ervan uit dat het bestand zich in dezelfde map bevindt als het script. Op de opdrachtregel is de huidige werkmap de map waarin u zich bevindt wanneer u het script aanroept. Scripts die vanaf de opdrachtregel worden aangeroepen, moeten altijd absolute paden gebruiken. (Let op de magische constanten __DIR__ en __FILE__ blijven werken zoals verwacht, en retourneren de locatie van het script.)
• Geen uitvoerbuffering De php.ini richtlijnen output_buffering en implicit_flush standaard respectievelijk false en true . Buffering is nog steeds beschikbaar, maar moet expliciet zijn ingeschakeld, anders wordt de uitvoer altijd in realtime weergegeven.
• Geen tijdslimiet De php.ini instructie max_execution_time is ingesteld op nul, zodat scripts niet standaard een time-out krijgen.
• Geen HTML-fouten Als u de php.ini instructie html_errors hebt ingeschakeld, wordt deze genegeerd op de opdrachtregel.
• Verschillende php.ini kunnen worden geladen . Wanneer u php van cli gebruikt, kan het andere php.ini dan webserver. U kunt weten welk bestand wordt gebruikt door php --ini .

Ingebouwde webserver uitvoeren

Vanaf versie 5.4 wordt PHP geleverd met een ingebouwde server. Het kan worden gebruikt om toepassingen uit te voeren zonder dat een andere http-server zoals nginx of apache hoeft te worden geïnstalleerd. Ingebouwde server is alleen ontworpen in controlleromgeving voor ontwikkeling en testdoeleinden.

Het kan worden uitgevoerd met opdracht php -S:

Maak een index.php bestand met om het te testen

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

en voer opdracht php -S localhost:8080

Nu zou je de inhoud in de browser moeten kunnen zien. Om dit te controleren, navigeert u naar http://localhost:8080

Elke toegang moet resulteren in logboekinvoer naar terminal

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

Edge Cases van getopt ()

Dit voorbeeld toont het gedrag van getopt wanneer de gebruikersinvoer ongewoon is:

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

Uit dit voorbeeld blijkt dat:

• Individuele opties (geen dubbele punt) hebben altijd een Booleaanse waarde false als deze is ingeschakeld.
• Als een optie wordt herhaald, wordt de respectieve waarde in de uitvoer van getopt een array.
• Vereiste argumentopties (één dubbele punt) accepteren één spatie of geen spatie (zoals optionele argumentopties) als scheidingsteken
• Na een argument dat niet kan worden toegewezen aan opties, worden de opties erachter ook niet toegewezen.