CODEWITHSUNDEEP
php
Er.KT
Er.KT

Reputation: 2860

pass value for last default parameter of function

From very long time i am working on php.

But one question may I have no idea about

like I have one function as bellow:

function hello($param1, $param2="2", $param3="3", $param4="4")

Now whenever I will use this function and if I need 4th params thats the $param4 then still I need to call all as blank like this one:

hello(1, '', '', "param4");

So is there any another way to just pass 1st and 4th param in call rather then long list of blanks ?

Or is there any other standard way for this ?

Upvotes: 4

Views: 622

Answers (4)

sevavietl
sevavietl

Reputation: 3802

It is an overhead, but you can use ReflectionFunction to create a class, instance of which that can be invoked with named parameters:

final class FunctionWithNamedParams
{
    private $func;

    public function __construct($func)
    {
        $this->func = $func;
    }

    public function __invoke($params = [])
    {
        return ($this->func)(...$this->resolveParams($params));
    }

    private function resolveParams($params)
    {
        $rf = new ReflectionFunction($this->func);

        return array_reduce(
            $rf->getParameters(),
            function ($carry, $param) use ($params) {
                if (isset($params[$param->getName()])) {
                    $carry[] = $params[$param->getName()];
                } else if ($param->isDefaultValueAvailable()) {
                    $carry[] = $param->getDefaultValue();
                } else {
                    throw new BadFunctionCallException;
                }

                return $carry;
            },  
            []
        );
    }
}

Then you can use it like this:

function hello($param1, $param2 = "2", $param3 = "3", $param4 = "4")
{
    var_dump($param1, $param2, $param3, $param4);
}

$func = new FunctionWithNamedParams('hello');

$func(['param1' => '1', 'param4' => 'foo']);

Here is the demo.

Upvotes: 0

MonkeyZeus
MonkeyZeus

Reputation: 20737

There was an RFC for this named skipparams but it was declined.

PHP has no syntactic sugar such as hello(1, , , "param4"); nor hello(1, default, default, "param4"); (per the RFC) for skipping optional parameters when calling a function.

If this is your own function then you can choose the common jQuery style of passing options into plug-ins like this:

function hello( $param1, $more_params = [] )
{
    static $default_params = [
        'param2' => '2',
        'param3' => '3',
        'param4' => '4'
    ];

    $more_params = array_merge( $default_params, $more_params );
}

Now you can:

hello( 1, [ 'param4'=>'not 4, muahaha!' ] );

If your function requires some advanced stuff such as type hinting then instead of array_merge() you will need to manually loop $more_params and enforce the types.

Upvotes: 5

R. Smith
R. Smith

Reputation: 548

The answer, as I see it, is yes and no.

No, because there's no way to do this in a standard fashion.

Yes, because you can hack around it. This is hacky, but it works ;)

Example:

function some_call($parm1, $parm2='', $parm3='', $parm4='') { ... }

and the sauce:

function some_call_4($parm1, $parm4) {
    return some_call($parm1, '', '', $parm4);
}

So if you make that call ALOT and are tired of typing it out, you can just hack around it.

Sorry, that's all I've got for you.

Upvotes: -1

GrumpyCrouton
GrumpyCrouton

Reputation: 8621

One potential way you can do this, while a little bit hacky, may work well in some situations.

Instead of passing multiple variables, pass a single array variable, and inside the function check if the specific keys exist.

function hello($param1, $variables = ["param2" => "2", "param3" => "3", "param4" => "4"]) {
    if(!array_key_exists("param2", $variables)) $variables['param2'] = "2";
    if(!array_key_exists("param3", $variables)) $variables['param3'] = "3";
    if(!array_key_exists("param4", $variables)) $variables['param4'] = "4";

    echo "<pre>".print_r($variables, true)."</pre>";
}

This will allow you to set "param4" in the above variable, while still remaining default on all of the others.

Calling the function this way:

hello("test", ["param4" => "filling in variable 4"]);

Will result in the output being:

Array
(
    [param4] => filling in variable 4
    [param2] => 2
    [param3] => 3
)

I don't generally recommend this if it can be avoided, but if you absolutely need this functionality, this may work for you.

The key here is that you have a specifically named index inside the array being passed, that you can check against inside the function itself.

Upvotes: 0

Related Questions