Praktische Tipps für PHP-Funktionen: array_chunk()

Array ist in der PHP-Sprache ein sehr praktischer Datentyp, der zum Speichern mehrerer Daten und zum Ausführen von Stapelvorgängen verwendet werden kann. Manchmal müssen wir jedoch zur besseren Verarbeitung ein großes Array in mehrere kleinere Arrays aufteilen. Zu diesem Zeitpunkt ist array_chunk() in der PHP-Funktion hilfreich. In diesem Artikel erfahren Sie, wie Sie mit der Funktion array_chunk() Array-Chunking-Operationen durchführen und erhalten einige praktische Tipps.

1. Übersicht über die Funktion array_chunk()

Die Funktion array_chunk() dient dazu, ein Array in Blöcke einer bestimmten Größe zu unterteilen und ein zweidimensionales Array zurückzugeben. Seine Funktion ist wie folgt definiert:

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

Parameterbeschreibung:

• $array: erforderlich, das Array soll in Chunks unterteilt werden.
• $size: erforderlich, eine Ganzzahl, die die Länge jedes Blocks angibt.
• $preserve_keys: Optional, ein boolescher Wert, der angibt, ob die Schlüsselnamen des ursprünglichen Arrays beibehalten werden sollen. Der Standardwert ist false, also nicht beibehalten.

Diese Funktion gibt ein zweidimensionales Array zurück, wobei die Länge jedes Unterarrays $size beträgt und die Länge des letzten Unterarrays kleiner als $size sein kann.

2. Beispiel der Funktion array_chunk()

Um die Verwendung der Funktion array_chunk() besser zu verstehen, können wir uns das folgende Beispiel ansehen.

Zuerst definieren wir ein Array mit 10 Elementen:

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

Wir können die Funktion array_chunk() verwenden, um es in kleine Arrays der Länge 3 zu unterteilen:

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

Das Ergebnis ist wie folgt:

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
        )

)

Wie Sie sehen können, Das ursprüngliche Array ist in 4 Unterarrays der Länge 3 unterteilt. Das letzte Unterarray enthält nur ein Element, da im ursprünglichen Array nur noch ein Element vorhanden ist.

3. Praktische Tipps zur Funktion array_chunk()

1. Array-Paging

Wir können die Funktion array_chunk() verwenden, um ein Array zu blättern und dabei die Anzahl der Dateneinträge pro Seite als Länge jedes Blocks anzugeben. Dies ist sehr nützlich, um ein einfaches Paging-System zu erstellen. Wir können beispielsweise insgesamt 50 Daten in 10 pro Seite aufteilen und sie dann auf 5 Seiten anzeigen.

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

Das Ergebnis ist wie folgt:

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
        )

)

Jedes Unterarray enthält 10 Elemente, genau wie jede Seite 10 Daten enthält.

2. Array-Aufteilung

Angenommen, wir haben eine durch Kommas getrennte Zeichenfolge und möchten sie in ein Array aufteilen und jeweils 10 Elemente aufteilen. Diese Operation kann mit der Funktion array_chunk() durchgeführt werden.

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

Die Ergebnisse sind wie folgt:

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 zufällig sortiert

Wenn wir die Reihenfolge der Elemente in einem Array stören möchten, können wir zuerst array_chunk() verwenden, um das Array in Blöcke zu unterteilen, und dann die Elemente verschlüsseln Von jedem Block werden schließlich alle Elemente des Blocks miteinander verbunden, um die zufällige Reihenfolge zu vervollständigen.

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

Die Ergebnisse sind wie folgt:

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
)

Wir haben zuerst das ursprüngliche Array in 4 Unterarrays mit einer Länge von 5 unterteilt, dann das Innere jedes Unterarrays gemischt und schließlich die Funktion array_merge() verwendet, um alle zusammenzuführen Wenn Sie die Unterarrays zusammenfügen, wird die Reihenfolge des ursprünglichen Arrays gestört.

4. Zusammenfassung

Die Funktion array_chunk() ist eine sehr praktische Funktion in der PHP-Sprache. Sie kann uns dabei helfen, ein großes Array in mehrere kleine Arrays aufzuteilen, was eine große Bequemlichkeit für die logische Verarbeitung bietet. Dieser Artikel stellt die Funktion und Verwendung der Funktion array_chunk() vor und gibt einige praktische Tipps für das Array-Chunking. Ich hoffe, dass dieser Artikel für Lernende der PHP-Sprache hilfreich sein wird.

Das obige ist der detaillierte Inhalt vonPraktische Tipps für PHP-Funktionen: array_chunk(). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!