Running PHP script from the command line
How can I run a PHP script from the command line using the PHP interpreter which is used to parse web scripts? I have a phpinfo.php file which is accessed from the web shows that German is installed. However, if I run the phpinfo.php from the command line using — php phpinfo.php and grep for German , I don’t find it. So both PHP files are different. I need to run a script which the php on which German is installed. How can I do this?
Please add more details about installed web server software, for example add output from phpinfo(); to your question. Also updated my answer.
3 Answers 3
You should check your server configuration files. Look for lines that start with LoadModule php . There probably are configuration files/directories named mods or something like that. Start from there.
You could also check output from php -r ‘phpinfo();’ | grep php and compare lines to phpinfo(); from web server.
To run php interactively:
(So you can paste/write code in the console.)
To make it parse a file and output to the console:
Parse a file and output to another file:
php -f file.php > results.html Do you need something else?
To run only a small part, one line or like, you can use:
php -r '$x = "Hello World"; echo "$x\n";' If you are running Linux then do man php at the console.
If you need/want to run PHP through fpm (FastCGI Process Manager), use cli fcgi:
SCRIPT_NAME="file.php" SCRIP_FILENAME="file.php" REQUEST_METHOD="GET" cgi-fcgi -bind -connect "/var/run/php-fpm/php-fpm.sock" Where /var/run/php-fpm/php-fpm.sock is your php-fpm socket file.
No. The problem is that there are multiple phps on the system. I need to find out which php is used to parse web scripts. If I run php from the console then it can’t find a class — but if I call that script from the web then that problem isn’t there. So it means that the PHP which is used are different, isn’t it?
@Siddharth You should check that from your server s/w configuration. Add your server details to question.
In linux, you can use which php to tell you which executable you are running by default. To use another executable, you must specify the full path to the executable you wish to use: /path/to/specific/php -f file.php > results.html
nice detail, +1 for explanation. Just here to comment, be watch with the environment vars, maybe you need to use the complete directory path even when the script is in the same directory that php.exe
On SUSE Linux, there are two different configuration files for PHP: one for Apache, and one for CLI (command line interface). In the /etc/php5/ directory, you will find an «apache2» directory and a «cli» directory. Each has a «php.ini» file. The files are for the same purpose (PHP configuration), but apply to the two different ways of running PHP. These files, among other things, load the modules PHP uses.
If your OS is similar, then these two files are probably not the same. Your Apache php.ini is probably loading the German module, while the the CLI php.ini isn’t. When the module was installed (auto or manual), it probably only updated the Apache php.ini file.
You could simply copy the Apache php.ini file over into the cli directory to make the CLI environment exactly like the Apache environment.
Or, you could find the line that loads the German module in the Apache file and copy/paste just it to the CLI file.
Running PHP code/scripts on the command line
I just began learning PHP. I’ve installed php5 on Linux and wrote very simple code just to get going. How can I run scripts? I tried using the -f option, but it works as a cat command and just spits out the code to standard output. The interactive interpreter option works fine. Is a web browser the only way to execute a PHP script?
If you are here (from a search engine hit) looking for a way to run PHP source directly from the command line (like a Perl one-liner), then go to Stack Overflow question How can I execute PHP code from the command line?. (It is the -r option)
4 Answers 4
If it is acting like cat, then you probably forgot to switch out of template mode and into script mode with
Shorter way for command line:
php -r ‘echo «Hello «; echo «Jay»;’
OR
php -r ‘echo dirname(«parent/child/reply») . «\n»;’
As already mentioned, you can execute your PHP with the following.
If you wish to pass an argument(s), you can simply do so like this:
In your PHP file you can use this argument by accessing the $argv array like this:
The above would print our «I like Apples». Note the array index is 1 and not 0. 0 is used for script name. In this case $argv would be «myScript.php»
Actually, PHP’s main purpose is to generate web pages, but there are at least two other options:
The first one can be achieved in many ways (eg. by giving proper permissions to the file and calling script by providing its URI, eg. ./index.php ), the second one can be invoked by php -a command (as stated in the documentation mentioned above).
Linux php run file
- Tell PHP to execute a certain file.
$ php my_script.php $ php -f my_script.php
$ php -r 'print_r(get_defined_constants());'
Note: Read the example carefully: there are no beginning or ending tags! The -r switch simply does not need them, and using them will lead to a parse error.
$ some_application | some_filter | php | sort -u > final_output.txt
As with every shell application, the PHP binary accepts a number of arguments; however, the PHP script can also receive further arguments. The number of arguments that can be passed to your script is not limited by PHP (and although the shell has a limit to the number of characters which can be passed, this is not in general likely to be hit). The arguments passed to the script are available in the global array $argv . The first index (zero) always contains the name of the script as called from the command line. Note that, if the code is executed in-line using the command line switch -r, the value of $argv[0] will be «Standard input code» ; prior to PHP 7.2.0, it was a dash ( «-» ) instead. The same is true if the code is executed via a pipe from STDIN .
A second global variable, $argc , contains the number of elements in the $argv array (not the number of arguments passed to the script).
As long as the arguments to be passed to the script do not start with the — character, there’s nothing special to watch out for. Passing an argument to the script which starts with a — will cause trouble because the PHP interpreter thinks it has to handle it itself, even before executing the script. To prevent this, use the argument list separator — . After this separator has been parsed by PHP, every following argument is passed untouched to the script.
# This will not execute the given code but will show the PHP usage $ php -r 'var_dump($argv);' -h Usage: php [options] [-f] [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" >
However, on Unix systems there’s another way of using PHP for shell scripting: make the first line of the script start with #!/usr/bin/php (or whatever the path to your PHP CLI binary is if different). The rest of the file should contain normal PHP code within the usual PHP starting and end tags. Once the execution attributes of the file are set appropriately (e.g. chmod +x test), the script can be executed like any other shell or perl script:
Example #1 Execute PHP script as shell script
Assuming this file is named test in the current directory, it is now possible to do the following:
$ chmod +x test $ ./test -h -- foo array(4) < [0]=>string(6) "./test" [1]=> string(2) "-h" [2]=> string(2) "--" [3]=> string(3) "foo" >
As can be seen, in this case no special care needs to be taken when passing parameters starting with — .
The PHP executable can be used to run PHP scripts absolutely independent of the web server. On Unix systems, the special #! (or «shebang») first line should be added to PHP scripts so that the system can automatically tell which program should run the script. On Windows platforms, it’s possible to associate php.exe with the double click option of the .php extension, or a batch file can be created to run scripts through PHP. The special shebang first line for Unix does no harm on Windows (as it’s formatted as a PHP comment), so cross platform programs can be written by including it. A simple example of writing a command line PHP program is shown below.
Example #2 Script intended to be run from command line (script.php)
if ( $argc != 2 || in_array ( $argv [ 1 ], array( ‘—help’ , ‘-help’ , ‘-h’ , ‘-?’ ))) ?>
This is a command line PHP script with one option.
can be some word you would like
to print out. With the —help, -help, -h,
or -? options, you can get this help.
The script above includes the Unix shebang first line to indicate that this file should be run by PHP. We are working with a CLI version here, so no HTTP headers will be output.
The program first checks that there is the required one argument (in addition to the script name, which is also counted). If not, or if the argument was —help, -help, -h or -?, the help message is printed out, using $argv[0] to dynamically print the script name as typed on the command line. Otherwise, the argument is echoed out exactly as received.
To run the above script on Unix, it must be made executable, and called simply as script.php echothis or script.php -h. On Windows, a batch file similar to the following can be created for this task:
Example #3 Batch file to run a command line PHP script (script.bat)
@echo OFF "C:\php\php.exe" script.php %*
Assuming the above program is named script.php , and the CLI php.exe is in C:\php\php.exe , this batch file will run it, passing on all appended options: script.bat echothis or script.bat -h.
See also the Readline extension documentation for more functions which can be used to enhance command line applications in PHP.
On Windows, PHP can be configured to run without the need to supply the C:\php\php.exe or the .php extension, as described in Command Line PHP on Microsoft Windows.
Note:
On Windows it is recommended to run PHP under an actual user account. When running under a network service certain operations will fail, because «No mapping between account names and security IDs was done».
User Contributed Notes 7 notes
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.