Français
Français
Dans le développement de PHP, Array_Column est une fonction très pratique qui extrait les données de colonne unique à partir de tableaux multidimensionnels et renvoie un nouveau tableau. Cette fonction est particulièrement adaptée à l'obtention de données à partir d'une colonne de données à partir d'un grand tableau contenant plusieurs sous-réseaux. Cependant, lorsque le volume de données est très important, les performances de Array_Column peuvent devenir un goulot d'étranglement, ce qui a rendu le programme lent.
Cet article introduira certaines méthodes pour optimiser les performances Array_Column pour vous aider à améliorer l'efficacité de votre programme lorsque vous traitez avec de grands tableaux.
Tout d'abord, passons en revue brièvement l'utilisation de base de Array_Column . Supposons que nous ayons un tableau bidimensionnel et que nous voulions extraire les données d'une certaine colonne, nous pouvons les implémenter via Array_Column :
$data = [
['id' => 1, 'name' => 'Alice'],
['id' => 2, 'name' => 'Bob'],
['id' => 3, 'name' => 'Charlie'],
];
$names = array_column($data, 'name');
print_r($names);
Sortir:
Array
(
[0] => Alice
[1] => Bob
[2] => Charlie
)
Dans cet exemple, nous extraissons les données du tableau de données $ de la colonne de nom .
Pour les ensembles de données à petite échelle, les performances Array_Column sont généralement acceptables. Cependant, lors du traitement des millions d'enregistrements ou plus, le temps d'exécution d'une fonction peut devenir plus long. La raison en est que Array_Column traversera, trouvera et extraire chaque ligne, ce qui est un processus très long dans de grands tableaux.
Si vous devez extraire plusieurs colonnes à partir d'un grand tableau, envisagez de réduire le nombre d'appels à Array_Column . Par exemple, évitez d'extraire une colonne à la fois et une autre colonne. Au lieu de cela, vous pouvez utiliser array_map pour extraire plusieurs colonnes que vous souhaitez en même temps.
// Extraire plusieurs colonnes
$data = [
['id' => 1, 'name' => 'Alice', 'age' => 30],
['id' => 2, 'name' => 'Bob', 'age' => 25],
['id' => 3, 'name' => 'Charlie', 'age' => 35],
];
// Extraire toutes les colonnes requises à la fois
$columns = array_map(function($item) {
return [$item['name'], $item['age']];
}, $data);
print_r($columns);
Cette méthode obtient plusieurs colonnes en traversant en même temps, en évitant plusieurs appels à array_column .
La gestion de la mémoire est également un aspect qui a besoin d'attention lorsqu'il s'agit de très grands tableaux. Pour réduire la consommation de mémoire, vous pouvez utiliser des générateurs pour traiter les tableaux au lieu de charger la matrice entière en mémoire.
Au lieu de charger toutes les données dans la mémoire à la fois, le générateur peut renvoyer chaque élément dans le tableau étape par étape, ce qui est très utile lors de la gestion des mégadonnées.
// Utilisez le générateur pour retourner les données étape par étape
function getNames($data) {
foreach ($data as $item) {
yield $item['name'];
}
}
$data = [
['id' => 1, 'name' => 'Alice'],
['id' => 2, 'name' => 'Bob'],
['id' => 3, 'name' => 'Charlie'],
];
// Utilisez le générateur pour obtenir le nom
foreach (getNames($data) as $name) {
echo $name . PHP_EOL;
}
Cette approche évite de charger le tableau entier en mémoire, réduisant ainsi la consommation de mémoire.
Lorsque vous traitez avec de très grands tableaux, vous pouvez diviser le tableau en plusieurs petits lots pour le traitement. Les limites de mémoire de PHP et les limites de temps d'exécution peuvent affecter les performances de votre programme, donc le lot des données est un bon choix.
Par exemple, vous pouvez couper un tableau par une certaine taille et appliquer Array_Column à chaque petit lot, puis fusionner les résultats.
$data = [
['id' => 1, 'name' => 'Alice'],
['id' => 2, 'name' => 'Bob'],
['id' => 3, 'name' => 'Charlie'],
// Plus de données
];
$batchSize = 1000;
$columns = [];
foreach (array_chunk($data, $batchSize) as $chunk) {
$columns = array_merge($columns, array_column($chunk, 'name'));
}
print_r($columns);
Cette méthode évite de faire fonctionner l'ensemble du tableau à la fois par le traitement par lots, réduisant ainsi la pression sur la mémoire et le CPU.
Lorsque vous traitez avec de grands tableaux, la fonction Array_Column peut créer des goulots d'étranglement de performances, en particulier lorsque le volume de données est extrêmement important. Pour optimiser ses performances, vous pouvez utiliser les méthodes suivantes:
Réduisez le nombre d'appels à Array_Column et optimisez les performances en extraction de plusieurs colonnes à la fois.
Utilisez le générateur pour traiter le tableau étape par étape pour réduire la consommation de mémoire.
Traitez de grands tableaux en lots, en fonctionnant un petit lot à la fois, en évitant la mémoire et les contraintes de temps.
Avec ces stratégies d'optimisation, vous pouvez améliorer considérablement les performances de la fonction Array_Column lorsque vous traitez avec de grands tableaux.
