Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg

PHP : Features : Using PHP from the command line

Chapter 10. Using PHP from the command line

As of version 4.3.0, PHP supports a new SAPI type (Server Application Programming Interface) named CLI which means Command Line Interface. As the name implies, this SAPI type main focus is on developing shell (or desktop as well) applications with PHP. There are quite a few differences between the CLI SAPI and other SAPIs which are explained in this chapter. It's worth mentioning that CLI and CGI are different SAPI's although they do share many of the same behaviors.

The CLI SAPI was released for the first time with PHP 4.2.0, but was still experimental and had to be explicitly enabled with --enable-cli when running ./configure. Since PHP 4.3.0 the CLI SAPI is no longer experimental and the option --enable-cli is on by default. You may use --disable-cli to disable it.

As of PHP 4.3.0, the name, location and existence of the CLI/CGI binaries will differ depending on how PHP is installed on your system. By default when executing make, both the CGI and CLI are built and placed as sapi/cgi/php and sapi/cli/php respectively, in your PHP source directory. You will note that both are named php. What happens during make install depends on your configure line. If a module SAPI is chosen during configure, such as apxs, or the --disable-cgi option is used, the CLI is copied to {PREFIX}/bin/php during make install otherwise the CGI is placed there. So, for example, if --with--apxs is in your configure line then the CLI is copied to {PREFIX}/bin/php during make install. If you want to override the installation of the CGI binary, use make install-cli after make install. Alternatively you can specify --disable-cgi in your configure line.


Because both --enable-cli and --enable-cgi are enabled by default, simply having --enable-cli in your configure line does not necessarily mean the CLI will be copied as {PREFIX}/bin/php during make install.

The Windows packages between PHP 4.2.0 and PHP 4.2.3 distributed the CLI as php-cli.exe, living in the same folder as the CGI php.exe. Starting with PHP 4.3.0 the Windows package distributes the CLI as php.exe in a separate folder named cli, so cli/php.exe . Starting with PHP 5, the CLI is distributed in the main folder, named php.exe. The CGI version is distributed as php-cgi.exe.

As of PHP 5, a new php-win.exe file is distributed. This is equal to the CLI version, except that php-win doesn't output anything and thus provides no console (no "dos box" appears on the screen). This behavior is similar to php-gtk. You should configure with --enable-cli-win32.

What SAPI do I have?:

From a shell, typing php -v will tell you whether php is CGI or CLI. See also the function php_sapi_name() and the constant PHP_SAPI.


A Unix manual page was added in PHP 4.3.2. You may view this by typing man php in your shell environment.

Remarkable differences of the CLI SAPI compared to other SAPIs:

  • Unlike the CGI SAPI, no headers are written to the output.

    Though the CGI SAPI provides a way to suppress HTTP headers, there's no equivalent switch to enable them in the CLI SAPI.

    CLI is started up in quiet mode by default, though the -q and --no-header switches are kept for compatibility so that you can use older CGI scripts.

    It does not change the working directory to that of the script. (-C and --no-chdir switches kept for compatibility)

    Plain text error messages (no HTML formatting).

  • There are certain php.ini directives which are overridden by the CLI SAPI because they do not make sense in shell environments:

    Table 10.1. Overridden php.ini directives

    Directive CLI SAPI default value Comment
    html_errors FALSE It can be quite hard to read the error message in your shell when it's cluttered with all those meaningless HTML tags, therefore this directive defaults to FALSE.
    implicit_flush TRUE It is desired that any output coming from print(), echo() and friends is immediately written to the output and not cached in any buffer. You still can use output buffering if you want to defer or manipulate standard output.
    max_execution_time 0 (unlimited) Due to endless possibilities of using PHP in shell environments, the maximum execution time has been set to unlimited. Whereas applications written for the web are often executed very quickly, shell application tend to have a much longer execution time.
    register_argc_argv TRUE

    Because this setting is TRUE you will always have access to argc (number of arguments passed to the application) and argv (array of the actual arguments) in the CLI SAPI.

    As of PHP 4.3.0, the PHP variables $argc and $argv are registered and filled in with the appropriate values when using the CLI SAPI. Prior to this version, the creation of these variables behaved as they do in CGI and MODULE versions which requires the PHP directive register_globals to be on. Regardless of version or register_globals setting, you can always go through either $_SERVER or $HTTP_SERVER_VARS. Example: $_SERVER['argv']


    These directives cannot be initialized with another value from the configuration file php.ini or a custom one (if specified). This is a limitation because those default values are applied after all configuration files have been parsed. However, their value can be changed during runtime (which does not make sense for all of those directives, e.g. register_argc_argv).

  • To ease working in the shell environment, the following constants are defined:

    Table 10.2. CLI specific Constants

    Constant Description

    An already opened stream to stdin. This saves opening it with


    = fopen('php://stdin', 'r');


    If you want to read single line from stdin, you can use

    = trim(fgets(STDIN)); // reads one line from STDIN
    fscanf(STDIN, "%d\n", $number); // reads number from STDIN


    An already opened stream to stdout. This saves opening it with


    = fopen('php://stdout', 'w');



    An already opened stream to stderr. This saves opening it with


    = fopen('php://stderr', 'w');


    Given the above, you don't need to open e.g. a stream for stderr yourself but simply use the constant instead of the stream resource:

    php -r 'fwrite(STDERR, "stderr\n");'

    You do not need to explicitly close these streams, as they are closed automatically by PHP when your script ends.

  • The CLI SAPI does not change the current directory to the directory of the executed script!

    Example showing the difference to the CGI SAPI:

    // Our simple test application named test.php
    echo getcwd(), "\n";

    When using the CGI version, the output is:

    $ pwd

    $ php -q another_directory/test.php

    This clearly shows that PHP changes its current directory to the one of the executed script.

    Using the CLI SAPI yields:

    $ pwd

    $ php -f another_directory/test.php

    This allows greater flexibility when writing shell tools in PHP.


    The CGI SAPI supports this CLI SAPI behaviour by means of the -C switch when run from the command line.

The list of command line options provided by the PHP binary can be queried anytime by running PHP with the -h switch:

Usage: php [options] [-f] <file> [--] [args...]
      php [options] -r <code> [--] [args...]
      php [options] [-B <begin_code>] -R <code> [-E <end_code>] [--] [args...]
      php [options] [-B <begin_code>] -F <file> [-E <end_code>] [--] [args...]
      php [options] -- [args...]
      php [options] -a

 -a               Run interactively
 -c <path>|<file> Look for php.ini file in this directory
 -n               No php.ini file will be used
 -d foo[=bar]     Define INI entry foo with value 'bar'
 -e               Generate extended information for debugger/profiler
 -f <file>        Parse and execute <file>.
 -h               This help
 -i               PHP information
 -l               Syntax check only (lint)
 -m               Show compiled in modules
 -r <code>        Run PHP <code> without using script tags <?..?>
 -B <begin_code>  Run PHP <begin_code> before processing input lines
 -R <code>        Run PHP <code> for every input line
 -F <file>        Parse and execute <file> for every input line
 -E <end_code>    Run PHP <end_code> after processing all input lines
 -H               Hide any passed arguments from external tools.
 -s               Display colour syntax highlighted source.
 -v               Version number
 -w               Display source with stripped comments and whitespace.
 -z <file>        Load Zend extension <file>.

 args...          Arguments passed to script. Use -- args when first argument
                  starts with - or script is read from stdin

 --ini            Show configuration file names

 --rf <name>      Show information about function <name>.
 --rc <name>      Show information about class <name>.
 --re <name>      Show information about extension <name>.
 --ri <name>      Show configuration for extension <name>.

The CLI SAPI has three different ways of getting the PHP code you want to execute:

  1. Telling PHP to execute a certain file.

    php my_script.php

    php -f my_script.php

    Both ways (whether using the -f switch or not) execute the file my_script.php. You can choose any file to execute - your PHP scripts do not have to end with the .php extension but can have any name or extension you wish.

  2. Pass the PHP code to execute directly on the command line.

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

    Special care has to be taken in regards of shell variable substitution and quoting usage.


    Read the example carefully, there are no beginning or ending tags! The -r switch simply does not need them. Using them will lead to a parser error.

  3. Provide the PHP code to execute via standard input (stdin).

    This gives the powerful ability to dynamically create PHP code and feed it to the binary, as shown in this (fictional) example:

    $ some_application | some_filter | php | sort -u >final_output.txt

You cannot combine any of the three ways to execute code.

Like every shell application, the PHP binary accepts a number of arguments but your PHP script can also receive arguments. The number of arguments which can be passed to your script is not limited by PHP (the shell has a certain size limit in the number of characters which can be passed; usually you won't hit this limit). The arguments passed to your script are available in the global array $argv. The zero index always contains the script name (which is - in case the PHP code is coming from either standard input or from the command line switch -r). The second registered global variable is $argc which contains the number of elements in the $argv array (not the number of arguments passed to the script).

As long as the arguments you want to pass to your script do not start with the - character, there's nothing special to watch out for. Passing an argument to your script which starts with a - will cause trouble because PHP itself thinks it has to handle it. To prevent this, use the argument list separator --. After this separator has been parsed by PHP, every argument following it is passed untouched to your 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 your script and prevent PHP from showing it's usage
$ php -r 'var_dump($argv);' -- -h
array(2) {
 string(1) "-"
 string(2) "-h"

However, there's another way of using PHP for shell scripting. You can write a script where the first line starts with #!/usr/bin/php. Following this you can place normal PHP code included within the PHP starting and end tags. Once you have set the execution attributes of the file appropriately (e.g. chmod +x test) your script can be executed like a normal shell or perl script:

Example 10.1. Execute PHP script as shell script


Assuming this file is named test in the current directory, we can now do the following:

$ chmod +x test
$ ./test -h -- foo
array(4) {
 string(6) "./test"
 string(2) "-h"
 string(2) "--"
 string(3) "foo"

As you see, in this case no care needs to be taken when passing parameters which start with - to your script.

Long options are available since PHP 4.3.3.

Table 10.3. Command line options

Option Long Option Description
-a --interactive

Runs PHP interactively. If you compile PHP with the Readline extension (which is not available on Windows), you'll have a nice shell, including a completion feature (e.g. you can start typing a variable name, hit the TAB key and PHP completes its name) and a typing history that can be accessed using the arrow keys. The history is saved in the ~/.php_history file.


Files included through auto_prepend_file and auto_append_file are parsed in this mode but with some restrictions - e.g. functions have to be defined before called.


Autoloading is not available if using PHP in CLI interactive mode.

-c --php-ini

This option can either specify a directory where to look for php.ini or specify a custom INI file (which does not need to be named php.ini), e.g.:

$ php -c /custom/directory/ my_script.php

$ php -c /custom/directory/custom-file.ini my_script.php

If you don't specify this option, file is searched in default locations.

-n --no-php-ini

Ignore php.ini at all. This switch is available since PHP 4.3.0.

-d --define

This option allows you to set a custom value for any of the configuration directives allowed in php.ini. The syntax is:

-d configuration_directive[=value]

Examples (lines are wrapped for layout reasons):

# Omitting the value part will set the given configuration directive to "1"
$ php -d max_execution_time
       -r '$foo = ini_get("max_execution_time"); var_dump($foo);'
string(1) "1"

# Passing an empty value part will set the configuration directive to ""
php -d max_execution_time=
       -r '$foo = ini_get("max_execution_time"); var_dump($foo);'
string(0) ""

# The configuration directive will be set to anything passed after the '=' character
$  php -d max_execution_time=20
       -r '$foo = ini_get("max_execution_time"); var_dump($foo);'
string(2) "20"
$  php
       -d max_execution_time=doesntmakesense
       -r '$foo = ini_get("max_execution_time"); var_dump($foo);'
string(15) "doesntmakesense"

-e --profile-info

Activate the extended information mode, to be used by a debugger/profiler.

-f --file

Parses and executed the given filename to the -f option. This switch is optional and can be left out. Only providing the filename to execute is sufficient.

-h and -? --help and --usage With this option, you can get information about the actual list of command line options and some one line descriptions about what they do.
-i --info This command line option calls phpinfo(), and prints out the results. If PHP is not working correctly, it is advisable to use php -i and see whether any error messages are printed out before or in place of the information tables. Beware that when using the CGI mode the output is in HTML and therefore quite huge.
-l --syntax-check

This option provides a convenient way to only perform a syntax check on the given PHP code. On success, the text No syntax errors detected in <filename> is written to standard output and the shell return code is 0. On failure, the text Errors parsing <filename> in addition to the internal parser error message is written to standard output and the shell return code is set to 255.

This option won't find fatal errors (like undefined functions). Use -f if you would like to test for fatal errors too.


This option does not work together with the -r option.

-m --modules

Using this option, PHP prints out the built in (and loaded) PHP and Zend modules:

$ php -m
[PHP Modules]

[Zend Modules]

-r --run

This option allows execution of PHP right from within the command line. The PHP start and end tags (<?php and ?>) are not needed and will cause a parser error if present.


Care has to be taken when using this form of PHP to not collide with command line variable substitution done by the shell.

Example showing a parser error

$ php -r "$foo = get_defined_constants();"
Command line code(1) : Parse error - parse error, unexpected '='

The problem here is that the sh/bash performs variable substitution even when using double quotes ". Since the variable $foo is unlikely to be defined, it expands to nothing which results in the code passed to PHP for execution actually reading:

$ php -r " = get_defined_constants();"

The correct way would be to use single quotes '. Variables in single-quoted strings are not expanded by sh/bash.

$ php -r '$foo = get_defined_constants(); var_dump($foo);'
array(370) {

If you are using a shell different from sh/bash, you might experience further issues. Feel free to open a bug report at » One can still easily run into troubles when trying to get shell variables into the code or using backslashes for escaping. You've been warned.


-r is available in the CLI SAPI and not in the CGI SAPI.


This option is meant for a very basic stuff. Thus some configuration directives (e.g. auto_prepend_file and auto_append_file) are ignored in this mode.

-B --process-begin

PHP code to execute before processing stdin. Added in PHP 5.

-R --process-code

PHP code to execute for every input line. Added in PHP 5.

There are two special variables available in this mode: $argn and $argi. $argn will contain the line PHP is processing at that moment, while $argi will contain the line number.

-F --process-file

PHP file to execute for every input line. Added in PHP 5.

-E --process-end

PHP code to execute after processing the input. Added in PHP 5.

Example 10.2. Using the -B, -R and -E options to count the number of lines of a project.

$ find my_proj | php -B '$l=0;' -R '$l += count(@file($argn));' -E 'echo "Total Lines: $l\n";'
Total Lines: 37328

-s --syntax-highlight and --syntax-highlight

Display colour syntax highlighted source.

This option uses the internal mechanism to parse the file and produces a HTML highlighted version of it and writes it to standard output. Note that all it does it to generate a block of <code> [...] </code> HTML tags, no HTML headers.


This option does not work together with the -r option.

-v --version

Writes the PHP, PHP SAPI, and Zend version to standard output, e.g.

$ php -v
PHP 4.3.0 (cli), Copyright (c) 1997-2002 The PHP Group
Zend Engine v1.3.0, Copyright (c) 1998-2002 Zend Technologies

-w --strip

Display source with stripped comments and whitespace.


This option does not work together with the -r option.

-z --zend-extension

Load Zend extension. If only a filename is given, PHP tries to load this extension from the current default library path on your system (usually specified /etc/ on Linux systems). Passing a filename with an absolute path information will not use the systems library search path. A relative filename with a directory information will tell PHP only to try to load the extension relative to the current directory.


Shows configuration file names and scanned directories. Available as of PHP 5.2.3.

Example 10.3. --ini example

$ php --ini
Configuration File (php.ini) Path: /usr/dev/php/5.2/lib
Loaded Configuration File:         /usr/dev/php/5.2/lib/php.ini
Scan for additional .ini files in: (none)
Additional .ini files parsed:      (none)

--rf --rfunction

Shows information about the given function or class method (e.g. number and name of the parameters). Available as of PHP 5.1.2.

This option is only available if PHP was compiled with Reflection support.

Example 10.4. basic --rf usage

$ php --rf var_dump
Function [ <internal> public function var_dump ] {

 - Parameters [2] {
   Parameter #0 [ <required> $var ]
   Parameter #1 [ <optional> $... ]

--rc --rclass

Show information about the given class (list of constants, properties and methods). Available as of PHP 5.1.2.

This option is only available if PHP was compiled with Reflection support.

Example 10.5. --rc example

$ php --rc Directory
Class [ <internal:standard> class Directory ] {

 - Constants [0] {

 - Static properties [0] {

 - Static methods [0] {

 - Properties [0] {

 - Methods [3] {
   Method [ <internal> public method close ] {

   Method [ <internal> public method rewind ] {

   Method [ <internal> public method read ] {

--re --rextension

Show information about the given extension (list of php.ini options, defined functions, constants and classes). Available as of PHP 5.1.2.

This option is only available if PHP was compiled with Reflection support.

Example 10.6. --re example

$ php --re json
Extension [ <persistent> extension #19 json version 1.2.1 ] {

 - Functions {
   Function [ <internal> function json_encode ] {
   Function [ <internal> function json_decode ] {

--ri --rextinfo

Shows the configuration information for the given extension (the same information that is returned by phpinfo()). Available as of PHP 5.2.2. The core configuration information are available using "main" as extension name.

Example 10.7. --ri example

$ php --ri date


date/time support => enabled
"Olson" Timezone Database Version => 2007.5
Timezone Database => internal
Default timezone => Europe/Oslo

Directive => Local Value => Master Value
date.timezone => Europe/Oslo => Europe/Oslo
date.default_latitude => 59.22482 => 59.22482
date.default_longitude => 11.018084 => 11.018084
date.sunset_zenith => 90.583333 => 90.583333
date.sunrise_zenith => 90.583333 => 90.583333

The PHP executable can be used to run PHP scripts absolutely independent from the web server. If you are on a Unix system, you should add a special first line to your PHP script, and make it executable, so the system will know, what program should run the script. On a Windows platform you can associate php.exe with the double click option of the .php files, or you can make a batch file to run the script through PHP. The first line added to the script to work on Unix won't hurt on Windows, so you can write cross platform programs this way. A simple example of writing a command line PHP program can be found below.

Example 10.8. 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.

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

} else {

In the script above, we used the special first line to indicate that this file should be run by PHP. We work with a CLI version here, so there will be no HTTP header printouts. There are two variables you can use while writing command line applications with PHP: $argc and $argv. The first is the number of arguments plus one (the name of the script running). The second is an array containing the arguments, starting with the script name as number zero ($argv[0]).

In the program above we checked if there are less or more than one arguments. Also if the argument was --help, -help, -h or -?, we printed out the help message, printing the script name dynamically. If we received some other argument we echoed that out.

If you would like to run the above script on Unix, you need to make it executable, and simply call it as script.php echothis or script.php -h. On Windows, you can make a batch file for this task:

Example 10.9. Batch file to run a command line PHP script (script.bat)

@C:\php\php.exe script.php %1 %2 %3 %4

Assuming you named the above program script.php, and you have your CLI php.exe in C:\php\php.exe this batch file will run it for you with your added options: script.bat echothis or script.bat -h.

See also the Readline extension documentation for more functions you can use to enhance your command line applications in PHP.

Code Examples / Notes » features.commandline

punk _at_ studionew _dot_ com

You can use this function to ask user to enter smth
function read ($length='255')
  if (!isset ($GLOBALS['StdinPointer']))
     $GLOBALS['StdinPointer'] = fopen ("php://stdin","r");
  $line = fgets ($GLOBALS['StdinPointer'],$length);
  return trim ($line);
// then
echo "Enter your name: ";
$name = read ();
echo "\nHello $name! Where you came from? ";
$where = read ();
echo "\nI see. $where is very good place.";


You can also call the script from the command line after chmod'ing the file (ie: chmod 755 file.php).
On your first line of the file, enter "#!/usr/bin/php" (or to wherever your php executable is located).  If you want to suppress the PHP headers, use the line of "#!/usr/bin/php -q" for your path.


While working with command line scripts it is tedious to handle the arguments in a numerated array.
The following code will:
If the argument is of the form –NAME=VALUE it will be represented in the array as an element with the key NAME and the value VALUE. I the argument is a flag of the form -NAME it will be represented as a boolean with the name NAME with a value of true in the associative array.
function arguments($argv) {
   $_ARG = array();
   foreach ($argv as $arg) {
       if (ereg('--[a-zA-Z0-9]*=.*',$arg)) {
           $str = split("=",$arg); $arg = '';
           $key = ereg_replace("--",'',$str[0]);
           for ( $i = 1; $i < count($str); $i++ ) {
               $arg .= $str[$i];
                       $_ARG[$key] = $arg;
       } elseif(ereg('-[a-zA-Z0-9]',$arg)) {
           $arg = ereg_replace("-",'',$arg);
           $_ARG[$arg] = 'true';
return $_ARG;
<?php print_r(arguments($argv)); ?>
# php5 myscript.php --user=nobody --password=secret -p
   [user] => nobody
   [password] => secret
   [p] => true


When you're writing one line php scripts remember that 'php://stdin' is your friend. Here's a simple program I use to format PHP code for inclusion on my blog:
 cat test.php | php -r "print htmlentities(file_get_contents('php://stdin'));"
 type test.php | php -r "print htmlentities(file_get_contents('php://stdin'));"

zager ..a..t..

Under Solaris (at least 2.6) I have some problems with reading stdin. Original pbms report may be found here:
At a first glance the only solution for it is 'fgetcsv'
#!/usr/local/bin/php -q
if (!$fd)
while (!feof ($fd))
 $s = fgetcsv($fd,128,"\n");
 if ($s==false)
 echo $s[0]."\n";
But... keep reading....
>>> I wrote
Sometimes I hate PHP... ;)
Right today I was trapped by some strange bug in my code with reading stdin using fgetcsv.
After a not small investigation I found that strings like "foo\nboo\ndoo"goo\n (take note of double quatation sign in it)
interpreted by fgetcsv like:
since double quotation mark has a special meaning and get stripped off of the input stream.
Indeed, according to PHP manual:
array fgetcsv ( int fp, int length [, string delimiter [, string enclosure]])
another delimiter with the optional third parameter. _The_enclosure_character_is_double_quote_,_unless_
_enclosure_is_added_from_PHP 4.3.0.       !!!!!!
Means no chance for us prior to 4.3.0 :(
But file() works just fine !!!! Of course by the price of memory, so be careful with large files.
set_magic_quotes_runtime(0); // important, do not forget it !!!
for ($i=0,$n=sizeof($s);$i<$n;$i++)
1. If you have no double quotation mark in your data use fgetcsv
2. From 4.3.0 use   fgetcsv($fd,"\n",""); // I hope it will help
3. If you data is not huge use file("php://stdin");
Hope now it's cleared for 100% (to myself ;)
Good luck!
PS. Don't forget that it's only Solaris specific problem. Under Linux just use usual fgets()...


To pass more than 9 arguments to your php-script on Windows, you can use the 'shift'-command in a batch file. After using 'shift', %1 becomes %0, %2 becomes %1 and so on - so you can fetch argument 10 etc.
Here's an example - hopefully ready-to-use - batch file:
@echo off
set args=
if "%0"=="" goto :finish_arg
set args=%args% %0
goto :get_arg
set php=C:\path\to\php.exe
set ini=C:\path\to\php.ini
%php% -c %ini% foo.php %args%
Usage on commandline:
foo -1 -2 -3 -4 -5 -6 -7 -8 -9 -foo -bar
A print_r($argv) will give you all of the passed arguments.


To hand over the GET-variables in interactive mode like in HTTP-Mode (e.g. your URI is myprog.html?hugo=bla&bla=hugo), you have to call
php myprog.html '&hugo=bla&bla=hugo'
(two & instead of ? and &!)
There just a little difference in the $ARGC, $ARGV values, but I think this is in those cases not relevant.


To display colored text when it is actually supported :
echo "\033[31m".$myvar; // red foreground
echo "\033[41m".$myvar; // red background
To reset these settings :
echo "\033[0m";
More fun :
echo "\033[5;30m;\033[48mWARNING !"; // black blinking text over red background
More info here :


TIP: If you want different versions of the configuration file  depending on what SAPI is used,just name them php.ini (apache module), php-cli.ini (CLI) and php-cgi.ini (CGI) and dump them all in the regular configuration directory. I.e no need to compile several versions of php anymore!

ben jenkins

This took me all day to figure out, so I hope posting it here saves someone some time:
Your PHP-CLI may have a different php.ini than your apache-php.  For example: On my Debian-based system, I discovered I have /etc/php4/apache/php.ini and /etc/php4/cli/php.ini
If you want MySQL support in the CLI, make sure the line
is not commented out.
The differences in php.ini files may also be why some scripts will work when called through a web browser, but will not work when called via the command line.


This posting is not a php-only problem, but hopefully will save someone a few hours of headaches.  Running on MacOS (although this could happen on any *nix I suppose), I was unable to get the script to execute without specifically envoking php from the command line:
[macg4:valencia/jobs] tim% test.php
./test.php: Command not found.
However, it worked just fine when php was envoked on the command line:
[macg4:valencia/jobs] tim% php test.php
Well, here we are...  Now what?
Was file access mode set for executable?  Yup.
[macg4:valencia/jobs] tim% ls -l
total 16
-rwxr-xr-x  1 tim  staff   242 Feb 24 17:23 test.php
And you did, of course, remember to add the php command as the first line of your script, yeah?  Of course.
<?php print "Well, here we are...  Now what?\n"; ?>
So why dudn't it work?  Well, like I said... on a Mac.... but I also occasionally edit the files on my Windows portable (i.e. when I'm travelling and don't have my trusty Mac available)...  Using, say, WordPad on Windows... and BBEdit on the Mac...
Aaahhh... in BBEdit check how the file is being saved!  Mac?  Unix?  or Dos?  Bingo.  It had been saved as Dos format.  Change it to Unix:
[macg4:valencia/jobs] tim% ./test.php
Well, here we are...  Now what?
[macg4:valencia/jobs] tim%
NB: If you're editing your php files on multiple platforms (i.e. Windows and Linux), make sure you double check the files are saved in a Unix format...  those \r's and \n's 'll bite cha!


This is the most simple way to get the named parameter.  Write the script test.php as ...
echo "Yo! my name is ".$_REQUEST["name"]."\n";
and run this program as follows
# php -f test.php name=Jerry
Yo! my name is Jerry
I am using PHP 4.3.3 (CGI) in Fedora Core 1 and It is working perfectly
God Bless You!


The basic issue was that PHP-as-CGI REALLY REALLY wants SCRIPT_FILENAME.
It ignores the command line. It ignores SCRIPT_NAME.  It wants
"No input file specified."
This very informative error message from PHP means that your web server, WHATEVER it is, is not setting SCRIPT_FILENAME.
The minimum set of env variables:
PATH: DOESN'T MATTER if you're spawning php pages with #!/../php in them
LD_LIBRARY_PATH= should be right
SERVER_SOFTWARE=mini_httpd/1.17beta1 26may2002
SERVER_NAME=who cares
SCRIPT_FILENAME=/homes/foobie/mini/foo.php <--- CRITICAL
HTTP_USER_AGENT=Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0; Q312461; .NET CLR 1.0.3705; .NET CLR 1.1.4322)
If SCRIPT_FILENAME is not set, you'll get the dreaded "No input file specified" message.
mini_httpd does not do this by default. You need to patch it in to make_envp.
A secondary issue is configuration (PHP):
   ./configure --enable-discard-path --with-config-file-path=/homes/wherever/mini/php.ini
   (where php.ini is a slightly modified version of php.ini-recommended)


Spawning php-win.exe as a child process to handle scripting in Windows applications has a few quirks (all having to do with pipes between Windows apps and console apps).
To do this in C++:
// We will run php.exe as a child process after creating
// two pipes and attaching them to stdin and stdout
// of the child process
// Define sa struct such that child inherits our handles
sa.bInheritHandle = TRUE;
sa.lpSecurityDescriptor = NULL;
// Create the handles for our two pipes (two handles per pipe, one for each end)
// We will have one pipe for stdin, and one for stdout, each with a READ and WRITE end
HANDLE hStdoutRd, hStdoutWr, hStdinRd, hStdinWr;
// Now create the pipes, and make them inheritable
CreatePipe (&hStdoutRd, &hStdoutWr, &sa, 0))
SetHandleInformation(hStdoutRd, HANDLE_FLAG_INHERIT, 0);
CreatePipe (&hStdinRd, &hStdinWr, &sa, 0)
SetHandleInformation(hStdinWr, HANDLE_FLAG_INHERIT, 0);
// Now we have two pipes, we can create the process
// First, fill out the usage structs
si.hStdOutput = hStdoutWr;
si.hStdInput  = hStdinRd;
// And finally, create the process
CreateProcess (NULL, "c:\\php\\php-win.exe", NULL, NULL, TRUE, NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi);
// Close the handles we aren't using
// Now that we have the process running, we can start pushing PHP at it
WriteFile(hStdinWr, "<?php echo 'test'; ?>", 9, &dwWritten, NULL);
// When we're done writing to stdin, we close that pipe
// Reading from stdout is only slightly more complicated
int i;
std::string processed("");
char buf[128];
while ( (ReadFile(hStdoutRd, buf, 128, &dwRead, NULL) && (dwRead != 0)) ) {
for (i = 0; i < dwRead; i++)
processed += buf[i];
// Done reading, so close this handle too
A full implementation (implemented as a C++ class) is available at



python coders might miss this construct when working in PHP:
if __name__=='__main__':
   # handle direct invocation from command line
it's a great way to embed little bits of test code (or a full-on cli for that matter),
while keeping the source file usable in other contexts.
Far as I can tell, this is the closest approximation available in PHP5:
if ('cli'===php_sapi_name() &&
       )) {
   // handle direct invocation from command line

ben-php dot net

PHP 4.3 and above automatically have STDOUT, STDIN, and STDERR openned ... but < 4.3.0 do not.  This is how you make code that will work in versions previous to PHP 4.3 and future versions without any changes:
if (version_compare(phpversion(),'4.3.0','<')) {
register_shutdown_function( create_function( '' , 'fclose(STDIN); fclose(STDOUT); fclose(STDERR); return true;' ) );
/* get some STDIN up to 256 bytes */
$str = fgets(STDIN,256);

roberto dot dimas

One of the things I like about perl and vbscripts, is the fact that I can name a file e.g. '' and just have to type 'test, without the .pl extension' on the windows command line and the command processor knows that it is a perl file and executes it using the perl command interpreter.
I did the same with the file extension .php3 (I will use php3 exclusivelly for command line php scripts, I'm doing this because my text editor VIM 6.3 already has the correct syntax highlighting for .php3 files ).
I modified the PATHEXT environment variable in Windows XP, from the " 'system' control panel applet->'Advanced' tab->'Environment Variables' button-> 'System variables' text area".
Then from control panel "Folder Options" applet-> 'File Types' tab, I added a new file extention (php3), using the button 'New'  and typing php3 in the window that pops up.
Then in the 'Details for php3 extention' area I used the 'Change' button to look for the Php.exe executable so that the php3 file extentions are associated with the php executable.
You have to modify also the 'PATH' environment variable, pointing to the folder where the php executable is installed
Hope this is useful to somebody

On windows, you can simulate a cls by echoing out just \r.  This will keep the cursor on the same line and overwrite what was on the line.
for example:
   echo "Starting Iteration" . "\n\r";
   for ($i=0;$i<10000;$i++) {
       echo "\r" . $i;
   echo "Ending Iteration" . "\n\r";


On windows try ctrl-m or ctrl-z to run code in interactive (-a) mode
(*nix ctrl-d)

adam, php

Ok, I've had a heck of a time with PHP > 4.3.x and whether to use CLI vs CGI. The CGI version of 4.3.2 would return (in browser):
No input file specified.
And the CLI version would return:
500 Internal Server Error
It appears that in CGI mode, PHP looks at the environment variable PATH_TRANSLATED to determine the script to execute and ignores command line. That is why in the absensce of this environment variable, you get "No input file specified." However, in CLI mode the HTTP headers are not printed. I believe this is intended behavior for both situations but creates a problem when you have a CGI wrapper that sends environment variables but passes the actual script name on the command line.
By modifying my CGI wrapper to create this PATH_TRANSLATED environment variable, it solved my problem, and I was able to run the CGI build of 4.3.2

lucas dot vasconcelos

Just another variant of previous script that group arguments doesn't starts with '-' or '--'
function arguments($argv) {
   $_ARG = array();
   foreach ($argv as $arg) {
     if (ereg('--([^=]+)=(.*)',$arg,$reg)) {
       $_ARG[$reg[1]] = $reg[2];
     } elseif(ereg('^-([a-zA-Z0-9])',$arg,$reg)) {
           $_ARG[$reg[1]] = 'true';
     } else {
 return $_ARG;
$ php myscript.php --user=nobody /etc/apache2/*
   [input] => Array
           [0] => myscript.php
           [1] => /etc/apache2/apache2.conf
           [2] => /etc/apache2/conf.d
           [3] => /etc/apache2/envvars
           [4] => /etc/apache2/httpd.conf
           [5] => /etc/apache2/mods-available
           [6] => /etc/apache2/mods-enabled
           [7] => /etc/apache2/ports.conf
           [8] => /etc/apache2/sites-available
           [9] => /etc/apache2/sites-enabled
   [user] => nobody

eric dot brison

Just a variant of previous script to accept arguments with '=' also
function arguments($argv) {
   $_ARG = array();
   foreach ($argv as $arg) {
     if (ereg('--([^=]+)=(.*)',$arg,$reg)) {
   $_ARG[$reg[1]] = $reg[2];
     } elseif(ereg('-([a-zA-Z0-9])',$arg,$reg)) {
           $_ARG[$reg[1]] = 'true';
 return $_ARG;
$ php myscript.php --user=nobody --password=secret -p --access="host= port=456"
   [user] => nobody
   [password] => secret
   [p] => true
   [access] => host= port=456


Just a note for people trying to use interactive mode from the commandline.
The purpose of interactive mode is to parse code snippits without actually leaving php, and it works like this:
[root@localhost php-4.3.4]# php -a
Interactive mode enabled
<?php echo "hi!"; ?>
<note, here we would press CTRL-D to parse everything we've entered so far>
<?php exit(); ?>
<ctrl-d here again>
[root@localhost php-4.3.4]#
I noticed this somehow got ommited from the docs, hope it helps someone!

16-sep-2006 07:05

It seems like 'max_execution_time' doesn't work on CLI.
php -d max_execution_time=20
       -r '$foo = ini_get("max_execution_time"); var_dump($foo);'
will print string(2) "20", but if you'l run infinity while: while(true) for example, it wouldn't stop after 20 seconds.
Testes on Linux Gentoo, PHP 5.1.6.

c dot kelly no--spam

In Windows [NT4.0 sp6a] the example
php -r ' echo getcwd();' does not work ; It appears you have to use the following php -r "echo getcwd();" --not the " around the command   to get the output to screen , just took me half an hour to figure out what was going on.


In a bid to save time out of lives when calling up php from the Command Line on Mac OS X.
I just wasted hours on this. Having written a routine which used the MCRYPT library, and tested it via a browser, I then set up a crontab to run the script from the command line every hour (to do automated backups from mysql using mysqldump, encrypt them using mcrypt, then email them and ftp them off to remote locations).
Everything worked fine from the browser, but failed every time from the cron task with "Call to undefined function: mcrypt [whatever]".
Only after much searching do I realise that the CGI and CLI versions are differently compiled, and have different modules attached (I'm using the install for Mac OS-X, php v4.3.2 and mysql v4.0.18).
I still can not find a way to resolve the problem, so I have decided instead to remove the script from the SSL side of the server, and run it using a crontab with CURL to localhost or in order that it will run through Apache's php module.
Just thought this might help some other people tearing their hair out. If anyone knows a quick fix to add the mcrypt module onto the CLI php without any tricky re-installing, it'd be really helpful.
Meantime the workaround does the job, not as neatly though.


In 5.1.2 (and others, I assume), the -f form silently drops the first argument after the script name from $_SERVER['argv']. I'd suggest avoiding it unless you need it for a special case.


In *nix systems, use the WHICH command to show the location of the php binary executable. This is the path to use as the first line in your php shell script file. (#!/path/to/php -q) And execute php from the command line with the -v switch to see what version you are running.
# which php
# php -v
PHP 4.3.1 (cli) (built: Mar 27 2003 14:41:51)
Copyright (c) 1997-2002 The PHP Group
Zend Engine v1.3.0, Copyright (c) 1998-2002 Zend Technologies
In the above example, you would use: #!/usr/local/bin/php
Also note that, if you do not have the current/default directory in your PATH (.), you will have to use ./scriptfilename to execute your script file from the command line (or you will receive a "command not found" error). Use the ENV command to show your PATH environment variable value.

goalain eat gmail dont com

If your php script doesn't run with shebang (#!/usr/bin/php),
and it issues the beautifull and informative error message:
"Command not found."  just dos2unix yourscript.php
et voila.
If your php script doesn't run with shebang (#/usr/bin/php),
and it issues the beautifull and informative message:
"Invalid null command." it's probably because the "!" is missing in the the shebang line (like what's above) or something else in that area.


If you want to use named command line parameters in your script,
the following code will parse command line parameters in the form
of name=value and place them in the $_REQUEST super global array.
echo "argv[] = ";
print_r($argv);  // just to see what was passed in
if ($argc > 0)
 for ($i=1;$i < $argc;$i++)
   $_REQUEST = array_merge($_REQUEST, $tmp);
echo "\$_REQUEST = ";
rwre:~/tmp$ /usr/local/bin/php cli_test.php foo=1 bar=2 third=a+value
argv[] = Array
   [0] => t.php
   [1] => foo=1
   [2] => bar=2
   [3] => third=a+value
$_REQUEST = Array
   [foo] => 1
   [bar] => 2
   [third] => a value


If you want to pass directly PHP code to the interpreter and you don't have only CGI, not the CLI SAPI so you miss the -r option.
If you're lucky enough to be on a nix like system, then tou can still use the pipe solution as the 3. way to command CLI SAPI described above, using a pipe ('|').
Then works for CGI SAPI:
$ echo '<?php echo "coucou\n"; phpinfo(); /* or any code */ ?>' | php
NOTE: unlike commands passed to the -r option, here you NEED the PHP tags.


If you want to get the output of a command use the function shell_exec($command) - it returns a string with the output of the command.


If you want an interactive command line shell for PHP to test out code, give phpa a try:


If you are using Windows XP (I think this works on 2000, too) and you want to be able to right-click a .php file and run it from the command line, follow these steps:
1. Run regedit.exe and *back up the registry.*
2. Open HKEY_CLASSES_ROOT and find the ".php" key.
3. Look at the "(Default)" value inside it and find the key in HKEY_CLASSES_ROOT with that name.
4. Open the "shell" key inside that key. Skip to 8.
5. Add a ".php" key and set the "(Default)" value inside it to something like "phpscriptfile".
6. Create another key in HKEY_CLASSES_ROOT called "phpscriptfile" or whatever you chose.
7. Create a key inside that one called "shell".
8. Create a key inside that one called "run".
9. Set the "(Default)" value inside "run" to whatever you want the menu option to be (e.g. "Run").
10. Create a key inside "run" called "command".
11. Set the "(Default)" value inside "command" to:
cmd.exe /k C:\php\php.exe "%1"
Make sure the path to PHP is appropriate for your installation. Why not just run it with php.exe directly? Because you (presumably) want the console window to remain open after the script ends.
You don't need to set up a webserver for this to work. I downloaded PHP just so I could run scripts on my computer. Hope this is useful!


If you are trying to set up an interactive command line script and you want to get started straight away (works on 4+ I hope). Here is some code to start you off:
// Stop the script giving time out errors..
// This opens standard in ready for interactive input..
// Main event loop to capture top level command..

// Print out main menu..
echo "Select an option..\n\n";
echo "    1) Do this\n";
echo "    2) Do this\n";
echo "    3) Do this\n";
echo "    x) Exit\n";
// Decide what menu option to select based on input..
case 1:

case 2:
case 3:
case "x":

// Close standard in..


I was looking for a way to interactively get a single character response from user. Using STDIN with fread, fgets and such will only work after pressing enter. So I came up with this instead:
#!/usr/bin/php -q
function inKey($vals) {
$inKey = "";
While(!in_array($inKey,$vals)) {
$inKey = trim(`read -s -n1 valu;echo \$valu`);
return $inKey;
function echoAT($Row,$Col,$prompt="") {
// Display prompt at specific screen coords
echo "\033[".$Row.";".$Col."H".$prompt;
// Display prompt at position 10,10
echoAT(10,10,"Opt : ");
// Define acceptable responses
$options = array("1","2","3","4","X");
// Get user response
$key = inKey($options);
// Display user response & exit
echoAT(12,10,"Pressed : $key\n");
Hope this helps someone.


i use emacs in c-mode for editing.  in 4.3, starting a cli script like so:
#!/usr/bin/php -q /* -*- c -*- */
told emacs to drop into c-mode automatically when i loaded the file for editing.  the '-q' flag didn't actually do anything (in the older cgi versions, it suppressed html output when the script was run) but it caused the commented mode line to be ignored by php.
in 5.2, '-q' has apparently been deprecated.  replace it with '--' to achieve the 4.3 invocation-with-emacs-mode-line behavior:
#!/usr/bin/php -- /* -*- c -*- */
don't go back to your 4.3 system and replace '-q' with '--'; it seems to cause php to hang waiting on STDIN...


I needed this, you proly wont tho.
puts the exicution args into $_GET
if ($argv)
for ($i=1;$i<count($argv);$i++)
$it = split("=",$argv[$i]);
$_GET[$it[0]] = $it[1];

b crawford

I have not seen in this thread any code snippets that support the full *nix style argument parsing. Consider this:
function getArgs($args) {
$out = array();
$last_arg = null;
for($i = 1, $il = sizeof($args); $i < $il; $i++) {
if( (bool)preg_match("/^--(.+)/", $args[$i], $match) ) {
$parts = explode("=", $match[1]);
$key = preg_replace("/[^a-z0-9]+/", "", $parts[0]);
if(isset($parts[1])) {
$out[$key] = $parts[1];
else {
$out[$key] = true;
$last_arg = $key;
else if( (bool)preg_match("/^-([a-zA-Z0-9]+)/", $args[$i], $match) ) {
for( $j = 0, $jl = strlen($match[1]); $j < $jl; $j++ ) {
$key = $match[1]{$j};
$out[$key] = true;
$last_arg = $key;
else if($last_arg !== null) {
$out[$last_arg] = $args[$i];
return $out;
php file.php --foo=bar -abc -AB 'hello world' --baz
 [foo] => bar
 [a] => true
 [b] => true
 [c] => true
 [A] => true
 [B] => hello world
 [baz] => true


I had a problem with the $argv values getting split up when they contained plus (+) signs. Be sure to use the CLI version, not CGI to get around it.


I had a problem with PHP 5.2.0 (cli) (winXP) that no output was printed when I tried to run any file. Using the -n switch solved the problem.
Apparently the interpreter can't always find php.ini, even though both exist in the same folder and the PATH variable is set correctly. No error messages were printed either.

alexander plakidin

How to change current directory in PHP script to script's directory when running it from command line using PHP 4.3.0?
(you'll probably need to add this to older scripts when running them under PHP 4.3.0 for backwards compatibility)
Here's what I am using:
Note: documentation says that "PHP_SELF" is not available in command-line PHP scripts. Though, it IS available. Probably this will be changed in future version, so don't rely on this line of code...
Use $_SERVER['PHP_SELF'] instead of just $PHP_SELF if you have register_globals=Off


This function clears the screen, like "clear screen"
 function clearscreen($out = TRUE) {
   $clearscreen = chr(27)."[H".chr(27)."[2J";
   if ($out) print $clearscreen;
   else return $clearscreen;

lasse johansson

Hi, parsing the commandline (argv) can be very simple in PHP.
If you use keyword parms like:
script.php parm1=value parm3=value
All you have to do in script.php is:
for ($i=1; $i < $argc; $i++) {parse_str($argv[$i]);}
$startup=compact('parm1', 'parm2', 'parm3');

earomero _{at}_

Here's <losbrutos at free dot fr> function modified to support unix like param syntax like <B Crawford> mentions:
function arguments($argv) {
   $_ARG = array();
   foreach ($argv as $arg) {
       if (preg_match('#^-{1,2}([a-zA-Z0-9]*)=?(.*)$#', $arg, $matches)) {
           $key = $matches[1];
           switch ($matches[2]) {
               case '':
               case 'true':
               $arg = true;
               case 'false':
               $arg = false;
               $arg = $matches[2];
           /* make unix like -afd == -a -f -d */            
           if(preg_match("/^-([a-zA-Z0-9]+)/", $matches[0], $match)) {
               $string = $match[1];
               for($i=0; strlen($string) > $i; $i++) {
                $_ARG[$string[$i]] = true;
           } else {
               $_ARG[$key] = $arg;
       } else {
           $_ARG['input'][] = $arg;
   return $_ARG;
eromero@ditto ~/workspace/snipplets $ foxogg2mp3.php asdf asdf --help --dest=/var/ -asd -h
   [input] => Array
           [0] => /usr/local/bin/foxogg2mp3.php
           [1] => asdf
           [2] => asdf
   [help] => 1
   [dest] => /var/
   [a] => 1
   [s] => 1
   [d] => 1
   [h] => 1

13-mar-2005 09:52

Here is very simple, but usefull Command Line handler class. it may be usefull for your apps.
class AnyClass{
   public function start(){
       return "started";
   public function stop(){
       return "stoppded";
$cli = new CliHandler(new AnyClass());
CliHandler accepts any class als argument.
Try this.
/usr/local/php/PHP5 CliHandler.class.php
output: Try these command:
enter "start"
output: started


Here goes a very simple clrscr function for newbies...
function clrscr() { system("clear"); }


Here are some instructions on how to make PHP files executable from the command prompt in Win2k.  I have not tested this in any other version of Windows, but I'm assuming it will work in XP, but not 9x/Me.
There is an environment variable (control panel->system->advanced->environment variables) named PATHEXT.  This is a list of file extensions Windows will recognize as executable at the command prompt.  Add .PHP (or .PL, or .CLASS, or whatever) to this list.  Windows will use the default action associated with that file type when you execute it from the command prompt.
To set up the default action:
Open Explorer.
Go to Tools->folder options->file types
Find the extension you're looking for.  If it's not there, click New to add it.
Click on the file type, then on Advanced, then New.
For the action, type "Run" or "Execute" or whatever makes sense.
For the application, type
 {path to application} "%1" %*
The %* will send any command line options that you type to the program.
The application field for PHP might look like
 c:\php\php.exe -f "%1" -- %*
(Note, you'll probably want to use the command line interface version php-cli.exe)
or for Java
 c:\java\java.exe "%1" %*
Click OK.
Click on the action that was just added, then click Set default.
If this helps you or if you have any changes/more information I would appreciate a note.  Just remove NOSPAM from the email address.


For windows clearing the screen using "system('cls');" does not work (at least for me)...
Although this is not pretty it works... Simply send 24 newlines after the output (for one line of output, 23 for two, etc
Here is a sample function and usage:
   function CLS($lines){  // $lines = number of lines of output to keep
       for($i=24;$i>=$lines;$i--) @$return.="\n";
       return $return;

   fwrite(STDOUT,"Still Processing: Total Time ".$i." Minutes so far..." . CLS(1));
Hope This Helps,


For those who was unable to clear the windows screen trying to run CLS command:
CLS is not an windows executable file! It is an option from!
So, the rigth command is
  system("command /C cls");


For those of you who want the old CGI behaviour that changes to the actual directory of the script use:
at the beginning of your scripts.


Example 43-2 shows how to create a DOS batch file to run a PHP script form the command line using:
@c:\php\cli\php.exe script.php %1 %2 %3 %4
Here is an updated version of the DOS batch file:
@c:\php\cli\php.exe %~n0.php %*
This will run a PHP file (i.e. script.php) with the same base file name (i.e. script) as the DOS batch file (i.e. script.bat) and pass all parameters (not just the first four as in example 43-2) from the DOS batch file to the PHP file.  
This way all you have to do is copy/rename the DOS batch file to match the name of your PHP script file without ever having to actually modify the contents of the DOS batch file to match the file name of the PHP script.


dunno if this is on linux the same but on windows evertime
you send somthing to the console screen php is waiting for
the console to return. therefor if you send a lot of small
short amounts of text, the console is starting to be using
more cpu-cycles then php and thus slowing the script.
take a look at this sheme:
cpu-cycle:1 ->php: print("a");
cpu-cycle:2 ->cmd: output("a");
cpu-cycle:3 ->php: print("b");
cpu-cycle:4 ->cmd: output("b");
cpu-cycle:5 ->php: print("c");
cpu-cycle:6 ->cmd: output("c");
cpu-cylce:7 ->php: print("d");
cpu-cycle:8 ->cmd: output("d");
cpu-cylce:9 ->php: print("e");
cpu-cycle:0 ->cmd: output("e");
on the screen just appears "abcde". but if you write
your script this way it will be far more faster:
cpu-cycle:1 ->php: ob_start();
cpu-cycle:2 ->php: print("abc");
cpu-cycle:3 ->php: print("de");
cpu-cycle:4 ->php: $data = ob_get_contents();
cpu-cycle:5 ->php: ob_end_clean();
cpu-cycle:6 ->php: print($data);
cpu-cycle:7 ->cmd: output("abcde");
now this is just a small example but if you are writing an
app that is outputting a lot to the console, i.e. a text
based screen with frequent updates, then its much better
to first cach all output, and output is as one big chunk of
text instead of one char a the time.
ouput buffering is ideal for this. in my script i outputted
almost 4000chars of info and just by caching it first, it
speeded up by almost 400% and dropped cpu-usage.
because what is being displayed doesn't matter, be it 2
chars or 40.0000 chars, just the call to output takes a
great deal of time. remeber that.
maybe someone can test if this is the same on unix-based
systems. it seems that the STDOUT stream just waits for
the console to report ready, before continueing execution.


Assuming --prefix=/usr/local/php, it's better to create a symlink from /usr/bin/php or /usr/local/bin/php to target /usr/local/php/bin/php so that it's both in your path and automatically correct every time you rebuild.  If you forgot to do that copy of the binary after a rebuild, you can do all kinds of wild goose chasing when things break.


an another "another variant" :
function arguments($argv)
 $_ARG = array();
 foreach ($argv as $arg)
   if (preg_match('#^-{1,2}([a-zA-Z0-9]*)=?(.*)$#', $arg, $matches))
     $key = $matches[1];
     switch ($matches[2])
       case '':
       case 'true':
         $arg = true;
       case 'false':
         $arg = false;
         $arg = $matches[2];
     $_ARG[$key] = $arg;
     $_ARG['input'][] = $arg;
 return $_ARG;
$php myscript.php arg1 -arg2=val2 --arg3=arg3 -arg4 --arg5 -arg6=false
   [input] => Array
           [0] => myscript.php
           [1] => arg1
   [arg2] => val2
   [arg3] => arg3
   [arg4] => true
   [arg5] => true
   [arg5] => false

goalain eat gmail dont com

An addition to my previous post (you can replace it)
If your php script doesn't run with shebang (#!/usr/bin/php),
and it issues the beautifull and informative error message:
"Command not found."  just dos2unix yourscript.php
et voila.
If you still get the "Command not found."
Just try to run it as ./myscript.php , with the "./"
if it works - it means your current directory is not in the executable search path.
If your php script doesn't run with shebang (#/usr/bin/php),
and it issues the beautifull and informative message:
"Invalid null command." it's probably because the "!" is missing in the the shebang line (like what's above) or something else in that area.


A very important point missing here (I lost hours on it and hope to avoid this to you) :
* When using PHP as CGI
* When you just become crazy because of "No input file specified" appearing on the web page, while it never appears directly in the shell
Then I have a solution for you :
1. Create a script for example called cgiwrapper.cgi
2. Put inside :
#!/bin/sh -
export SCRIPT_FILENAME=/var/www/realpage.php
/usr/bin/php -f $SCRIPT_FILENAME
3. Name your page realpage.php
For example with thttpd the problem is that SCRIPT_FILENAME is not defined, while PHP absolutely requires it.
My solution corrects that problem !

diego dot rodrigues

#!/usr/bin/php -q
* Simple argv[] parser for CLI scripts
* Diego Mendes Rodrigues - São Paulo - Brazil
* diego.m.rodrigues [at] gmail [dot] com
* May/2005
class arg_parser {
var $argc;
var $argv;
var $parsed;
var $force_this;
function arg_parser($force_this="") {
global $argc, $argv;
$this->argc = $argc;
$this->argv = $argv;
$this->parsed = array();

                          array($this->argv[0]) );
if ( !empty($force_this) )
if ( is_array($force_this) )
$this->force_this = $force_this;
//Sending parameters to $parsed
if ( $this->argc > 1 ) {
for($i=1 ; $i< $this->argc ; $i++) {
//We only have passed -xxxx
if ( substr($this->argv[$i],0,1) == "-" ) {
//Se temos -xxxx xxxx
if ( $this->argc > ($i+1) ) {
if ( substr($this->argv[$i+1],0,1) != "-" ) {
$this->argv[$i+1]) );
//We have passed -xxxxx1 xxxxx2
                                            array($this->argv[$i]) );
               //Testing if all necessary parameters have been passed
//Testing if one parameter have benn passed
function passed($argumento) {
for($i=0 ; $i< $this->argc ; $i++)
if ( $this->parsed[$i][0] == $argumento )
return $i;
return 0;
//Testing if you have passed a estra argument, -xxxx1 xxxxx2
function full_passed($argumento) {
$findArg = $this->passed($argumento);
if ( $findArg )
if ( count($this->parsed[$findArg] ) > 1 )
return $findArg;
return 0;
       //Returns  xxxxx2 at a " -xxxx1 xxxxx2" call
function get_full_passed($argumento) {
               $findArg = $this->full_passed($argumento);
               if ( $findArg )
                return $this->parsed[$findArg][1];

//Necessary parameters to script
function force() {
if ( is_array( $this->force_this ) ) {
for($i=0 ; $i< count($this->force_this) ; $i++) {
if ( $this->force_this[$i][1] == "SIMPLE"
    && !$this->passed($this->force_this[$i][0])
die("\n\nMissing " . $this->force_this[$i][0] . "\n\n");
                               if ( $this->force_this[$i][1] == "FULL"
                                    && !$this->full_passed($this->force_this[$i][0])
                                       die("\n\nMissing " . $this->force_this[$i][0] ." <arg>\n\n");
$forcar = array(
array("-name", "FULL"),
array("-email","SIMPLE") );
$parser = new arg_parser($forcar);
if ( $parser->passed("-show") )
echo "\nGoing...:";
echo "\nName: " . $parser->get_full_passed("-name");
if ( $parser->full_passed("-email") )  
echo "\nEmail: " . $parser->get_full_passed("-email");
       echo "\nEmail: default";
if ( $parser->full_passed("-copy") )
       echo "\nCopy To: " . $parser->get_full_passed("-copy");
echo "\n\n";
[diego@Homer diego]$ ./en_arg_parser.php -name -email cool -copy Ana
Missing -name <arg>
[diego@Homer diego]$ ./en_arg_parser.php -name diego -email cool -copy Ana
Name: diego
Email: cool
Copy To: Ana
[diego@Homer diego]$ ./en_arg_parser.php -name diego -email  -copy Ana
Name: diego
Email: default
Copy To: Ana
[diego@Homer diego]$ ./en_arg_parser.php -name diego -email
Name: diego
Email: default
[diego@Homer diego]$

Change Language

Follow Navioo On Twitter
HTTP authentication with PHP
Dealing with XForms
Handling file uploads
Using remote files
Connection handling
Persistent Database Connections
Safe Mode
Using PHP from the command line
eXTReMe Tracker