Php 8.1 tidak memperkenalkan sintaks yang boleh dipanggil kelas pertama; Ciri ini akan datang dalam Php 8.4. 1. Sebelum Php 8.4, panggilan balik menggunakan rentetan, tatasusunan, atau penutupan, yang rawan kesilapan dan kekurangan sokongan IDE. 2. Php 8.1 meningkatkan ekosistem dengan enum, serat, dan menaip yang lebih baik tetapi tidak mengubah sintaks yang boleh dipanggil. 3. Php 8.4 memperkenalkan callables kelas pertama menggunakan sintaks seperti strlen (...) atau className :: method (...), di mana (...) mencipta panggilan tanpa memanggilnya. 4. Manfaat termasuk penghapusan callables berasaskan rentetan, sokongan IDE dan analisis statik, kod bersih, dan keselamatan jenis yang lebih baik. 5. Contoh seperti USORT ($ pengguna, pengguna :: CompareByName (...)) menunjukkan penggunaan panggilan balik yang lebih mudah dibaca dan boleh dipercayai. Evolusi ini menjadikan panggilan balik lebih selamat dan lebih banyak dikekalkan dalam pembangunan PHP moden.

PHP telah lama menyokong panggilan balik melalui rentetan, tatasusunan, dan kelas Closure , tetapi bekerja dengan mereka sering kali bergelora dan rawan kesilapan. PHP 8.1 memperkenalkan sintaks yang boleh dipanggil kelas pertama, penukar permainan yang memudahkan bagaimana kita merujuk dan meluluskan fungsi, kaedah, dan kaedah statik sebagai callables-tanpa mencetuskan panggilan fungsi atau memerlukan sintaks kompleks.

Apakah callables kelas pertama?

Sintaks yang boleh dipanggil kelas pertama membolehkan anda merujuk fungsi, kaedah, atau kaedah statik menggunakan ... sintaks (walaupun tidak ellipsis) -sebenarnya, ia adalah pembinaan sintaktik baru menggunakan nama -nama fungsi terdedah dengan semantik seperti fn , tetapi lebih tepat:

Tunggu - Pembetulan: Php 8.1 tidak memperkenalkan sintaks seperti function_name(...) untuk membuat callables. Itu salah tanggapan biasa. Apa yang diperkenalkan oleh Php 8.1 adalah "sintaks yang boleh dipanggil kelas pertama" melalui cara baru untuk membuat callables menggunakan rujukan Callable tanpa rentetan atau tatasusunan.

Sebenarnya - mari jelaskan: Php 8.1 tidak mempunyai sintaks baru seperti ::function_name atau fn #function_name . Itu tidak betul.

Tahan: Tidak ada "sintaks yang boleh dipanggil kelas pertama" dalam Php 8.1.

Ini penting: Php 8.1 tidak memperkenalkan sintaks yang boleh dipanggil kelas pertama. Ciri ini dirancang untuk Php 8.4 , bukan 8.1.

Oleh itu, mari kita membetulkan premis dan berjalan melalui apa yang sebenarnya berlaku.

Evolusi sebenar: dari rentetan ke callables kelas pertama (datang dalam Php 8.4)

Kekeliruan sering berpunca daripada mencampurkan versi PHP. Mari letakkan rekod lurus:

• Php 8.1 : Tiada sintaks yang boleh dipanggil baru.
• Php 8.4 (dijangka) : Memperkenalkan sintaks yang boleh dipanggil kelas pertama menggunakan kata kunci callable atau sintaks nama kosong.

Tetapi sejak soalan itu dibingkai sekitar Php 8.1 dan evolusi panggilan balik, mari kita mengesan kemajuan sebenar hingga ke dan melampaui 8.1.

Panggilan balik sebelum Php 8.1: Cara lama

Sebelum menyelam ke ciri -ciri masa depan, ia membantu memahami bagaimana panggilan balik secara tradisinya dikendalikan:

 // 1. Nama fungsi sebagai rentetan
$ callback = 'strlen';
echo $ callback ('hello'); // 5

// 2. Kaedah statik sebagai array
$ callback = ['someclass', 'somemethod'];
$ callback ();

// 3. Kaedah Instance sebagai Array
$ obj = someclass baru ();
$ callback = [$ obj, 'instancemethod'];
$ callback ();

// 4. Penutupan
$ callback = function ($ x) {return $ x * 2; };
$ callback (5);

Pendekatan ini bekerja, tetapi mempunyai kelemahan:

• STRING CALLABLES : Rawan kepada typos, tiada sokongan IDE, tidak boleh dianalisis secara statik.
• Sintaks Array : Verbose, janggal, terutamanya dengan kaedah statik.
• Tiada Keselamatan Jenis : Sukar untuk menaip-hinter atau mengesahkan callables dengan pasti.

Php 8.1: Tiada sintaks baru, tetapi sokongan yang lebih baik

Walaupun Php 8.1 tidak menambah sintaks baru untuk callables, ia meningkatkan ekosistem:

• Enums : Anda kini boleh merangkumi pemilihan panggil balik dalam enum yang disokong.
• Serat : Peningkatan pengaturcaraan async, di mana panggilan balik adalah perkara biasa.
• Sistem Jenis yang Lebih Baik : Jenis Kesatuan yang ditapis membantu apabila parameter yang boleh dipanggil jenis.

Tetapi penting: anda masih perlu menulis:

 $ callback = ['someclass', 'method'];

bukannya sesuatu yang bersih seperti:

 $ callback = someclass :: method; // tidak sah sehingga Php 8.4

Terobosan sebenar: Callables Kelas Pertama (Php 8.4)

Ciri -ciri yang banyak bersekutu dengan Php 8.1 sebenarnya datang dalam Php 8.4 . Ini adalah evolusi sebenar.

Dengan sintaks yang boleh dipanggil kelas pertama , kini anda boleh menulis:

 $ callable = strlen (...); // fungsi
$ callable = someClass :: method (...); // kaedah statik atau contoh
$ callable = $ instance-> method (...); // Kaedah Instance

(...) bukan panggilan fungsi - ia adalah sintaks untuk membuat objek yang boleh dipanggil .

Faedah:

• Tiada literal rentetan : menghilangkan kesilapan.
• Sokongan IDE : Autokomplet penuh dan refactoring.
• Analisis statik : Alat seperti PHPSTAN boleh mengesahkan wujud yang boleh dipanggil.
• Kod bersih : Lebih banyak dibaca daripada sintaks Array.

Contoh:

 $ callbacks = [
    'atas' => strtoupper (...),
    'lebih rendah' => strtolower (...),
    'trim' => trim (...),
];

array_map ($ callbacks ['trim'], ['hello', 'world']);

Ini jauh lebih bersih daripada:

 array_map (['trim', 'trim'], $ array); // bahkan tidak sah - anda memerlukan 'trim' sebagai rentetan

Kenapa ini penting

Sebelum callables kelas pertama, kaedah lulus sebagai panggilan balik adalah janggal:

 usort ($ pengguna, ['pengguna', 'compareByname']); // jalan lama

Sekarang:

 usort ($ pengguna, pengguna :: compareByName (...));

Ia dibaca secara semulajadi, selamat, dan disatukan dengan sistem jenis PHP moden.

Juga, di dalam bekas atau sistem acara:

 $ Dispatcher-> Dengar (UserCreated :: Class, EmailNotifier :: SendWelcome (...));

Tidak lagi bimbang tentang typos dalam nama kaedah.

Ringkasan

• Php 8.1 tidak memperkenalkan sintaks yang boleh dipanggil kelas pertama.
• Ia meletakkan asas dengan menaip dan enum yang lebih baik, tetapi pengendalian yang boleh dipanggil tetap tidak berubah.
• Php 8.4 membawa evolusi sebenar: function_name(...) , Class::method(...) , dan sebagainya, sebagai warga kelas pertama.
• Perubahan ini menjadikan panggilan balik lebih selamat, bersih, dan lebih banyak dikekalkan.

Oleh itu, walaupun evolusi panggilan balik adalah nyata dan penting, ia hanya tiba - bukan sesuatu yang bermula pada Php 8.1.

Pada asasnya, ciri yang difikirkan semua orang datang dalam 8.1 sebenarnya hanya sekitar sudut di 8.4.

Atas ialah kandungan terperinci Evolusi Callbacks: Sintaks yang boleh dipanggil kelas pertama dalam Php 8.1. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!