Une brève analyse des fonctionnalités de PHP8.0 : paramètre nommé (paramètres nommés)

J'ai passé du temps il y a des années à améliorer les performances de Yar, mais j'ai également rencontré un problème qui m'a laissé un peu mal à l'aise en raison du manque de bonne conception au début, c'est-à-dire lors de l'appel de RPC en parallèle, Le Le prototype actuel de la méthode est :

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 {}

Cela ne semble-t-il pas écrasant à première vue ?

Parce qu'en utilisation réelle, il est très probable que la fonction de rappel et la fonction de rappel d'erreur soient vides, car lorsque l'appel peut réellement être lancé, c'est-à-dire lorsque la boucle est spécifiée de manière globale :

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

Et plusieurs fois $ les options sont utiles, en fonction de l'appel, donc lorsqu'elles sont réellement utilisées, un grand nombre de codes d'appel parallèles écriront beaucoup de NULL dans les paramètres, semblable à :

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"));

J'ai donc toujours réfléchi à la façon de rendre de tels appels plus élégants . Une fois, j'ai voulu utiliser le polymorphisme, ou ajouter une nouvelle API, similaire à :

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

, mais le trouble obsessionnel-compulsif m'a fait sentir que cela entraînerait un désastre sans fin. Ce matin, je me suis soudainement souvenu d'un RFC. J'en avais déjà vu auparavant, alors j'ai cherché longtemps et j'ai trouvé qu'il était validé dès PHP 5.6, mais je suis de toute façon relativement old-school, j'ai fait peu de recherches sur les nouvelles fonctionnalités et je ne les ai pas beaucoup utilisées, donc j'ai je ne sais pas si tout le monde les utilisera. ?

C'est la première fonctionnalité introduite aujourd'hui : le déballage des arguments.

Déballage des arguments

Nous savons que PHP prend en charge les paramètres variables, c'est-à-dire les fonctions variadiques. Par exemple, pour la définition de fonction suivante :

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

Faites attention à la définition des paramètres, en utilisant trois points... (symbole de points de suspension). , ce qui signifie que peu importe où vous vous trouvez. Combien de paramètres sont passés lors de l'appel de cette fonction, ces paramètres seront regroupés dans un tableau nommé $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" }

Bien sûr, ce n'est pas ce que nous utiliserons aujourd'hui, cette fonctionnalité a également un correspondant qui est utilisé au moment de l'appel La forme sœur de est appelée déballage d'argument :

Par exemple, similaire à ma question ci-dessus, nous définissons une fonction

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

Si dans la plupart des cas nos paramètres b, c, d sont tous NULL, mais e devra peut-être être passé. Ensuite, nous pouvons utiliser le déballage des arguments pour éviter un grand nombre de paramètres NULL dans le code, similaire à :

$arguments = array(
    "First argument",
    NULL,  NULL,  NULL,
    "Fifth argument",
);
 
dummy(...$arguments);
 
//output:
// string(14) "First argument"
// NULL
// NULL
// NULL
// string(14) "Fifth argument"

Notez que lors de l'appel, j'ai également utilisé..., ce que cela signifie consiste à décompresser le tableau après... et à les séquencer dans l'ordre. Passé à la fonction appelée, le premier élément correspond au premier paramètre et le deuxième élément correspond au second.

Mais notez que la position ici est liée à la position de remplissage et n'a rien à voir avec l'index C'est-à-dire :

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

Dans ce formulaire, l'index 4 est toujours considéré comme le premier paramètre.

Après avoir réfléchi à cela, j'ai soudain réalisé que je n'avais pas besoin d'introduire de nouvelles choses à Yar. L'exemple le plus courant peut être :

$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);

Pensez-vous que c'est fini ?

Considérant le code ci-dessus, il y a toujours un problème, c'est-à-dire que nous devons construire un tableau intermédiaire. Pour ceux d'entre nous souffrant de trouble obsessionnel-compulsif, nous pensons toujours que c'est un peu...

Mais en fait. , nous pouvons également utiliser la méthode introduite dans PHP8.0. Une autre RFC, Paramètre nommé :

Paramètre nommé

Après PHP8.0, les utilisateurs sont autorisés à spécifier des noms de paramètres lors du passage des paramètres. Par exemple, pour l'exemple de fonction ci-dessus :

.

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

Maintenant, nous pouvons l'appeler quand , spécifier le nom du paramètre à passer, tel que :

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

En d'autres termes, j'ai spécifié les paramètres à passer à a et e, et la valeur par défaut est la valeur par défaut si non précisé. Vous pouvez même ne pas suivre l'ordre de déclaration, tel que :

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

Le résultat est le même.

De cette façon, le code au début peut devenir :

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")));

Vous pouvez transmettre ce que vous voulez et cela lorsque vous l'appelez

Bien que le code soit encore un peu long par rapport au déballage des arguments, c'est à la fois Cela résout le problème de ne pas avoir à écrire autant de NULL et de ne pas introduire de nouvelles variables intermédiaires.

Le problème est donc parfaitement résolu, et je n'ai pas besoin d'introduire une nouvelle API :)

Adresse originale : https://www.laruence.com/2022/05/10/6192.html

Etude recommandée : " Tutoriel vidéo PHP》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!