函数简化参数列表

When calling a function is there a way to simplify the argument list? Instead of using $blank.

$subscribe=1;
    $database->information($blank,$blank,$blank,$blank,$blank,$blank,$subscribe,$blank,$blank,$blank,$blank,$blank);



    function information ($search,$id,$blank,$category,$recent,$comment,$subscribe,$pages,$pending,$profile,$deleted,$reported) {
    //code
    }

You could pass in an array with the specified keys, and merge it with an array of default values

So instead of

function foo($arg1 = 3, $arg2 = 5, $arg3 = 7) { }

You'd have

function foo($args) {
   $defaults = array(
      'arg1' => '',
      'arg2' => null,
      'arg3' => 7
   );

   // merge passed in array with defaults
   $args = array_merge($defaults, $args);

   // set variables within local scope
   foreach($args as $key => $arg) { 
       // this is to make sure that only intended arguments are passed
       if(isset($defaults[$key])) ${$key} = $arg; 
   }

    // rest of your code
}

Then call it as

foo(array('arg3' => 2));

Yes, pass an array instead, or refactor. A long arguments list is usually a bad smell.

function information(array $params) {....

information(array('search'=>'.....

You can make it so the function wil automatically fill the variable with a given value like an empty string:

function information ($subscribe, $search="", $id="", $blank="", $category="", $recent="", $comment="", $pages="", $pending="", $profile="", $deleted="", $reported="") {
    //code
}

Twelve arguments are generally too many for one function. It's likely that your code could be simplified (including the argument lists getting shorter) by refactoring function information which looks likely to be a monster.

Stopgap measures you can use in the meantime are

• adding default argument values
• making the function accept all its arguments as an array

Both of the above will require you to visit all call sites for the function for review and modification.

Adding default arguments is IMHO the poor choice here, as by looking at the example call it seems that you would need to make all arguments default, which in turn means that the compiler will never warn you if you call the function wrongly by mistake.

Converting to an array is more work, but it forces you to rewrite the calls in a way that's not as amenable to accidental errors. The function signature would change to

function information(array $params)

or possibly

function information(array $params = array())

if you want all parameters to be optional. You can supply defaults for the parameters with

function information(array $params) {
    $defaults = array('foo' => 'bar', /* ... */);
    $params += $defaults; // adds missing values that have defaults to $params;
                          // does not overwrite existing values

To avoid having to rewrite the function body, you can then use export to pull out these values from the array into the local scope:

    export($params); // creates local vars
    echo $foo; // will print "bar" unless you have given another value

See all of this in action.

Yes, there are several ways:

• Accept an associative array as a single argument, and pass what you need to that. Throw exceptions if a critical argument is missing.
• Place critical arguments at the head of the function definition, and optional ones at the end. Give them a default value so that you don't have to declare them.
• Recosinder your function. 12 arguments is much too many for one function. Consider using a class/object, or dividing the work between different functions.

Several ways:

function test($input = "some default value") {
    return $input; // returns "some default value"
}

function test($input) {
    return $input;
}

test(NULL); // returns NULL

function test() {
   foreach(func_get_args() as $arg) {
       echo $arg;
   }
}

test("one", "two", "three"); // echos: onetwothree