Petua praktikal untuk fungsi PHP: array_chunk()

Array dalam bahasa PHP ialah jenis data yang sangat praktikal yang boleh digunakan untuk menyimpan berbilang data dan melaksanakan operasi kelompok. Walau bagaimanapun, kadangkala kita perlu membahagikan tatasusunan yang besar kepada beberapa tatasusunan yang lebih kecil untuk pemprosesan yang lebih baik. Pada masa ini, array_chunk() dalam fungsi PHP sangat berguna. Artikel ini akan berkongsi cara menggunakan fungsi array_chunk() untuk melaksanakan operasi chunking tatasusunan dan beberapa petua praktikal.

1. Gambaran keseluruhan fungsi array_chunk()

Fungsi fungsi array_chunk() adalah untuk membahagikan array kepada ketulan saiz yang ditentukan dan mengembalikan tatasusunan dua dimensi. Fungsinya ditakrifkan seperti berikut:

array array_chunk ( array $array , int $size [, bool $preserve_keys = false ] )

Perihalan parameter:

• $array : Diperlukan, tatasusunan untuk dibahagikan kepada blok.
• $size: diperlukan, integer menyatakan panjang setiap blok.
• $preserve_keys: Pilihan, nilai Boolean yang menunjukkan sama ada untuk mengekalkan nama kunci tatasusunan asal Lalai adalah palsu, yang bermaksud tidak mengekalkan.

Fungsi ini mengembalikan tatasusunan dua dimensi, di mana panjang setiap subtatasusunan ialah $size dan panjang subtatasusunan terakhir boleh kurang daripada $size.

2. Contoh fungsi array_chunk()

Untuk lebih memahami penggunaan fungsi array_chunk(), kita boleh melihat contoh berikut.

Pertama, kita mentakrifkan tatasusunan dengan 10 elemen:

<?php
  $arr = array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j');
?>

Kita boleh menggunakan fungsi array_chunk() untuk membahagikannya kepada tatasusunan kecil dengan panjang 3:

<?php
  $result = array_chunk($arr, 3);
  print_r($result);
?>

Hasil Sebagai berikut:

Array
(
    [0] => Array
        (
            [0] => a
            [1] => b
            [2] => c
        )

    [1] => Array
        (
            [0] => d
            [1] => e
            [2] => f
        )

    [2] => Array
        (
            [0] => g
            [1] => h
            [2] => i
        )

    [3] => Array
        (
            [0] => j
        )

)

Seperti yang anda lihat, tatasusunan asal dibahagikan kepada 4 sub-tatasusunan dengan panjang 3. Subarray terakhir hanya mempunyai satu elemen kerana hanya ada satu elemen yang tinggal dalam tatasusunan asal.

3. Kemahiran praktikal fungsi array_chunk()

1. Paging array

Kita boleh menggunakan fungsi array_chunk() untuk halaman array dan membahagikan setiap halaman ke dalam halaman Bilangan kemasukan data ditentukan sebagai panjang setiap blok. Ini sangat berguna untuk membuat sistem paging yang mudah Sebagai contoh, kita boleh membahagikan sejumlah 50 data kepada 10 setiap halaman, dan kemudian memaparkannya pada 5 halaman.

<?php
  $arr = range(1,50);
  $pages = array_chunk($arr,10);
  print_r($pages);
?>

Hasilnya adalah seperti berikut:

Array
(
    [0] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
            [3] => 4
            [4] => 5
            [5] => 6
            [6] => 7
            [7] => 8
            [8] => 9
            [9] => 10
        )

    [1] => Array
        (
            [0] => 11
            [1] => 12
            [2] => 13
            [3] => 14
            [4] => 15
            [5] => 16
            [6] => 17
            [7] => 18
            [8] => 19
            [9] => 20
        )

    [2] => Array
        (
            [0] => 21
            [1] => 22
            [2] => 23
            [3] => 24
            [4] => 25
            [5] => 26
            [6] => 27
            [7] => 28
            [8] => 29
            [9] => 30
        )

    [3] => Array
        (
            [0] => 31
            [1] => 32
            [2] => 33
            [3] => 34
            [4] => 35
            [5] => 36
            [6] => 37
            [7] => 38
            [8] => 39
            [9] => 40
        )

    [4] => Array
        (
            [0] => 41
            [1] => 42
            [2] => 43
            [3] => 44
            [4] => 45
            [5] => 46
            [6] => 47
            [7] => 48
            [8] => 49
            [9] => 50
        )

)

Setiap sub-array mengandungi 10 elemen, sama seperti setiap halaman mengandungi 10 data.

2. Pembahagian Tatasusunan

Andaikan kita mempunyai rentetan yang dipisahkan dengan koma dan kita ingin membahagikannya kepada tatasusunan dan membahagikan 10 elemen pada satu masa, kita boleh Gunakan array_chunk () fungsi untuk mencapai operasi ini.

<?php
  $str = "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20";
  $arr = explode(',', $str);
  $result = array_chunk($arr, 10);
  print_r($result);
?>

Hasilnya adalah seperti berikut:

Array
(
    [0] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
            [3] => 4
            [4] => 5
            [5] => 6
            [6] => 7
            [7] => 8
            [8] => 9
            [9] => 10
        )

    [1] => Array
        (
            [0] => 11
            [1] => 12
            [2] => 13
            [3] => 14
            [4] => 15
            [5] => 16
            [6] => 17
            [7] => 18
            [8] => 19
            [9] => 20
        )

)

3. Array disusun secara rawak

Jika kita ingin mengganggu susunan elemen dalam tatasusunan, kita boleh mula-mula gunakan array_chunk() Bahagikan tatasusunan kepada blok, kemudian kocok elemen setiap blok, dan akhirnya sambungkan elemen semua blok bersama-sama untuk menyelesaikan pengisihan rawak.

<?php
  $arr = range(1, 20);
  $chunk_arr = array_chunk($arr, 5);
  foreach ($chunk_arr as $key => &$value) {
    shuffle($value);
  }
  $result = call_user_func_array('array_merge', $chunk_arr);
  print_r($result);
?>

Hasilnya adalah seperti berikut:

Array
(
    [0] => 1
    [1] => 4
    [2] => 2
    [3] => 3
    [4] => 5
    [5] => 9
    [6] => 10
    [7] => 7
    [8] => 6
    [9] => 8
    [10] => 11
    [11] => 12
    [12] => 14
    [13] => 13
    [14] => 16
    [15] => 15
    [16] => 17
    [17] => 20
    [18] => 19
    [19] => 18
)

Kami mula-mula membahagikan tatasusunan asal kepada 4 sub-tatasusunan dengan panjang 5, kemudian merangkak dan mengisih setiap sub-susun, dan akhirnya menggunakan array_merge () Fungsi ini menggabungkan semua subarray bersama-sama, mengganggu susunan tatasusunan asal.

4. Ringkasan

Fungsi array_chunk() ialah fungsi yang sangat praktikal dalam bahasa PHP. Ia boleh membantu kami membahagikan tatasusunan yang besar kepada berbilang tatasusunan kecil, menyediakan cara yang mudah untuk pemprosesan logik . Artikel ini memperkenalkan fungsi dan penggunaan fungsi array_chunk() dan berkongsi beberapa petua praktikal untuk penyusunan tatasusunan. Saya harap artikel ini akan membantu pelajar bahasa PHP.

Atas ialah kandungan terperinci Petua praktikal untuk fungsi PHP: array_chunk(). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!