Eine kurze Analyse der PHP8.0-Funktionen: Benannte Parameter (benannte Parameter)

Ich habe vor Jahren einige Zeit damit verbracht, die Leistung von Yar zu verbessern, aber ich bin auch auf ein Problem gestoßen, das mich aufgrund des Mangels an gutem Design am Anfang, dh beim parallelen Aufruf von RPC, etwas unwohl gefühlt hat Der aktuelle Methodenprototyp ist:

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

Sieht das auf den ersten Blick nicht überwältigend aus?

Denn bei der tatsächlichen Verwendung ist es sehr wahrscheinlich, dass die Rückruffunktion und die Fehlerrückruffunktion leer sind, denn wenn der Anruf tatsächlich initiiert werden kann, dh wenn die Schleife erneut global angegeben wird:

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

Und oft $ Optionen sind je nach Aufruf nützlich, sodass bei tatsächlicher Verwendung bei einer großen Anzahl paralleler Aufrufcodes viele NULL-Werte in die Parameter geschrieben werden, ähnlich wie:

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

Ich habe mir also immer Gedanken gemacht, wie man solche Aufrufe eleganter gestalten kann . Ich wollte einmal Polymorphismus verwenden oder eine neue API hinzufügen, ähnlich wie:

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

, aber eine Zwangsstörung hatte das Gefühl, dass dies endlose Katastrophen mit sich bringen würde. Heute Morgen fiel mir plötzlich ein RFC ein Ich hatte es schon einmal gesehen, also habe ich lange gesucht und festgestellt, dass es bereits mit PHP 5.6 festgeschrieben wurde, aber ich bin sowieso relativ altmodisch, habe wenig über neue Funktionen recherchiert und sie nicht oft verwendet, also habe ich Ich weiß nicht, ob jeder sie nutzen wird. ?

Dies ist die erste Funktion, die heute eingeführt wird: Argument-Entpacken.

Argument-Entpacken

Wir wissen, dass PHP variable Parameter unterstützt, also variadische Funktionen. Zum Beispiel für die folgende Funktionsdefinition:

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

Achten Sie auf die Definition von Parametern, indem Sie drei Punkte verwenden ... (Auslassungszeichen). Dies bedeutet, dass unabhängig davon, wo Sie sich befinden, wie viele Parameter beim Aufrufen dieser Funktion übergeben werden, diese Parameter in ein Array mit dem Namen $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" }

gepackt werden. Dies ist natürlich nicht das, was wir heute verwenden werden, diese Funktion verfügt auch über diese Funktion eine entsprechende, die zum Zeitpunkt des Aufrufs verwendet wird. Die Geschwisterform von heißt Argument auspacken:

Zum Beispiel definieren wir ähnlich wie bei meiner Frage oben eine Funktion

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

Wenn in den meisten Fällen unsere Parameter b, c, d sind alles NULL, aber möglicherweise muss e übergeben werden. Dann können wir das Entpacken von Argumenten verwenden, um eine große Anzahl von NULL-Parametern im Code zu vermeiden, ähnlich wie:

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

Beachten Sie, dass ich beim Aufruf auch ... verwendet habe, was das bedeutet besteht darin, das Array nach ... zu entpacken und in der richtigen Reihenfolge zu ordnen. An die aufgerufene Funktion übergeben, entspricht das erste Element dem ersten Parameter und das zweite Element dem zweiten.

Aber beachten Sie, dass die Position hier mit der Füllposition zusammenhängt und nichts mit dem Index zu tun hat. Das heißt:

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

In dieser Form wird Index 4 immer noch als erster Parameter betrachtet.

Nachdem ich darüber nachgedacht hatte, wurde mir plötzlich klar, dass ich Yar keine neuen Dinge vorstellen muss. Das häufigste Beispiel kann sein:

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

Glaubst du, das ist vorbei?

In Anbetracht des obigen Codes gibt es immer noch ein Problem, das heißt, wir müssen ein Zwischenarray erstellen. Für diejenigen von uns mit Zwangsstörungen haben wir immer noch das Gefühl, dass es ein bisschen ...

Aber tatsächlich , wir können auch die in PHP8.0 eingeführte Methode verwenden. Ein weiterer RFC, benannter Parameter:

Named Parameter

Nach PHP8.0 dürfen Benutzer Parameternamen angeben, wenn sie Parameter übergeben, zum Beispiel für die obige Beispielfunktion:

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

Jetzt können wir es beim Aufrufen aufrufen und den Namen des zu übergebenden Parameters angeben, z. B.:

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

Mit anderen Worten, ich habe die Parameter angegeben, die an a und e übergeben werden sollen, und der Standardwert ist der Standardwert if nicht angegeben. Sie können die Reihenfolge der Deklaration nicht einmal befolgen, z. B.:

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

Die Ausgabe ist dieselbe.

Auf diese Weise kann der Code am Anfang lauten:

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

Du kannst übergeben, was du willst und das, wenn du es aufrufst

Obwohl der Code im Vergleich zum Entpacken von Argumenten immer noch etwas lang ist, ist es beides. Dies löst das Problem, nicht so viele NULL-Werte schreiben zu müssen und keine neuen Zwischenvariablen einzuführen.

Das Problem ist also perfekt gelöst und ich muss keine neue API einführen:)

Ursprüngliche Adresse: https://www.laruence.com/2022/05/10/6192.html

Empfohlene Studie: „ PHP-Video-Tutorial》

Das obige ist der detaillierte Inhalt vonEine kurze Analyse der PHP8.0-Funktionen: Benannte Parameter (benannte Parameter). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!