Français
Français
En PHP, la fonction Array_Chunk est un outil très pratique pour diviser un grand tableau en morceaux plus petits. Bien qu'il offre des fonctionnalités pratiques, il peut entraîner des problèmes de débordement de mémoire lorsqu'ils traitent de très grands tableaux, en particulier lorsque le tableau est très grand ou trop de blocs fendus.
La syntaxe de base de la fonction Array_Chunk est la suivante:
array_chunk(array $array, int $length, bool $preserve_keys = false): array
$ tableau : le tableau d'entrée.
$ Longueur : le nombre d'éléments dans chaque sous-réseau.
$ Preserve_keys : une valeur booléenne qui détermine l'opportunité de maintenir la valeur clé du tableau d'origine.
$array = [1, 2, 3, 4, 5, 6, 7, 8, 9];
$chunks = array_chunk($array, 3);
print_r($chunks);
Sortir:
Array
(
[0] => Array ( [0] => 1 [1] => 2 [2] => 3 )
[1] => Array ( [0] => 4 [1] => 5 [2] => 6 )
[2] => Array ( [0] => 7 [1] => 8 [2] => 9 )
)
Ce code divise le tableau de baies $ en 3 blocs, chaque bloc contenant 3 éléments.
Lorsque vous divisez un très grand tableau, Array_Chunk renvoie un nouveau tableau bidimensionnel où chaque sous-réseau contient une partie des données du tableau d'origine. Si le tableau d'origine est très grand et que le nombre de blocs est très important, cela entraînera la mémoire de PHP en mémoire, ce qui peut entraîner des problèmes de débordement de mémoire.
Supposons que vous ayez un très grand tableau contenant des millions d'éléments. Si vous utilisez Array_Chunk pour le diviser en 1000 morceaux, cela peut créer un grand nombre de sous-réseaux, dont chacun doit encore prendre de la mémoire, provoquant une forte augmentation de l'utilisation de la mémoire, ce qui déclenche un débordement de mémoire.
Pour éviter le débordement de la mémoire lors de l'utilisation de Array_Chunk , vous pouvez adopter les stratégies suivantes:
Les générateurs sont une manière économe en mémoire fournie par PHP, qui peut générer des données à la demande au lieu de charger toutes les données en mémoire à la fois. Vous pouvez utiliser des générateurs pour traiter les données par blocs, évitant ainsi de charger le tableau entier en mémoire à la fois.
function chunkGenerator(array $array, $chunkSize) {
$chunk = [];
foreach ($array as $key => $value) {
$chunk[] = $value;
if (count($chunk) >= $chunkSize) {
yield $chunk;
$chunk = [];
}
}
if (count($chunk) > 0) {
yield $chunk;
}
}
$array = range(1, 10000000);
foreach (chunkGenerator($array, 1000) as $chunk) {
// Traiter chacun $chunk
}
Dans cet exemple, nous avons utilisé le mot clé de rendement pour créer un générateur. Chaque fois qu'un bloc est généré, il renvoie temporairement le bloc au lieu de charger tous les blocs en mémoire à la fois. Cela peut réduire considérablement l'utilisation de la mémoire.
Si vous ne pouvez pas utiliser le générateur, vous pouvez envisager d'éviter le débordement de la mémoire en chargeant des lots ou en traitement des données étape par étape. Par exemple, si vos données proviennent d'une base de données ou d'une API externe, vous pouvez charger les données par lots au lieu de charger la grande matrice entière à la fois.
En supposant que vos données soient récupérées à partir d'une URL, vous pouvez charger les données de l'URL étape par étape, plutôt que de tout charger à la fois:
function fetchDataInChunks($url, $chunkSize) {
$handle = fopen($url, 'r');
$chunk = [];
while (($line = fgets($handle)) !== false) {
$chunk[] = $line;
if (count($chunk) >= $chunkSize) {
yield $chunk;
$chunk = [];
}
}
fclose($handle);
if (count($chunk) > 0) {
yield $chunk;
}
}
$url = 'https://m66.net/data.csv';
foreach (fetchDataInChunks($url, 1000) as $chunk) {
// Traiter chacun $chunk
}
Si vos données de tableau sont très importantes mais que vous ne souhaitez pas utiliser de générateur, vous pouvez réduire le nombre de blocs créés en même temps en redimensionnant chaque bloc. Par exemple, définissez la taille du bloc un peu plus grande et traitez des blocs de données plus grands à chaque fois au lieu de les diviser en de nombreux petits blocs.
Lorsque vous divisez de grands tableaux avec Array_Chunk , il peut en effet provoquer des problèmes de débordement de mémoire, en particulier lorsque le tableau est particulièrement important ou que le nombre de blocs est trop grand. Pour résoudre ce problème, nous pouvons utiliser les méthodes suivantes:
Utilisez le générateur : réduisez l'empreinte de la mémoire en générant des données à la demande.
Étape par étape : si les données proviennent d'une source externe, vous pouvez charger les données par lots.
Redimensionner les blocs : réduire le nombre de blocs, augmenter la taille de chaque bloc, réduisant ainsi l'utilisation de la mémoire.
Ces méthodes peuvent vous aider efficacement à faire face aux problèmes de mémoire lorsque de grands volumes de données, ce qui rend le programme à fonctionner plus efficacement.
