Français
Français
Dans le développement quotidien de PHP, les goulots d'étranglement de la mémoire sont souvent rencontrés lorsqu'ils traitent des collections de données à grande échelle. Les générateurs de PHP sont introduits depuis PHP 5.5, nous fournissant un moyen de traverser les données paresseux, tandis que la fonction array_diff_ukey () peut être utilisée pour personnaliser et comparer les différences entre deux tableaux en fonction du nom de clé. Lorsque nous utilisons ces deux fonctions en combinaison, nous pouvons considérablement améliorer l'efficacité de la mémoire, en particulier lorsque la source de données est très grande.
Cet article présentera les avantages de cette combinaison et montrera à travers des exemples comment les utiliser efficacement.
La traversée traditionnelle du tableau nécessite le chargement du tableau entier en mémoire, et le générateur génère des éléments de données selon les besoins via le mot clé de rendement , sans charger tout le contenu à la fois, il est donc particulièrement efficace lors du traitement de grands ensembles de données.
L'exemple de fonction du générateur est le suivant:
function getLargeArrayFromSource() {
for ($i = 0; $i < 1000000; $i++) {
yield "key_$i" => "value_$i";
}
}
Ce générateur produira un grand tableau avec des valeurs clés de Key_0 à Key_999999 , mais en fait, il ne génère qu'une seule paire de valeurs clés à la fois.
La fonction array_diff_ukey () est utilisée pour comparer les touches de deux tableaux et des éléments de retour dans le premier tableau qui ne sont pas inclus dans la deuxième clé de tableau. Habituellement, cette fonction reçoit deux tableaux complets, ce qui peut entraîner un débordement de mémoire lorsqu'il s'agit de tableaux super grands.
Cependant, nous pouvons transmettre des données dans cette fonction via le générateur, combinée avec iterator_to_array () pour atteindre la traversée et la comparaison, réduisant l'utilisation de la mémoire:
function getLocalKeys() {
return [
"key_1" => "old_value_1",
"key_2" => "old_value_2",
"key_999999" => "old_value_final"
];
}
function getRemoteKeysGenerator() {
for ($i = 0; $i < 1000000; $i++) {
yield "key_$i" => "remote_value_$i";
}
}
$localKeys = getLocalKeys();
$remoteKeysGenerator = getRemoteKeysGenerator();
// Convertir le générateur en tableau pour comparaison，Mais seules les données avec différents noms de clés sont conservées
$diff = array_diff_ukey(
iterator_to_array($remoteKeysGenerator, false),
$localKeys,
function ($a, $b) {
return strcmp($a, $b);
}
);
echo "Nombre de clés de données différentielles: " . count($diff) . PHP_EOL;
// Exemple de traitement de sortie
foreach (array_slice($diff, 0, 5, true) as $key => $value) {
echo "Pas de clé correspondante: $key => $value" . PHP_EOL;
}
Si les données de comparaison sont trop grandes, iterator_to_array () peut toujours entraîner une pression de mémoire. Pour le moment, vous pouvez implémenter la logique de comparaison de différence par vous-même, traverser les éléments du générateur un par un et juger s'il existe avec la clé locale.
En extrayant des clés de tableau locales dans les collections de hachage, vous pouvez rapidement rechercher et améliorer l'efficacité de comparaison.
Imaginez que vous construisez un système qui synchronise les SKU de produits avec des API tiers, avec un certain nombre de SKU localement, et un serveur distant (tel que https://api.m66.net/products ) renvoie une grande quantité de données de SKU. Cette stratégie de comparaison de chargement paresseuse + différence est particulièrement importante sur les serveurs à mémoire de mémoire.
En combinant le générateur avec la fonction array_diff_ukey () , nous pouvons réduire efficacement l'utilisation de la mémoire des programmes PHP pendant le traitement des données à grande échelle. Le générateur offre la possibilité de retarder l'exécution, et array_diff_ukey () nous donne la flexibilité de comparer les noms de clés, réalisant ainsi une logique de traitement des données plus efficace et évolutive. Espérons que les exemples de cet article apporteront des effets d'optimisation substantiels à votre projet.
