Analisis ringkas ciri PHP8.0: Parameter Dinamakan (parameter bernama)

Saya telah meluangkan masa beberapa tahun yang lalu untuk meningkatkan prestasi Yar, tetapi saya juga menghadapi masalah yang membuat saya sedikit tidak selesa kerana kekurangan reka bentuk yang baik semasa memanggil RPC secara selari, prototaip kaedah semasa ialah:

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

Tidakkah ia kelihatan menggembirakan pada pandangan pertama?

Oleh kerana dalam penggunaan sebenar, fungsi panggil balik dan fungsi panggil balik ralat berkemungkinan besar kosong, kerana apabila panggilan sebenarnya boleh dimulakan, iaitu apabila gelung ditentukan semula secara global:

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

Dan banyak kali $options berguna, bergantung pada panggilan, jadi apabila benar-benar digunakan, sejumlah besar kod panggilan selari akan menulis banyak NULL dalam parameter, serupa dengan:

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

Jadi saya telah memikirkan cara untuk membuat panggilan sedemikian lebih elegan Pada satu masa, saya ingin menggunakan polimorfisme, atau menambah API baharu, serupa dengan:

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

Tetapi gangguan obsesif-kompulsif dibuat. Saya merasakan bahawa melakukan itu akan membawa malapetaka, pagi ini saya tiba-tiba teringat RFC yang saya lihat sebelum ini, jadi saya mencari untuk masa yang lama dan mendapati ia telah dilakukan seawal PHP5.6 Tetapi bagaimanapun, saya agak tua -sekolah dan telah melakukan sedikit penyelidikan tentang ciri baharu, jadi ia tidak berguna saya tidak tahu sama ada semua orang akan menggunakannya. ?

ialah ciri pertama yang diperkenalkan hari ini: Membongkar hujah.

Pembukaan hujah

Kami tahu bahawa PHP menyokong parameter pembolehubah, iaitu fungsi variadik Contohnya, untuk definisi fungsi berikut:

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

Beri perhatian kepada. takrifan parameter, menggunakan Tiga titik... (simbol elipsis), yang bermaksud bahawa tidak kira berapa banyak parameter yang anda lalui semasa memanggil fungsi ini, parameter ini akan dimasukkan ke dalam tatasusunan bernama $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" }

Sudah tentu, Ini bukan perkara yang akan kami gunakan hari ini Ciri ini juga mempunyai bentuk adik beradik yang sepadan yang digunakan semasa membuat panggilan, dipanggil pembongkaran hujah:

Sebagai contoh, sama dengan soalan saya di atas, kami. mentakrifkan fungsi

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

Jika parameter b, c, d kami semuanya NULL dalam kebanyakan kes, tetapi e mungkin perlu diluluskan, maka kami boleh menggunakan pembongkaran hujah untuk mengelakkan sejumlah besar parameter NULL dalam kodnya, serupa dengan:

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

Perhatikan bahawa semasa membuat panggilan, saya juga menggunakan.... Ini bermakna tatasusunan selepas... dilepaskan dan dihantar ke fungsi yang dipanggil mengikut urutan elemen pertama sepadan dengan parameter pertama, yang kedua sepadan dengan yang kedua.

Tetapi ambil perhatian bahawa jawatan di sini adalah berkaitan dengan jawatan pengisian dan tiada kaitan dengan indeks iaitu:

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

Dalam borang ini, indeks 4 masih dipertimbangkan. satu parameter pertama.

Setelah memikirkan perkara ini, tiba-tiba saya menyedari bahawa saya tidak perlu memperkenalkan perkara baharu kepada Yar Contoh paling mudah ialah:

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

Adakah anda rasa ini sudah berakhir?

Memandangkan kod di atas, masih ada masalah, iaitu, kita perlu membina tatasusunan perantaraan Bagi kita yang mengalami gangguan obsesif-kompulsif, kita masih merasakan bahawa ia adalah sedikit...

Tetapi sebenarnya kami Anda juga boleh menggunakan RFC lain yang diperkenalkan dalam PHP8.0, Parameter bernama:

Named Parameter

Selepas PHP8.0, pengguna dibenarkan untuk menentukan parameter nama apabila menghantar parameter, seperti Untuk fungsi contoh di atas:

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

Sekarang kita boleh menentukan nama parameter yang akan dihantar semasa memanggil, seperti:

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

Dalam erti kata lain , saya menyatakan nama parameter yang akan dihantar ke Untuk parameter a dan e, jika ia tidak dinyatakan, ia adalah nilai lalai Anda tidak boleh mengikut susunan pengisytiharan, contohnya:

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

Hasil output akan sama.

Dengan cara ini, kod pada permulaan boleh menjadi:

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

Anda boleh lulus itu dan itu apabila anda memanggilnya, dan luluskannya mengikut cara yang anda mahu

Walaupun kod itu masih lebih panjang sedikit daripada pembongkaran hujah, ia menyelesaikan masalah tidak perlu menulis begitu banyak NULL dan tidak memperkenalkan pembolehubah perantaraan baharu.

Jadi, masalah itu diselesaikan dengan sempurna, dan saya tidak perlu memperkenalkan API baharu:)

Alamat asal: https://www.laruence.com/2022 /05/10/ 6192.html

Pembelajaran yang disyorkan: "Tutorial Video PHP"

Atas ialah kandungan terperinci Analisis ringkas ciri PHP8.0: Parameter Dinamakan (parameter bernama). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!