PHP
Interface de ligne de commande (CLI)

codeigniter HTML JavaScript jQuery Laravel MySQL Regular Expressions SQL symfony2 WordPress
Recherche…


Traitement des arguments

Les arguments sont transmis au programme d'une manière similaire à la plupart des langages de style C. $argc est un entier contenant le nombre d'arguments incluant le nom du programme, et $argv est un tableau contenant des arguments pour le programme. Le premier élément de $argv est le nom du programme. 

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

L'appel de l'application ci-dessus avec php example.php foo bar (où example.php contient le code ci-dessus) produira la sortie suivante:

Vous avez appelé le programme example.php avec 2 arguments
L'argument 1 est foo
L'argument 2 est la barre

Notez que $argc et $argv sont des variables globales, pas des variables super globales. Ils doivent être importés dans la portée locale en utilisant le mot-clé global s'ils sont nécessaires dans une fonction.

Cet exemple montre comment les arguments sont regroupés lorsque des échappements tels que "" ou \ sont utilisés.

Exemple de script 

var_dump($argc, $argv);

Ligne de commande 

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

Si le script PHP est exécuté avec -r : 

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

Ou un code redirigé vers STDIN de php : 

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

Gestion des entrées et des sorties

Lorsqu'elles sont exécutées à partir de la CLI, les constantes STDIN , STDOUT et STDERR sont prédéfinies. Ces constantes sont des descripteurs de fichiers et peuvent être considérées comme équivalentes aux résultats de l'exécution des commandes suivantes: 

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

Les constantes peuvent être utilisées partout où un descripteur de fichier standard serait: 

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

Les adresses de flux intégrées référencées précédemment ( php://stdin , php://stdout et php://stderr ) peuvent être utilisées à la place des noms de fichiers dans la plupart des contextes: 

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

Comme alternative, vous pouvez également utiliser readline () pour la saisie, et vous pouvez également utiliser l' écho ou l' impression ou toute autre fonction d'impression de chaîne pour la sortie. 

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

Codes de retour

La construction d' exit peut être utilisée pour transmettre un code de retour à l'environnement d'exécution. 

#!/usr/bin/php

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

Par défaut, un code de sortie de 0 sera renvoyé si aucun code n'est fourni, c'est-à-dire que exit est identique à exit(0) . Comme exit n'est pas une fonction, les parenthèses ne sont pas requises si aucun code de retour n'est transmis.

Les codes de retour doivent être compris entre 0 et 254 (255 est réservé par PHP et ne doit pas être utilisé). Par convention, sortir avec un code retour de 0 indique au programme appelant que le script PHP a été exécuté avec succès. Utilisez un code retour différent de zéro pour indiquer au programme appelant qu'une condition d'erreur spécifique s'est produite.

Gestion des options du programme

Les options du programme peuvent être gérées avec la fonction getopt() . Il fonctionne avec une syntaxe similaire à la commande POSIX getopt , avec un support supplémentaire pour les options longues de style 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

Ce script peut être testé comme ceci: 

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

Notez que la dernière méthode ne fonctionnera pas car -v 5 n'est pas valide.

Note: Depuis PHP 5.3.0, getopt est indépendant du système d'exploitation, fonctionnant également sous Windows.

Restreindre l'exécution du script à la ligne de commande

La fonction php_sapi_name() et la constante PHP_SAPI deux renvoient le type d'interface (S API erver) qui est utilisé par PHP. Ils peuvent être utilisés pour restreindre l'exécution d'un script à la ligne de commande, en vérifiant si la sortie de la fonction est égale à cli . 

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

La fonction drupal_is_cli() est un exemple de fonction qui détecte si un script a été exécuté à partir de la ligne de commande: 

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

Lancer votre script

Sous Linux / UNIX ou Windows, un script peut être transmis en tant qu'argument à l'exécutable PHP, avec les options et arguments suivants: 

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

Cela passe foo et bar comme arguments à example.php .

Sous Linux / UNIX, la méthode préférée pour exécuter des scripts consiste à utiliser un shebang (par exemple #!/usr/bin/env php ) comme première ligne d'un fichier et à définir le bit exécutable sur le fichier. En supposant que le script est sur votre chemin, vous pouvez l'appeler directement: 

example.php foo bar

L'utilisation de /usr/bin/env php permet de trouver l'exécutable PHP à l'aide du PATH. Après l'installation de PHP, il se peut qu'il ne soit pas situé au même endroit (par exemple /usr/bin/php ou /usr/local/bin/php ), contrairement à env qui est généralement disponible à partir de /usr/bin/env .

Sous Windows, vous pouvez obtenir le même résultat en ajoutant le répertoire PHP et votre script au PATH et en modifiant PATHEXT pour permettre à .php d'être détecté à l'aide du PATH. Une autre possibilité est d'ajouter un fichier nommé example.bat ou example.cmd dans le même répertoire que votre script PHP et d'y écrire cette ligne: 

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

Ou, si vous avez ajouté le répertoire PHP dans PATH, pour une utilisation pratique: 

php "%~dp0example.php" %*

Différences comportementales sur la ligne de commande

Lors de l'exécution à partir de la CLI, PHP présente différents comportements que lorsqu'il est exécuté à partir d'un serveur Web. Ces différences doivent être prises en compte, en particulier dans le cas où le même script peut être exécuté à partir des deux environnements.

  • Aucun changement de répertoire Lorsque vous exécutez un script à partir d'un serveur Web, le répertoire de travail actuel est toujours celui du script lui-même. Le code require("./stuff.inc"); suppose que le fichier se trouve dans le même répertoire que le script. Sur la ligne de commande, le répertoire de travail actuel est le répertoire dans lequel vous vous trouvez lorsque vous appelez le script. Les scripts qui vont être appelés depuis la ligne de commande doivent toujours utiliser des chemins absolus. (Notez que les constantes magiques __DIR__ et __FILE__ continuent à fonctionner comme prévu et renvoient l'emplacement du script.)
  • Pas de mise en mémoire tampon des sorties Les directives php.ini output_buffering et implicit_flush output_buffering par défaut sur false et true , respectivement. La mise en mémoire tampon est toujours disponible, mais doit être explicitement activée, sinon la sortie sera toujours affichée en temps réel.
  • Aucune limite de temps La directive php.ini max_execution_time est définie sur zéro, donc les scripts ne seront pas expirés par défaut.
  • Aucune erreur HTML Si vous avez activé la directive php.ini html_errors , celle-ci sera ignorée sur la ligne de commande.
  • Différents php.ini peuvent être chargés . Lorsque vous utilisez php from cli, il peut utiliser différents php.ini que le serveur Web. Vous pouvez savoir quel fichier utilise en exécutant php --ini .

Serveur Web intégré en cours d'exécution

A partir de la version 5.4, PHP est livré avec un serveur intégré. Il peut être utilisé pour exécuter une application sans avoir besoin d'installer un autre serveur http tel que nginx ou apache. Le serveur intégré est conçu uniquement dans l'environnement du contrôleur à des fins de développement et de test.

Il peut être exécuté avec la commande php -S:

Pour le tester, créez le fichier index.php contenant 

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

et lancez la commande php -S localhost:8080

Maintenant, vous devriez être capable de voir le contenu dans le navigateur. Pour le vérifier, accédez à http://localhost:8080

Chaque accès doit aboutir à une entrée de journal écrite sur le terminal 

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

Cas de bord de getopt ()

Cet exemple montre le comportement de getopt lorsque l'entrée utilisateur est rare:

getopt.php 
var_dump(
    getopt("ab:c::", ["delta", "epsilon:", "zeta::"])
);
Ligne de commande shell 
$ 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"
}

De cet exemple, on peut voir que:

  • Les options individuelles (pas de deux points) portent toujours une valeur booléenne false si cette option est activée.
  • Si une option est répétée, la valeur respective dans la sortie de getopt deviendra un tableau.
  • Les options d'argument requises (un deux-points) acceptent un espace ou aucun espace (comme les options d'argument optionnelles) comme séparateur
  • Après un argument qui ne peut être associé à aucune option, les options ne seront pas mappées non plus.


Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow