PHP
Interfaz de línea de comandos (CLI)

Manejo de argumentos

Los argumentos se pasan al programa de manera similar a la mayoría de los lenguajes de estilo C. $argc es un número entero que contiene el número de argumentos, incluido el nombre del programa, y $argv es una matriz que contiene argumentos para el programa. El primer elemento de $argv es el nombre del programa.

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

Al llamar a la aplicación anterior con php example.php foo bar (donde example.php contiene el código anterior) se obtendrá el siguiente resultado:

Llamaste al programa example.php con 2 argumentos
Argumento 1 es foo
Argumento 2 es barra

Tenga en cuenta que $argc y $argv son variables globales, no variables superglobal. Deben importarse en el ámbito local utilizando la palabra clave global si se necesitan en una función.

Este ejemplo muestra cómo se agrupan los argumentos cuando se utilizan escapes como "" o \ .

Ejemplo de script

var_dump($argc, $argv);

Línea de comando

$ 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 el script PHP se ejecuta usando -r :

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

O el código canalizado en STDIN de php :

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

Manejo de entrada y salida

Cuando se ejecuta desde la CLI, las constantes STDIN , STDOUT y STDERR están predefinidas. Estas constantes son manejadores de archivos y pueden considerarse equivalentes a los resultados de ejecutar los siguientes comandos:

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

Las constantes se pueden usar en cualquier lugar donde un manejador de archivos estándar sea:

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

Las direcciones de flujo incorporadas a las que se hizo referencia anteriormente ( php://stdin , php://stdout y php://stderr ) se pueden usar en lugar de los nombres de archivo en la mayoría de los contextos:

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

Como alternativa, también puede usar readline () para la entrada, y también puede usar eco o imprimir o cualquier otra función de impresión de cadenas para la salida.

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

Códigos de retorno

La construcción de salida se puede usar para pasar un código de retorno al entorno de ejecución.

#!/usr/bin/php

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

Por defecto, se devolverá un código de salida de 0 si no se proporciona ninguno, es decir, la exit es la misma que la de exit(0) . Como exit no es una función, los paréntesis no son necesarios si no se pasa ningún código de retorno.

Los códigos de retorno deben estar en el rango de 0 a 254 (255 está reservado por PHP y no debe usarse). Por convención, salir con un código de retorno de 0 le dice al programa que llama que el script PHP se ejecutó correctamente. Utilice un código de retorno distinto de cero para indicar al programa que llama que se produjo una condición de error específica.

Opciones de programa de manejo

Las opciones del programa se pueden manejar con la función getopt() . Funciona con una sintaxis similar al comando POSIX getopt , con soporte adicional para las opciones largas de estilo 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

Este script puede ser probado como tal:

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

Tenga en cuenta que el último método no funcionará porque -v 5 no es válido.

Nota: A partir de PHP 5.3.0, getopt es un sistema operativo independiente, que también funciona en Windows.

Restrinja la ejecución del script a la línea de comando

La función php_sapi_name() y la constante PHP_SAPI devuelven el tipo de interfaz ( S erver API ) que está utilizando PHP. Se pueden usar para restringir la ejecución de un script a la línea de comando, verificando si la salida de la función es igual a cli .

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

La función drupal_is_cli() es un ejemplo de una función que detecta si un script se ha ejecutado desde la línea de comandos:

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

Ejecutando tu guion

En Linux / UNIX o Windows, se puede pasar un script como argumento al ejecutable de PHP, con las opciones y argumentos de ese script a continuación:

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

Esto pasa foo y bar como argumentos a example.php .

En Linux / UNIX, el método preferido para ejecutar scripts es usar un shebang (por ejemplo, #!/usr/bin/env php ) como la primera línea de un archivo, y establecer el bit ejecutable en el archivo. Suponiendo que el script está en su ruta, puede llamarlo directamente:

example.php foo bar

El uso de /usr/bin/env php hace que el ejecutable de PHP se encuentre utilizando el PATH. Siguiendo cómo se instala PHP, es posible que no se encuentre en el mismo lugar (como /usr/bin/php o /usr/local/bin/php ), a diferencia de env que normalmente está disponible en /usr/bin/env .

En Windows, puede obtener el mismo resultado al agregar el directorio de PHP y su secuencia de comandos a la RUTA y editar PATHEXT para permitir que se detecte .php utilizando la RUTA. Otra posibilidad es agregar un archivo llamado example.bat o example.cmd en el mismo directorio que su script PHP y escribir esta línea en él:

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

O, si agregó el directorio de PHP en el PATH, para un uso conveniente:

php "%~dp0example.php" %*

Diferencias de comportamiento en la línea de comando.

Cuando se ejecuta desde la CLI, PHP muestra algunos comportamientos diferentes que cuando se ejecuta desde un servidor web. Estas diferencias deben tenerse en cuenta, especialmente en el caso de que se pueda ejecutar el mismo script desde ambos entornos.

• Sin cambio de directorio Cuando se ejecuta un script desde un servidor web, el directorio de trabajo actual es siempre el del propio script. El código require("./stuff.inc"); asume que el archivo está en el mismo directorio que el script. En la línea de comandos, el directorio de trabajo actual es el directorio en el que se encuentra cuando llama al script. Los scripts que se van a llamar desde la línea de comandos siempre deben usar rutas absolutas. (Tenga en cuenta que las constantes mágicas __DIR__ y __FILE__ continúan funcionando como se esperaba y devuelven la ubicación del script).
• No hay salida de búfer las php.ini directivas output_buffering y implicit_flush por defecto a false y true , respectivamente. El almacenamiento en búfer todavía está disponible, pero debe habilitarse explícitamente, de lo contrario, la salida siempre se mostrará en tiempo real.
• Sin límite de tiempo La directiva php.ini max_execution_time se establece en cero, por lo que los scripts no se max_execution_time forma predeterminada.
• No hay errores de HTML En el caso de que haya habilitado la directiva php.ini html_errors , se ignorará en la línea de comandos.
• Se pueden cargar diferentes php.ini . Cuando está usando php desde cli, puede usar php.ini diferente al servidor web. Puede saber qué archivo está usando ejecutando php --ini .

Ejecutando servidor web incorporado

A partir de la versión 5.4, PHP viene con servidor incorporado. Puede utilizarse para ejecutar aplicaciones sin necesidad de instalar otro servidor http como nginx o apache. El servidor incorporado está diseñado solo en el entorno del controlador para fines de desarrollo y prueba.

Se puede ejecutar con el comando php -S:

Para probarlo cree el archivo index.php que contiene

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

y ejecute el comando php -S localhost:8080

Ahora debes poder ver el contenido en el navegador. Para verificar esto, navegue a http://localhost:8080

Cada acceso debe dar como resultado una entrada de registro escrita en el terminal

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

Edge Casos de getopt ()

Este ejemplo muestra el comportamiento de getopt cuando la entrada del usuario es poco común:

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

De este ejemplo, se puede ver que:

• Las opciones individuales (sin dos puntos) siempre tienen un valor booleano de false si están habilitadas.
• Si se repite una opción, el valor respectivo en la salida de getopt se convertirá en una matriz.
• Las opciones de argumento requeridas (una coma) aceptan un espacio o ningún espacio (como opciones de argumento opcionales) como separador
• Después de un argumento que no se puede asignar a ninguna opción, las opciones que se encuentran detrás tampoco se asignarán.