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



PHP : Function Reference : PHP Options&Information : getopt

getopt

Gets options from the command line argument list (PHP 4 >= 4.3.0, PHP 5)
array getopt ( string options [, array longopts] )

Returns an associative array of option / argument pairs based on the options format specified in options, or FALSE on an error.

Parameters

options

The options parameter may contain the following elements: individual characters, and characters followed by a colon to indicate an option argument is to follow. For example, an option string x recognizes an option -x, and an option string x: recognizes an option and argument -x argument. It does not matter if an argument has leading white space.

longopts

Return Values

This function will return an array of option / argument pairs. If an option does not have an argument, the value will be set to FALSE.

ChangeLog

Version Description
5.3.0 This function is no longer system dependent and works on Windows too.

Examples

Example 1842. getopt() Example

copy to clipboard
<?php
// parse the command line ($GLOBALS['argv'])
$options = getopt("f:hp:");
?>


Code Examples / Notes » getopt

yarco dot w
You cant use this function twice or more.
For example:
<?php
print_r(getopt('a:b:c:'));
print_r(getopt('d:e:f:'));
?>
You would be confused by the result.
[yarco@localhost ~]$ php test3.php -a love -b love -d love
Array
(
   [a] => love
   [b] => love
)
Array
(
   [e] => love
   [d] => love
)

carl
Unlike POSIX.2 getopt(), this function does not modify argv, so it's
only useful if you have no non-option arguments. More often than
not, you're probably better off examining $argv yourself.

daevid
This is how I parse command line options:
<?php
$OPTION['debug'] = false;
$OPTION['test'] = false;
$OPTION['force'] = "";
//loop through our arguments and see what the user selected
  for ($i = 1; $i < $_SERVER["argc"]; $i++)
  {
      switch($_SERVER["argv"][$i])
      {
          case "-v":
          case "--version":
echo  $_SERVER['argv'][0]." v07.19.04 06:10 PM\n";
exit;
              break;

          case "--debug":
              $OPTION['debug'] = true;
              break;

          case "--force":
              $OPTION['force'] = " --force";
              break;

          case "--db":
          case "--database":
          case "--id":
if ( is_numeric($_SERVER['argv'][$i+1]) )
$OPTION['CompanyID'] = intval($_SERVER['argv'][++$i]);
else //it must be a database name
$OPTION['CompanyDB'] = $_SERVER['argv'][++$i];
              break;
          case "--base":
          case "--basedir":
          case "--dir":
              $OPTION['basedir'] = $_SERVER["argv"][++$i];
              break;

          case "--test":
              $OPTION['test'] = true;
              break;

          case "-?":
          case "-h":
          case "--help":
?>
This will print any .txt files, process any .sql files and
execute any .php files found starting from the base directory
'<?=$OPTION['basedir']?>' in alphabetical order.
Usage: <?php echo $_SERVER['argv'][0]; ?> <option>
--help, -help, -h, or -? to get this help.
--version to return the version of this file.
--debug to turn on output debugging.
--test to fake the SQL and PHP commands.
--force to ignore SQL errors and keep on going.
--db [CompanyDB] to apply to only this [CompanyDB].
--id [CompanyID] to apply to only this [CompanyID].
--basedir [directory] to change base directory from <?=$OPTION['basedir']?>.
Omitting the CompanyID or CompanyDB will cause ALL Company DB's to be updated.
There are global files and per-company files. Global files are applied to global
databases (see list below). Their filename contains a tag that reflects the database
to apply them against. Per-company files are applied against databases. Their
filename contains a tag that reads 'COMPANY'. Files should be in <?=$OPTION['basedir']?>;
Global files that are understood:
<?=$OPTION['basedir']?>
<?php foreach ($GLOBAL_SQL_FILES as $sqlFile) echo $sqlFile."   "; ?>
<?php
              exit;
              break;
      }
  } //parse arguments
// print_r($OPTION);
?>

damien b.
This is how I handle arguments with getopt: I use switch within a foreach at the beginning of a program.
<?php
$opts = getopt('hs:');
// Handle command line arguments
foreach (array_keys($opts) as $opt) switch ($opt) {
 case 's':
   // Do something with s parameter
   $something = $opts['s'];
   break;
 case 'h':
   print_help_message();
   exit(1);
}
print "$something\n";
?>

joey
There are 2 simpler (and much faster) methods for getting good getopt() operation without creating your own handler.
1. Use the Console_Getopt PEAR class (should be standard in most PHP installations) which lets you specify both short and long form options as well as whether or not arguments supplied to an option are themselves 'optional'. Very simple to use and requires very little code to operate compaired to writing own handler.
2. If you cannot load external PEAR objects, use your shell's getopt() functions (which in BASHs case work very well) to process options and have your shell script then call your PHP script with a rigid argument structure that is very easy for PHP to digest such as:
% myfile.php -a TRUE -b FALSE -c ARGUMENT ...
If the initial arguments are invalid you can have the shell script return an error without calling the PHP script. Sounds convoluted but is a very simple solution and in fact PHP's own % pear command uses this method. /usr/bin/pear is a shell script that does some simle checking before calling pearcmd.php and repassing the arguments on to it.
The second method is by far the best for portability because it allows a single shell script to check a few things like your PHP version and respond acordingly e.g. does it call your PHP4 or PHP5 compatible script? Also, because getopt() is not available on Windows, The second solution allows you to do Windows specific testing as a BAT file (as oposed to BASH, ZSH or Korn on UNIX).

nutbar
The code snippet that daevid at daevid dot com gives works, however is not a perfect getopt replacement since you cannot use the "default" switch statement.
Usage: prog [OPTIONS] <req'd argument> <req'd argument>
The switch() call will eventually run on those 2 required arguments.  If you use the "default" statement, it will catch the argument and chances are you use the default statement as your --help trap, thus it will exit the script (if that's what you do).
So, if you use that example below, you may want to check each "argv" variable, and if it doesn't match --*, then you may want to skip past it and store it in another array for retrieval as a required argument if your script uses those.
I will be writing a getopt class that will do everything properly possibly, if/when I do, I'll post it up here so you can all use it rather than the built in getopt code (seems a bit limiting compared to the actual C library getopt_long()).

fertugrul
I have written another function to parse command line variables. The source can be found at http://afe.cc/getopt.txt and the include file generic.h is at http://afe.cc/generic.h .
What you need to do is to put required variables to an array in a specific order and call parse_args. All variables that must be read from command line are set automatically. I've tried to imitate the output of GNU's getopt library.
Hope it helps.
AFE

dante
i didn't like the way getopt worked, exactly, so i wrote a new variant, that other people would possibly like to see. (works more like perl's function)
it reads an array of options like:
$opAr = array ("-a|--append","-l|--list","-i|--input:");
$op = bgetop($opAr);
and parses the command line, returning an array like
$op['cmdline'] = $param;  ...
it has a small bug that can easily be avoided ... haven't yet determined how to work around the particular case where the bug exists, but otherwise is very robust.
it also accepts wildwards as the last option, or the output from another program like 'find' :
./getop.php `find /etc -name *.conf`
populates the $op array with the filenames returned from find.  it's pretty nifty.
the source is at : http://higginsforpresident.net/projects/source/getopt-0.1.phps
i didn't want to post it here until i fixed that one condition, but the function works nicely (as expected) if you don't use duplicate beginnings for different option array strings:
$opAr = array("-f:","--foo");
bgetopt() sees --foo needs no 'next input', but -f exists in '--foo', so ./getop.php -f foobar set's f to 'true', which is the
expected result of array("-f","--foo") or array("-f|--foo"), but not ("-f:","--foo");
enjoy.  (my first submission here ... be kind.)

grange
getopt() will return an empty array if you call it more than once.

klewan
For all buddies outside who dont get getopt to work :)
here is a php variant with just standard function calls
<?
//Set Defaults
$options["a"]="valA";
$options["b"]="valB";
parseArgs($argv,&$options);
//options will be $options["FLAG"] (if not argument is given like -h the $options["h"] will be set to bolean true
if($options["h"] == true) {
       print_usage();
       exit(1);
}
var_dump($options);
function parseArgs($a = array(), $r) {
$f=NULL;
       for($x = 0; $x < count($a); $x++) {
               if($a[$x]{0} == "-") {
                       $f=$a[$x];
                       $r[substr($f,1,strlen($f))]=true;
               }
               if ($f != NULL) {
                       if (($a[$x+1] != NULL) && ($a[$x+1] != "") && ($a[$x+1] != "") && ($a[$x+1]{0} != "-")) {
                               $r[substr($f,1,strlen($f))]=$a[$x+1];
                       } else {
                           $f=$a[x+1];
                       }
               }
       }
}
function print_usage() {
       echo "-a bla bla\n";
       echo "-b bla bla\n";
       echo "-h display this help\n";
}
?>

koenbollen
After you use the getopt function you can use the following script to update the $argv array:
<?php
 $options = "c:ho:s:t:uvV";
 $opts = getopt( $options );
 foreach( $opts as $o => $a )
 {
   while( $k = array_search( "-" . $o, $argv ) )
   {
     if( $k )
       unset( $argv[$k] );
     if( preg_match( "/^.*".$o.":.*$/i", $options ) )
       unset( $argv[$k+1] );
   }
 }
 $argv = array_merge( $argv );
?>
Note: I used the array_merge function to reindex the array's keys.
Cheers, Koen Bollen

andrew dot waite
After having problems with the getopt() function I developed this to handle parameters in a smilar way to 'nix shell script. Hope this is of some us to someone.
#!/usr/bin/php4
<?php
#
# Purpose: Parse parameters passed to script in way comaparable to shell script
# Usage: include_once("/some/path/getArgs.php"); OR
# require_once("/some/path/getArgs.php"); depending on context of parent script
# Post: Generate an associative array $params
#
# Author: A.Waite
# Date: 09/12/05
# Version: V1.0
$i = 1;
$params = array();
for ($i=1; $i < $argc; $i++){
if ( isParam($argv[$i]) ){

if (strlen($argv[$i]) == 1){
//do nothing
// single -
}elseif ( strlen($argv[$i]) == 2){
//seperated (ie -H www.google.com)  or no value parameter (ie. -h)
$paramName = $argv[$i];
$paramVal = ( !isParam( $argv[ $i + 1 ] ) ) ? $argv[$i + 1] : null;
}elseif ( strlen($argv[$i]) > 2){
//joined parameters ie -Hwww.google.com
$paramName = substr($argv[$i],0,2);
$paramVal = substr($argv[$i],2);
}
$params[ $paramName ] = $paramVal;
}
}
#determines whether string is a parameter
function isParam($string){
return ($string{0} == "-") ? 1: 0;
}
?>

17-jan-2007 07:59
About getopt(String):
Parses the command-line arguments into an associative array, using the function's String parameter to specify arguments and options, thus:
* arguments are specified as any letter followed by a colon, e.g. "h:".
* arguments are returned as "h" => "value".
* options are specified as any letter not followed by a colon, e.g. "r".
* options are returned as "r" => (boolean) false.
Also note that:
1) Options or arguments not passed in the command-line parameters are not set in the returned associative array.
2) Options or arguments present in the command-line arguments multiple times are returned as an enumerated array within the returned associative array.

vedanta
A sample use  :
#!/usr/bin/php
<?php
$opt = getopt("s:f:r:u:");
$help="***Error :url_mailer.php -s <subject> -f <sender_email> -r <receipient_email> -u <url_to_mail>";
if($opt[s]=='' || $opt[r]=='' || $opt[u]=='' || $opt[f]=='' ){ echo "$help\n";exit(); }
# prepare the mail message from the url
$url=trim($opt[u]);
$message=file_get_contents($url);
# prepare mail headers
$headers = "MIME-Version: 1.0\r\n";
$headers.= "Content-type: text/html; charset=iso-8859-1\r\n";
$headers.= "From: $opt[f] \r\n";
# send the mail
mail($opt[r],$opt[s],$message,$headers);
?>

gu1ll4um3r0m41n
<?php
function getopt_($opts, $argv) {
$opts_array = explode(':', $opts);
foreach($opts_array as $opt) {
$key = array_search($opt, $argv);
if($key && !in_array($argv[$key+1], $opts_array)) {
$result[$opt] = trim($argv[$key+1]);
} elseif($key) {
$result[$opt] = '';
}
}
return $result;
}
$result = getopt('-h:-o:--help', $argv);
?>

chris
"phpnotes at kipu dot co dot uk" and "tim at digicol dot de" are both wrong or misleading.  Sean was correct.  Quoted space-containing strings on the command line are one argument.  It has to do with how the shell handles the command line, more than PHP.  PHP's getopt() is modeled on and probably built upon the Unix/POSIX/C library getopt(3) which treats strings as strings, and does not break them apart on white space.
Here's proof:
$ cat opt.php
#! /usr/local/bin/php
<?php
$options = getopt("f:");
print_r($options);
?>
$ opt.php -f a b c
Array
(
   [f] => a
)
$ opt.php -f 'a b c'
Array
(
   [f] => a b c
)
$ opt.php -f "a b c"
Array
(
   [f] => a b c
)
$ opt.php -f a\ b\ c
Array
(
   [f] => a b c
)
$

Change Language


Follow Navioo On Twitter
assert_options
assert
dl
extension_loaded
get_cfg_var
get_current_user
get_defined_constants
get_extension_funcs
get_include_path
get_included_files
get_loaded_extensions
get_magic_quotes_gpc
get_magic_quotes_runtime
get_required_files
getenv
getlastmod
getmygid
getmyinode
getmypid
getmyuid
getopt
getrusage
ini_alter
ini_get_all
ini_get
ini_restore
ini_set
main
memory_get_peak_usage
memory_get_usage
php_ini_scanned_files
php_logo_guid
php_sapi_name
php_uname
phpcredits
phpinfo
phpversion
putenv
restore_include_path
set_include_path
set_magic_quotes_runtime
set_time_limit
sys_get_temp_dir
version_compare
zend_logo_guid
zend_thread_id
zend_version
Terms of Service Privacy Policy Sitemap

©2024 -EPSILONSYS SOFTWARE inc

Other EPSILONSYS SOFTWARE Web Sites : Programming Resources | News Headline | Free local classifieds

eXTReMe Tracker