Conseils pratiques pour les fonctions PHP : array_chunk()

Array en langage PHP est un type de données très pratique qui peut être utilisé pour stocker plusieurs données et effectuer des opérations par lots. Cependant, nous devons parfois diviser un grand tableau en plusieurs tableaux plus petits pour un meilleur traitement. À l’heure actuelle, array_chunk() dans la fonction PHP est utile. Cet article explique comment utiliser la fonction array_chunk() pour effectuer des opérations de segmentation de tableau et quelques conseils pratiques.

1. Présentation de la fonction array_chunk()

La fonction array_chunk() consiste à diviser un tableau en morceaux d'une taille spécifiée et à renvoyer un tableau bidimensionnel. Sa fonction est définie comme suit :

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

Description du paramètre :

# 🎜🎜 #

$array : obligatoire, le tableau à diviser en blocs.
• $size : Obligatoire, un entier spécifiant la longueur de chaque bloc.
• $preserve_keys : Facultatif, une valeur booléenne indiquant s'il faut conserver les noms de clés du tableau d'origine. La valeur par défaut est false, c'est-à-dire non conservée.

Cette fonction renvoie un tableau bidimensionnel, où la longueur de chaque sous-tableau est $size et la longueur du dernier sous-tableau peut être inférieure à $size.

2. Exemple de fonction array_chunk()

Afin de mieux comprendre l'utilisation de la fonction array_chunk(), nous pouvons regarder l'exemple suivant.

Tout d'abord, on définit un tableau contenant 10 éléments :

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

On peut utiliser la fonction array_chunk() pour le diviser en petits tableaux de longueur 3 :

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

Le résultat est le suivant :

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
        )

)

Comme vous pouvez le constater, le tableau d'origine est divisé en 4 sous-tableaux de longueur 3. Le dernier sous-tableau n'a qu'un seul élément car il n'en reste qu'un seul dans le tableau d'origine.

3. Compétences pratiques de la fonction array_chunk()

Array paging

Nous pouvons utiliser la fonction array_chunk() Pages un tableau, en spécifiant le nombre d'entrées de données par page comme longueur de chaque bloc. Ceci est très utile pour créer un système de pagination simple. Par exemple, nous pouvons diviser un total de 50 données en 10 par page, puis les afficher sur 5 pages.

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

Les résultats sont les suivants :

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
        )

)

Chaque sous-tableau contient 10 éléments, tout comme chaque page contient 10 données.

array split

Supposons que nous ayons une chaîne séparée par des virgules et que nous voulions la diviser en un tableau et la diviser à chaque fois Divisé en 10 éléments, vous pouvez utiliser la fonction array_chunk() pour terminer cette opération.

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

Les résultats sont les suivants :

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
        )

)

Array random tri

Si on veut perturber les éléments dans un tableau Pour le tri, vous pouvez d'abord utiliser array_chunk() pour diviser le tableau en morceaux, puis brouiller les éléments de chaque morceau et enfin connecter les éléments de tous les morceaux ensemble pour effectuer un tri aléatoire.

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

Les résultats sont les suivants :

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
)

Nous avons d'abord divisé le tableau d'origine en 4 sous-tableaux d'une longueur de 5, puis mélangé l'intérieur de chaque sous-tableau , et enfin Utilisez la fonction array_merge() pour fusionner tous les sous-tableaux ensemble, perturbant ainsi l'ordre du tableau d'origine.

4. Résumé

array_chunk() est une fonction très pratique dans le langage PHP, qui peut nous aider à diviser un grand tableau en plusieurs petits tableaux. Le traitement logique est très efficace. commodité. Cet article présente la fonction et l'utilisation de la fonction array_chunk() et partage quelques conseils pratiques pour le regroupement de tableaux. J'espère que cet article sera utile aux apprenants du langage PHP.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!