PHP 7.1.0 Released

Executando arquivos PHP

Existem três formas de fornecer código PHP para ser executado pelo CLI SAPI:

  1. Diga ao PHP para executar determinado arquivo.

    $ php my_script.php
    
    $ php -f my_script.php
    

    As duas formas (usando ou não a opção -f ) executam o arquivo my_script.php. Note que não existe restrição sobre quais arquivos podem ser executados; em particular, o nome do arquivo não precisa conter a extensão .php.

    Nota:

    Caso argumentos precisem ser passados para o script ao usar -f , o primeiro argumento deve ser --.

  2. Passa o código PHP diretamente através da linha de comando.

    $ php -r 'print_r(get_defined_constants());'
    

    Um cuidado especial deve ser tomado em relação a substituição de variáveis e o uso de aspas.

    Nota:

    Leia o exemplo cuidadosamente: não existem tags de abertura e fechamento! A opção -r simplesmente não necessita delas, e usá-las irá gerar um erro de interpretação.

  3. Direciona a entrada padrão (stdin) para o código PHP.

    Isso dá a poderosa habilidade de criar código PHP dinamicanente e alimentar o binário, assim como demonstrado nesse exemplo fictício:

    $ some_application | some_filter | php | sort -u > final_output.txt
    
Você não pode combinar essas formas de executar o código.

Assim como qualquer aplicação de linha de comando, o PHP aceita qualquer quantidade argumentos; entretanto, os scripts PHP também podem receber outros argumentos. A quantidade de argumentos que podem ser passados para o script não é limitada pelo PHP (e apesar do shell ter um limite no número de caracteres que podem ser passados, ele não é geralmente atingido). Os argumentos passados para o scripts ficam disponíveis no array global $argv. O primeiro índice (zero) sempre contém o nome do script que está sendo chamado pela linha de comando. Note que, se o código é executado diretamente usando a opção de linha de comando -r , o valor de $argv[0] será somente um hífen (-). O mesmo é verdadeiro se o código e redirecionado pelo STDIN.

Uma segunda variável global, $argc, contém o número de elementos contidos no array$argv array (não o número de argumentos passados para o script).

Desde que os argumentos passados pelo script não comecem com o caractere -, não existe nada em especial com que você deva se preocupar. Passar um argumento para o script que comece com - irá causar problemas, porque o interpretador do PHP irá pensar que ele mesmo deve manipular esse argumento, mesmo antes de executar o script. Para prevenir isso use o separador de lista de argumentos --. Depois que esse separador é interpretado pelo PHP, cada argumento seguinte e passado intocado para o script.

# This will not execute the given code but will show the PHP usage
$ php -r 'var_dump($argv);' -h
Usage: php [options] [-f] <file> [args...]
[...]

# This will pass the '-h' argument to the script and prevent PHP from showing its usage
$ php -r 'var_dump($argv);' -- -h
array(2) {
  [0]=>
  string(1) "-"
  [1]=>
  string(2) "-h"
}

Entretanto, em sistemas Unix existe uma outra maneira de usar o PHP em linha de comando: fazer com que a primeira linha do script comece com #!/usr/bin/php (ou qualquer que seja o caminho para o binário do PHP CLI caso seja diferente. O restante do arquivo deve conter código PHP normal com as já tradicionais tags de abertura e fechamento. Uma vez que os atributos de execução do arquivo estejam apropriadamente definidos (exemplo. chmod +x test), o script poderá ser executado como qualquer outro script shell ou perl:

Exemplo #1 Executando scripts PHP como shell scripts

#!/usr/bin/php
<?php
var_dump
($argv);
?>

Assumindo que esse arquivo tenha o nome test no diretório atual, é possível fazer o seguinte:

$ chmod +x test
$ ./test -h -- foo
array(4) {
  [0]=>
  string(6) "./test"
  [1]=>
  string(2) "-h"
  [2]=>
  string(2) "--"
  [3]=>
  string(3) "foo"
}

Como pode ser visto, nesse caso nenhum cuidado especial precisa ser tomado ao passar parâmetros começando com -.

O executável do PHP pode ser usado para rodar scripts absolutamente independetes do servidor web. Em sistemas Unix, a primeira linha especial #! (ou "shebang") deve ser adicionada a sripts PHP para que o sistema possa automaticamente dizer qual programa deve executar o script. Em plataformas Windows, é possível associar o php.exe com um clique duplo no arquivos com extensão .php, ou um arquivo batch pode ser criado para rodar scripts através do PHP. A primeira linha especial shebang para Unix não causa nenhum efeito no Windows (Já que é formatada como um comentário PHP), então programas multiplataforma podem ser escritos com a inclusão disso. Um exemplo simples de programa de linha de comando em PHP é mostrado abaixo.

Exemplo #2 Script planejado para ser executado na linha de comando (script.php)

#!/usr/bin/php
<?php

if ($argc != || in_array($argv[1], array('--help''-help''-h''-?'))) {
?>

This is a command line PHP script with one option.

  Usage:
  <?php echo $argv[0]; ?> <option>

  <option> can be some word you would like
  to print out. With the --help, -help, -h,
  or -? options, you can get this help.

<?php
} else {
    echo 
$argv[1];
}
?>

O script acima inclui a shebang na primeira linha para indicar que esse arquivo deve ser executado pelo PHP. Nos estámos trabalhando com a versão CLI aqui, então nenhum cabeçalho HTTP será exibido.

O programa primeiramente verifica se o primeiro argumento obrigatório foi passado (juntamente com o nome do arquivo, que também é contabilizado). Em caso negativo, ou caso o argumento seja --help , -help , -h ou -? , uma mensagem de ajuda é disparada, usando $argv[0] para imprimir dinamicamente o nome do script como foi digitado na linha de comando. Do contrário, o argumento é exibido da forma como foi escrito.

Para executar o script acima em sistemas Unix, ele deve ser tornado executável, e chamado simplesmente com script.php echothis ou script.php -h. Em sistemas Windows, um arquivo batch similar ao seguinte pode ser criado para essa tarefa:

Exemplo #3 Arquivo batch para rodar um script de linha de comando em PHP (script.bat)

@echo OFF
"C:\php\php.exe" script.php %*

Assumindo que o programa acima foi nomeado como script.php, e que o CLI php.exe está em C:\php\php.exe, esse arquivo batch irá executá-lo, repassando todas as opções: script.bat echothis ou script.bat -h.

Veja também a documentação da extensão Readline com mais funções usadas para melhorar as aplicações de linha de comando em PHP.

No Windows,o PHP pode ser configurado para rodar sem a necessidade de informar o C:\php\php.exe ou a extensão.php, como descrito em PHP para linha de comando no Microsoft Windows.

add a note add a note

User Contributed Notes 7 notes

up
29
php at richardneill dot org
3 years ago
On Linux, the shebang (#!) line is parsed by the kernel into at most two parts.
For example:

1:  #!/usr/bin/php
2:  #!/usr/bin/env  php
3:  #!/usr/bin/php -n
4:  #!/usr/bin/php -ddisplay_errors=E_ALL
5:  #!/usr/bin/php -n -ddisplay_errors=E_ALL

1. is the standard way to start a script. (compare "#!/bin/bash".)

2. uses "env" to find where PHP is installed: it might be elsewhere in the $PATH, such as /usr/local/bin.

3. if you don't need to use env, you can pass ONE parameter here. For example, to ignore the system's PHP.ini, and go with the defaults, use "-n". (See "man php".)

4.  or, you can set exactly one configuration variable. I recommend this one, because display_errors actually takes effect if it is set here. Otherwise, the only place you can enable it is system-wide in php.ini. If you try to use ini_set() in your script itself, it's too late: if your script has a parse error, it will silently die.

5. This will not (as of 2013) work on Linux. It acts as if the whole string, "-n -ddisplay_errors=E_ALL" were a single argument. But in BSD, the shebang line can take more than 2 arguments, and so it may work as intended.

Summary: use (2) for maximum portability, and (4) for maximum debugging.
up
8
spencer at aninternetpresence dot net
5 years ago
If you are running the CLI on Windows and use the "-r" option, be sure to enclose your PHP code in double (not single) quotes. Otherwise, your code will not run.
up
7
petruzanautico at yah00 dot com dot ar
5 years ago
As you can't use -r and -f together, you can circumvent this by doing the following:
php -r '$foo = 678; include("your_script.php");'
up
1
david at frankieandshadow dot com
4 months ago
A gotcha when using #!/usr/bin/php at the start of the file as noted above:

if you originally edited the file on Windows and then attempt to use it on Unix, it won't work because the #! line requires a Unix line ending. Bash gives you the following error message if it has DOS line endings:
"bash: /usr/local/bin/wpreplace.php: /usr/bin/php^M: bad interpreter: No such file or directory"

(In Emacs I used "CTRL-X ENTER f" then type "unix" and ENTER to convert)
up
0
gabriel at figdice dot org
5 days ago
Regarding shebang:

In both Linux and Windows, when you execute a script in CLI with:

    php script.php

then PHP will ignore the very first line of your script if it starts with:

    #!

So, this line is not only absorbed by the kernel when the script file is executable, but it is also ignored by the PHP engine itself.

However, the engine will NOT ignore the first #! line of any included files withing your "outer" script.php.
Any "shebang" line in an included script, will result in simply outputting the line to STDOUT, just as any other text residing outside a <?php ...  ?> block.
up
-2
gar37bic at gmail dot com
8 months ago
For Linux and similar, the actual path to php may differ according to the particular distribution's layout.  Sometimes it is in /usr/local/bin/php, sometimes /usr/bin/php, and even /home/user/bin/php.  So #/usr/bin/php may need to be changed.

But there is an alternative:  Use #/usr/bin/env php instead.  This uses the environmental setup, and will ordinarily find PHP in one of your $PATH locations, searching down the path to the first hit. (At least I think that's how it works.)  If your CLI script will be run in different environments on different machines, this allows it to work without changes.  I believe this also works on BSD (which also means MacOS?) but I don't have one around any more to confirm.
up
-13
andrew-by at hotmail dot com
5 years ago
If you want your batch file's window stay opened after executing the PHP script just add "pause" at the last line. So it should look like:

@echo OFF
"C:\php\php.exe" script.php %*
pause
To Top