Français
Français
Au cours du processus de développement, il est souvent nécessaire de diviser un grand tableau en plusieurs petits tableaux lors du traitement de grandes quantités de données. PHP fournit une fonction très utile array_chunk () pour la segmentation du tableau. Cette fonction peut diviser un grand tableau en plusieurs petits tableaux, ce qui convient à divers scénarios, tels que la pagination, le traitement par lots, etc. Bien que Array_Chunk () soit très pratique, lorsqu'il s'agit de grands tableaux, s'il n'est pas optimisé, il peut conduire à des bouteilles de performance. Cet article présentera comment utiliser Array_Chunk () et explorera les moyens d'éviter les problèmes de performances.
La fonction Array_Chunk () est utilisée pour diviser un tableau en plusieurs petits tableaux et renvoyer un tableau bidimensionnel contenant de petits tableaux.
Syntaxe de base:
array_chunk(array $array, int $size, bool $preserve_keys = false): array
$ Array : le tableau qui doit être divisé.
$ Taille : la taille de chaque petit tableau.
$ Preserve_Keys : Si défini sur true , le nom de clé du tableau d'origine sera conservé; Si faux , le nom de la clé sera réindexé.
Exemple de code:
<?php
$array = range(1, 20); // Générer un contenu 1 arriver 20 Tableau de
$chunked = array_chunk($array, 5);
print_r($chunked);
?>
Résultat de sortie:
Array
(
[0] => Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 )
[1] => Array ( [0] => 6 [1] => 7 [2] => 8 [3] => 9 [4] => 10 )
[2] => Array ( [0] => 11 [1] => 12 [2] => 13 [3] => 14 [4] => 15 )
[3] => Array ( [0] => 16 [1] => 17 [2] => 18 [3] => 19 [4] => 20 )
)
Cette méthode est très efficace pour les petits tableaux, mais si vous avez affaire à un très grand tableau, des problèmes de performance émergeront progressivement.
Lorsque le tableau est très important, l'utilisation de l'array_chunk () peut provoquer directement une utilisation excessive de la mémoire, ce qui affectera les performances. Les principales raisons sont les suivantes:
Memory Footprint : Array_Chunk () crée plusieurs nouvelles copies de tableau, ce qui peut entraîner une forte augmentation de l'utilisation de la mémoire.
Nom de clé inutile Reconstruction : Si le paramètre $ Preserve_Keys est faux , chaque petit tableau réindexera le nom de clé, ajoutant des frais généraux supplémentaires.
Pour les grandes tableaux, les goulots d'étranglement des performances peuvent être particulièrement perceptibles sans optimisation et peuvent même provoquer des accidents de programme ou une réponse lente.
Lorsque vous traitez avec de grands tableaux, afin d'éviter les goulots d'étranglement de performance, nous pouvons prendre les mesures d'optimisation suivantes:
La fonction Array_Slice () peut extraire les sous-réseaux d'un tableau sans copier l'intégralité du tableau. Par rapport à Array_Chunk () , Array_Slice () nous permet de traiter une partie des données dans le tableau au besoin, en évitant l'utilisation de la mémoire du traitement de l'ensemble de la grande matrice à la fois.
Exemple d'optimisation:
<?php
$array = range(1, 1000000); // Supposons que nous ayons un large éventail de millions d'éléments
$chunk_size = 10000; // Chaque traitement 10000 Éléments
// utiliser array_slice Itérer à travers de gros tableaux
for ($i = 0; $i < count($array); $i += $chunk_size) {
$chunk = array_slice($array, $i, $chunk_size);
// traiter avec $chunk données，Par exemple, envoyer HTTP Demande etc.
// Assumer la demande URL pour https://m66.net/api/data
file_get_contents("https://m66.net/api/data?data=" . urlencode(json_encode($chunk)));
}
?>
Lorsque vous utilisez Array_Slice () pour traverser de grands tableaux, seule une partie des données d'une taille fixe est traitée à la fois, ce qui peut réduire efficacement l'utilisation de la mémoire et éviter les problèmes de performances causés par le chargement de trop de données en même temps.
Comme mentionné précédemment, le paramètre Preserve_Keys de Array_Chunk () affectera l'utilisation de la mémoire. Si nous n'avons pas besoin de préserver le nom de clé, il est préférable de définir ce paramètre sur FALS pour réduire l'utilisation de la mémoire.
<?php
$array = range(1, 1000000);
$chunked = array_chunk($array, 10000, false); // Aucun nom de clé d'origine conservé
?>
Cela entraînera la réin-indexation des noms de chaque petit tableau, réduisant les frais généraux de mémoire inutiles.
Pour les tableaux super grands, la meilleure façon est de les traiter en segments. En traitant les données par lots en cycles, les grandes tableaux peuvent être divisés en plusieurs petits morceaux pour le traitement un par un, réduisant ainsi la pression de la mémoire.
Exemple de traitement par lots:
<?php
$array = range(1, 1000000); // Grand tableau
$chunk_size = 50000; // 每批次traiter avec 50000 个données
foreach (array_chunk($array, $chunk_size) as $chunk) {
// 逐批traiter avecdonnées，Par exemple, initié API demander
file_get_contents("https://m66.net/api/data?data=" . urlencode(json_encode($chunk)));
}
?>
Cette méthode peut empêcher le chargement des données excessives en mémoire et améliorer la stabilité et les performances du programme.
Lorsque vous utilisez Array_Chunk () , nous devons accorder une attention particulière au traitement des grandes tableaux pour éviter les goulots d'étranglement de performances. Les performances peuvent être optimisées de la manière suivante:
Utilisez array_slice () pour traiter les segments de tableau à la demande.
Définissez raisonnablement le paramètre Preserve_Keys pour éviter les frais généraux de mémoire inutiles.
Le traitement des données par lots réduit l'utilisation de la mémoire et améliore l'efficacité du programme.
Ces méthodes d'optimisation permettent de traiter plus efficacement de grandes tableaux et évitent les problèmes de performances dans des environnements à haute charge.
