You want to define a function that takes a variable number of arguments.

Pass the function a single array-typed argument and put your variable arguments inside the array:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// find the "average" of a group of numbers function mean($numbers) { // initialize to avoid warnings $sum = 0; // the number of elements in the array $size = count($numbers); // iterate through the array and add up the numbers for ($i = 0; $i < $size; $i++) { $sum += $numbers[$i]; } // divide by the amount of numbers $average = $sum / $size; // return average return $average; } // $mean is 96.25 $mean = mean(array(96, 93, 98, 98)); |

There are two good solutions, depending on your coding style and preferences. The more traditional PHP method is the one described in the Solution.

We prefer this method because using arrays in PHP is a frequent activity; therefore, all programmers are familiar with arrays and their behavior.

So although this method creates some additional overhead, bundling variables is commonplace.

Also, inside the function, the syntax to access and manipulate the array involves basic commands such as $array[$i] and count($array).

However, this can seem clunky, so PHP provides an alternative and allows you direct access to the argument list, as shown in *Example 6-1*.

*Example 6-1. Accessing function parameters without using the argument list*

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// find the "average" of a group of numbers function mean() { // initialize to avoid warnings $sum = 0; // the arguments passed to the function $size = func_num_args(); // iterate through the arguments and add up the numbers for ($i = 0; $i < $size; $i++) { $sum += func_get_arg($i); } // divide by the amount of numbers $average = $sum / $size; // return average return $average; } // $mean is 96.25 $mean = mean(96, 93, 98, 98); |

This example uses a set of functions that return data based on the arguments passed to the function they are called from.

First, **func_num_args()** returns an integer with the number of arguments passed into its invoking function—in this case, **mean()**.

From there, you can then call **func_get_arg()** to find the specific argument value for each position.

When you call mean(96, 93, 98, 98),** func_num_args()** returns 4.

The first argument is in position 0, so you iterate from 0 to 3, not 1 to 4. That’s what happens inside the for loop where $i goes from 0 to less than $size.

As you can see, this is the same logic used in the Solution in which an array was passed. If you’re worried about the potential overhead from using **func_get_arg()** inside a loop, don’t be.

This version is actually faster than the array-passing method.

There is a third version of this function that uses** func_get_args()** to return an array containing all the values passed to the function.

It ends up looking like a hybrid between the previous two functions, as shown in *Example 6-2*.

*Example 6-2. Accessing function parameters without using the argument list*

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// find the "average" of a group of numbers function mean() { // initialize to avoid warnings $sum = 0; // the arguments passed to the function $size = func_num_args(); // iterate through the arguments and add up the numbers foreach (func_get_args() as $arg) { $sum += $arg; } // divide by the amount of numbers $average = $sum / $size; // return average return $average; } // $mean is 96.25 $mean = mean(96, 93, 98, 98); |

Here you have the dual advantages of not needing to place the numbers inside a temporary array when passing them into **mean()**, but inside the function you can continue to treat them as if you did.