Using an associative array as php function's input

The downside is that anyone looking at your code (other than you) would have no idea what parameters are coming into a method, where they came from, or what they are for. They would also have no idea how to call a method since it isn't clear without looking at the code exactly what is required inside that "parameter array".

presumably one of the downsides is that you'll end up with way too many parameters. This leads to the problem that the code is likely to lose it's readability.

In a strict Object-Oriented approach you would convert all these parameters that are "passed through" multiple function-calls into instance-variables of the classes holding the methods.

You should never pass parameters to functions that are not actually required by them.

This isn't necessarily that bad of an idea, since PHP lacks the "keyword arguments" feature found in many other modern programming languages (Python, Ruby, etc.). However, there are definitely a few problems with it:

1. If you change the parameters that a function accepts, then it's likely you'll have to change some code where it's called anyway, to match the new parameters.

2. If you're using these arrays extensively, and in many function calls taking an array and simply "passing it along," that might be a sign that you should think about turning some of those parameters into a structured class.

3. If you're using these arrays as a mutable data structure, you don't necessarily know that the array you have after calling the function is the same as the one you passed in. This will probably come back to get you at some point.

Listing each parameter can increase code readability. Passing a single associative array wouldn't necessarily explain what kind(s) of data are being passed to a function.

If I were to pick up your function and see that it simply starts referencing hash values within a single function argument, I would be a bit confused. Explicitly stating the variables and giving a bit of documentation within a docblock using @param helps tremendously. Having to add an argument in two places is a minor cost compared to the readability listing arguments yields.

I personally use the following method:

1. declare the parameter as an array in the function definition;

2. establish a "default values" assoc. array;

3. match passed params with the default into a definitive parameters assoc.array that I use inside the function. For this purpose I use the param_default() function.

By following this method I avoid mandatory params issues and manage default values; also the ability to pass keys in any order is very comfortable.

// default values fx.
function param_default( $def = array(), $parameters= array() ){
    $parm_diff = array();
    $ak=array();
    $va=array();
    $parm = array();
    foreach($def as $key=>$values) if(!in_array($key, array_keys($parameters))){
        $ak[]=$key;
        $va[]=$values;
    }
    $parm_diff = array_combine($ak,$va);
    $parm = array_merge($parm_diff,$parameters);
    unset($parm_diff, $ak,$va);

    return $parm;
}

So this is a simple example of usage:

<?php
// sample use 
 function my_func( $parameters = array() ){
    $def = array(
        'first' => 1,
        'second' => 'foo',
        'third' => -1
     );
   $parm = param_default( $def, $parameters );
   //hereon I can use my array

   var_dump($param);

   if ($param['second'] !=='foo'){
       echo 'Not foo!!';
       // whatever...
   }

   return true;
}
?>

Example of output:

 // calling my_fun()

$example = my_func( array('second'=>'bar') );

// results in 
$param array: 
'first' => 1,
'second' => 'bar',
'third' => -1

The biggest code smell here is that adding another variable would cascade through 4-5 different functions. I can't really think of a reason this would need to happen.

It sounds like you need to refactor this code into a class so that then you can pass the values into a constructor one time, and save them as member variables.

It makes it a lot easier to generate documentation if you have the parameters named and passed in separately. You might think using an array makes it easier to add new code, but the upside there doesn't beat out readability. Plus go away from your code for 2 months and come back...figuring out in what order to add params to your array in which situations will become a massive headache.

In some cases this does make sense I feel, but often you can simplify things by creating multiple methods with slightly different behaviours. The name of the method will then make it clear what it's for.

In general if your functions have > 3 arguments it will become unreadable anyway.

As an alternative, and often used pattern is making the single argument of your function a (classed-)object. The 'parameter class' will define exactly what's supported.

If someone's still searching for a solution - here it is (example-function is __construct() ):

Extract $_GET/$_POST params and pass them to constructor

if your quetion is that how to give an array as inputof function, this is your Answer:

<?php
 function city($input){
   $i=count($input['iran']);
   $result="";
     for($b=1;$b<=$i;$b++){
       $result.='<div style="background:gold">'.$input['iran'][$b].'</div>';
       }
      return $result;
    }
$cityName['iran'][1]="Tehran";
$cityName['iran'][2]="Qom";
$cityName['iran'][3]="MashHad";
$cityName['iran'][4]="Isfahan";
$cityName['iran'][5]="Shiraz";
$cityName['iran'][6]="Yazd";

echo city($cityName);
?>

Create the function:

function testing($argumentos) {
    $var_1 = $argumentos['var_01'];
    $var_2 = $argumentos['var_02'];

    echo $var_1 . " " . $var_2;
} 

Call the function:

testing(array('var_01' => "mierda", 'var_02' => "conio!"));

Output:

 mierda conio!