Gelung gaya lama boleh diubahsuai ke dalam saluran paip koleksi PHP moden untuk meningkatkan kebolehbacaan kod dan kebolehkerjaan. Langkah -langkah tertentu adalah seperti berikut: 1. Kenal pasti gelung yang digunakan untuk menukar atau menapis tatasusunan; 2. Membungkus data dengan mengumpul ($ array); 3. Gantikan penghakiman dan penghakiman bersyarat dengan penapis (), peta (), dan menolak (); 4. Gunakan FlatMap () untuk struktur bersarang; 5. Rantaian akhir panggilan melalui toArray () atau semua (); 6. Ekstrak logik kompleks ke dalam fungsi yang boleh diguna semula untuk mencapai proses pemprosesan data yang lebih jelas dan deklaratif.

Refactoring sekolah lama for dan foreach gelung ke dalam saluran paip koleksi PHP moden boleh menjadikan kod anda lebih bersih, lebih ekspresif, dan lebih mudah untuk dikekalkan. Peralihan ini sangat kuat apabila bekerja dengan array rekod pengguna seperti data, membentuk input, atau respons API -di mana anda menapis, memetakan, atau mengurangkan nilai.

Daripada menulis gelung prosedur yang bermutasi keadaan atau mendapat kusut dalam keadaan bersarang, anda boleh menggunakan perpustakaan koleksi seperti Laravel Illuminate\Support\Collection atau pakej mandiri seperti tightenco/collect untuk membina transformasi data yang fasih dan rantai.

Mari kita jalankan bagaimana untuk merenung gelung warisan ke dalam saluran paip moden dan boleh dibaca.

? Gantikan gelung asas dengan map , filter , dan toArray

Pertimbangkan gelung foreach klasik ini yang menapis pengguna aktif dan format nama mereka:

 $ pengguna = [
    ['name' => 'Alice', 'Active' => True],
    ['name' => 'bob', 'active' => false],
    ['name' => 'Charlie', 'Active' => True],
];

$ activeNames = [];
foreach ($ pengguna sebagai pengguna $) {
    jika ($ user ['aktif']) {
        $ activeNames [] = strtoupper ($ user ['name']);
    }
}

Ini berfungsi, tetapi penting: anda memberitahu PHP bagaimana untuk membina keputusan langkah demi langkah.

Refactornya menjadi saluran paip koleksi :

 Gunakan Illuminate \ Support \ Collection;

$ ActiveNames = kumpulkan ($ pengguna)
    -> penapis (fn ($ user) => $ user ['aktif'])
    -> peta (fn ($ user) => strtoupper ($ user ['name']))
    -> toArray ();

? Faedah:

• Deklaratif: Anda mengatakan apa yang anda mahukan, bukan bagaimana .
• Chainable: Mudah untuk memasukkan langkah -langkah seperti sortBy , take(5) , atau values() .
• Boleh diuji: Setiap langkah diasingkan dan boleh dikompos.

? Memudahkan syarat bersarang dengan pelbagai peringkat saluran paip

Kod Legacy sering berakhir dengan sangat bersarang if pernyataan di dalam gelung:

 $ diproses = [];
foreach ($ pesanan sebagai $ order) {
    jika ($ order ['total']> 100) {
        jika ($ order ['status'] === 'dihantar') {
            foreach ($ order ['item'] sebagai $ item) {
                jika ($ item ['kategori'] === 'elektronik') {
                    $ diproses [] = [
                        'order_id' => $ order ['id'],
                        'produk' => $ item ['nama'],
                        'Keuntungan' => $ item ['Harga'] * 0.2,
                    ];
                }
            }
        }
    }
}

Ini sukar untuk diikuti dan diubah suai.

Sekarang reflektor menggunakan koleksi:

 $ diproses = kumpulkan ($ pesanan)
    -> penapis (fn ($ order) => $ order ['total']> 100 && $ order ['status'] === 'dihantar')
    -> FlatMap (fn ($ order) => kumpulkan ($ order ['item'])
        -> penapis (fn ($ item) => $ item ['kategori'] === 'elektronik')
        -> peta (fn ($ item) => [
            'order_id' => $ order ['id'],
            'produk' => $ item ['nama'],
            'Keuntungan' => $ item ['Harga'] * 0.2,
        ])
    )
    -> nilai ()
    -> toArray ();

? Wawasan Utama: Gunakan flatMap untuk meratakan koleksi bersarang semasa mengubah.

Versi ini:

• Memisahkan kebimbangan secara bersih.
• Menjadikan setiap keadaan jelas.
• Mengelakkan array manual menolak.

? Ekstrak logik kompleks ke langkah -langkah saluran paip yang boleh diguna semula

Apabila saluran paip tumbuh, ekstrak logik ke dalam fungsi pesanan yang lebih tinggi untuk digunakan semula:

 fungsi OnlyElectronics () {
    kembali fn ($ item) => $ item ['kategori'] === 'elektronik';
}

fungsi mengiraProfit ($ margin) {
    fungsi kembali ($ item) penggunaan ($ margin) {
        kembali $ item ['Harga'] * $ margin;
    };
}

Kemudian gunakannya di rantai anda:

 $ menguntungkan = kumpulkan ($ produk)
    -> Penapis (OnlyElectronics ())
    -> peta (fn ($ item) => [
        'Nama' => $ item ['Nama'],
        'Keuntungan' => KiraanProfit (0.25) ($ item),
    ])
    -> semua ();

Ini menggalakkan pengaturcaraan gaya berfungsi , di mana fungsi-fungsi kecil yang murni digabungkan seperti blok bangunan.

?? apabila tidak refactor

Tidak setiap gelung harus menjadi saluran paip. Pertimbangkan:

• Gelung prestasi kritikal (koleksi mempunyai overhead).
• Lelaran mudah (contohnya, menghantar e -mel satu demi satu).
• Kesan sampingan (seperti penjimatan ke DB dalam gelung) -gunakan each() dengan teliti.

Tetapi untuk transformasi data , penapisan , dan pelaporan , saluran paip menang dengan kejelasan.

? Ringkasan: Cara Memulakan Refactoring

Untuk memodenkan gelung warisan:

• [] Kenal pasti gelung yang mengubah atau menapis susunan.
• [] Bungkus data dalam collect($array) .
• [] Gantikan keadaan foreach dengan filter() , map() , reject() .
• [] Gunakan flatMap() untuk struktur bersarang.
• [] Kaedah rantai dengan lancar dan berakhir dengan toArray() atau all() apabila diperlukan.
• [] Ekstrak logik yang boleh diguna semula ke dalam fungsi.

Paip koleksi PHP moden tidak hanya kelihatan lebih baik -mereka mengurangkan pepijat, meningkatkan kebolehbacaan, dan membuat kod anda berasa lebih seperti bercerita data daripada pembukuan manual.

Pada asasnya, jika anda melingkari untuk mengubah data, tidak melakukan sesuatu, saluran paip koleksi mungkin alat yang lebih baik.

Atas ialah kandungan terperinci Warisan refactoring untuk gelung ke saluran paip koleksi moden. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!