A brief analysis of PHP8.0 features: Named Parameter (named parameters)

I spent some time years ago and made some improvements to the performance of Yar, but I also encountered a problem that made me a little uncomfortable because of the lack of good design. When calling RPC in parallel, the current method prototype is:

public static Yar_Concurrent_Client::call(string $uri, string $method, ?array $arguments = NULL, ?callable $callback = NULL, ?callable $error_callback = NULL, ?array $options = NULL):null|int|bool {}

Is it confusing at first glance?

Because in the actual use process, it is very likely that the callback function and error callback function are empty, because when the call can actually be initiated, that is, when the loop is re-globally specified:

Yar_Concurrent_Client::loop(?callable $callback = NULL, ?callable $error_callback = NULL, ?array $options = NULL):?bool {}

And many times $options are useful, depending on the call, so when actually used, a large number of parallel call codes will write a lot of NULLs in the parameters, similar to:

Yar_Concurrent_Clinet::call("https://xxx.com/api", "method", array("arguments"), NULL, NULL, array(YAR_OPT_HEADER=>array("header:val1"));
Yar_Concurrent_Clinet::call("https://xxx.com/api", "method", array("arguments"), NULL, NULL, array(YAR_OPT_HEADER=>array("header:val2"));
Yar_Concurrent_Clinet::call("https://xxx.com/api", "method", array("arguments"), NULL, NULL, array(YAR_OPT_HEADER=>array("header:val2"));
Yar_Concurrent_Clinet::call("https://xxx.com/api", "method", array("arguments"), NULL, NULL, array(YAR_OPT_HEADER=>array("header:val4"));

So I have been Thinking about how to make such calls more elegant, I once wanted to use polymorphism, or add a new API, similar to:

public static Yar_Concurrent_Client::callArray(array $arguments):null|int|bool {}

But my obsessive-compulsive disorder made me feel that doing so would cause endless trouble. This morning I suddenly I remembered an RFC I had seen before, so I searched for a long time and found that it had been committed as early as PHP5.6. But anyway, I am relatively old-school and have done little research on new features and have not used them much. I don’t know what everyone is saying. Whether it will be used. ?

is the first feature to be introduced today: Argument unpacking.

Argument unpacking

We know that PHP supports variable parameters, that is, variadic function. For example, for the following function definition:

function variadic(...$arguments) {
    var_dump($arguments);
}

Pay attention to the definition of parameters, using three Dot... (ellipsis symbol), which means that no matter how many parameters you pass when calling this function, these parameters will be packed into an array named $arguments:

variadic();
//output: array(0) { }
variadic(NULL);
//output: array(1) { [0]=> NULL }
variadic("foo", "bar");
//output: array(2) { [0]=> string(3) "foo"  [1]=> string(3) "bar" }
variadic(NULL, array(), "dummy");
//output: array(3) { [0]=> NULL [1]=>[] [2]=> string(5) "dummy" }

Of course, this is not what we have today To be used, this feature also has a corresponding sibling form used at the time of calling, called argument unpacking:

For example, similar to my question above, we defined a function

function dummy($a, $b = NULL, $c = NULL, $d = NULL, $e = NULL) {
    var_dump($a, $b, $c, $d, $e);
}

If our parameters b, c, d are all NULL in most cases, but e may need to be passed, then we can use argument unpacking to avoid a large number of NULL parameters in the code, similar to:

$arguments = array(
    "First argument",
    NULL,  NULL,  NULL,
    "Fifth argument",
);

dummy(...$arguments);

//output:
// string(14) "First argument"
// NULL
// NULL
// NULL
// string(14) "Fifth argument"

Note When calling, I also used..., which means to unwrap the array after... and pass it to the called function in order. The first element corresponds to the first parameter, and the second element corresponds to the third parameter. Two.

But note that the position here is related to the filling position and has nothing to do with the index. That is to say:

$arguments = array(
    4=> "First argument",
    0=> "Fifth argument"
),

In this form, index 4 is still considered the first parameter.

After thinking about this, I suddenly realized that I don’t need to introduce new things to Yar. The most open example can be:

$arguments = array(
    "https://xxx.com/api",
    "method",
    array("arguments"),
    NULL, NULL,
    "options" => array(YAR_OPT_HEADER => array("header:val1")
)
Yar_Concurrent_Clinet::call(...$arguments);

$arguments["options"][YAR_OPT_HADER] = ["header:val2"];
Yar_Concurrent_Clinet::call(...$arguments);

$arguments["options"][YAR_OPT_HADER] = ["header:val3"];
Yar_Concurrent_Clinet::call(...$arguments);

$arguments["options"][YAR_OPT_HADER] = ["header:val4"];
Yar_Concurrent_Clinet::call(...$arguments);
Yar_Concurrent_Clinet::call(...$arguments);

Do you think this is over?

Considering the above code, there is still a problem, that is, we need to construct an intermediate array. For those of us with obsessive-compulsive disorder, we still feel that it is a bit, so what...

But in fact we You can also use another RFC introduced in PHP8.0, Named parameter:

Named Parameter

After PHP8.0, users are allowed to specify the parameter name when passing parameters, such as For the above example function:

function dummy($a, $b = NULL, $c = NULL, $d = NULL, $e = NULL) {
    var_dump($a, $b, $c, $d, $e);
}

Now we can specify the parameter name to be passed when calling, such as:

dummy(a:"dummy", e:"foo");
//output:
// string(5) "dummy"
// NULL
// NULL
// NULL
// string(3) "foo"

In other words, I specified the parameters to be passed to a and e , the default value is the default value if it is not specified, you can even do it out of the order of declaration, for example:

dummy(e:"foo", a:"dummy");

The output result is the same.

In this way, the beginning code can become:

Yar_Concurrent_Client::call("https://xxx.com/api", "method", arguments:array("arguments"), options:array(YAR_OPT_HEADER=>array("header:val1")));
Yar_Concurrent_Client::call("https://xxx.com/api", "method", arguments:array("arguments"), options:array(YAR_OPT_HEADER=>array("header:val2")));
Yar_Concurrent_Client::call("https://xxx.com/api", "method", arguments:array("arguments"), options:array(YAR_OPT_HEADER=>array("header:val3")));
Yar_Concurrent_Client::call("https://xxx.com/api", "method", arguments:array("arguments"), options:array(YAR_OPT_HEADER=>array("header:val4")));

You can pass that and that when you call, and pass however you want

Although the code is still a bit longer than argument unpacking, it solves the problem of not having to write so many NULLs and does not introduce new intermediate variables.

So, the problem is solved perfectly, and I don’t need to introduce a new API:)

Original address: https://www.laruence.com/2022/05/10/ 6192.html

Recommended learning: "PHP Video Tutorial"

The above is the detailed content of A brief analysis of PHP8.0 features: Named Parameter (named parameters). For more information, please follow other related articles on the PHP Chinese website!