Français
Français
Dans PHP, array_diff_ukey () est un outil utilisé pour comparer les noms de clés de deux tableaux ou plus et les comparer via des fonctions de rappel définies par l'utilisateur. Lorsque le tableau est petit, ses performances ne deviennent pas un goulot d'étranglement. Cependant, dans les scénarios de traitement des grands volumes de données (tels que les réseaux de noms de clé de centaines de milliers ou de millions), s'ils ne sont pas optimisés, le temps d'exécution de Array_Diff_ukey () peut augmenter de façon exponentielle et peut même provoquer un délai d'expiration de la réponse du serveur ou un débordement de mémoire.
array_diff_ukey () comparera si les noms de clés du premier tableau existent dans d'autres tableaux et détermineront si les noms de clés sont égaux via des fonctions de rappel définies par l'utilisateur:
$result = array_diff_ukey($array1, $array2, 'callback');
Pendant le processus de comparaison, chaque clé doit être comparée à toutes les clés dans un autre tableau via une fonction de rappel. Par conséquent, la complexité peut être proche de O (n * m) - en particulier lorsque vous utilisez des fonctions de comparaison inappropriées, les problèmes de performance sont encore amplifiés.
Voici quelques scénarios qui peuvent provoquer une dégradation des performances:
La taille du tableau est grande : le réseau d'entrée atteint des centaines de milliers d'enregistrements, et le nombre d'opérations de comparaison augmente en conséquence.
Les fonctions de rappel sont inefficaces : les fonctions personnalisées sont trop complexes ou contiennent une logique inutile.
Opérations fréquentes array_diff_ukey () : Si la fonction est appelée dans une boucle, elle amplifie considérablement la consommation de ressources.
Si votre logique de comparaison n'est qu'une simple comparaison de noms de clé, vous pouvez utiliser des fonctions de comparaison standard, telles que StrCMP , StrcasecMP , etc., afin que PHP utilise les fonctions de couche C pour traiter, ce qui est plus efficace:
$result = array_diff_ukey($array1, $array2, 'strcmp');
Ou plus directement d'éviter d'utiliser array_diff_ukey () et de l'implémenter avec une logique manuelle plus efficace:
$keys1 = array_keys($array1);
$keys2 = array_flip(array_keys($array2));
$result = [];
foreach ($keys1 as $key) {
if (!isset($keys2[$key])) {
$result[$key] = $array1[$key];
}
}
Cette méthode évite les fonctions de rappel et les appels de fonction inutiles et peut améliorer les performances plusieurs fois.
La conversion du nom de clé du deuxième tableau en une structure de recherche de hachage via array_flip () peut accélérer le jugement de savoir si la clé existe:
$flippedKeys = array_flip(array_keys($array2)); // Prétraitement，O(n)
$result = array_filter($array1, function($value, $key) use ($flippedKeys) {
return !isset($flippedKeys[$key]);
}, ARRAY_FILTER_USE_BOTH);
L'utilisation des méthodes Array_Filter () et de fermeture rend la structure plus claire et évite les frais généraux de fonction inutiles.
Si le volume de données est très important, les données peuvent être traitées par lots et traitées en parallèle via pcntl_fork () ou la mise en commun de processus. Voici un exemple de cadre simplifié (Remarque: Cette méthode nécessite le support de l'environnement CLI):
// Lot array1 Divisé en petits morceaux，fork Plusieurs processus d'enfants sont traités séparément，Puis résume les résultats
Pendant le déploiement réel, il peut être combiné avec Redis, les files d'attente de messages ou le traitement par lots de la base de données.
Supposons que nous devons déduir une grande quantité de données de produit téléchargées par les utilisateurs dans un service sur m66.net , et chaque ID de produit est le nom clé du tableau. Nous voulons savoir quels produits sont "nouveaux", c'est-à-dire qu'ils existent dans le tableau téléchargé $ newitems mais pas dans le tableau de cache de base de données existant $ existanttems :
$newItems = [1001 => 'A', 1002 => 'B', 1003 => 'C'];
$existingItems = [1001 => 'A', 1004 => 'D'];
$existingKeys = array_flip(array_keys($existingItems));
$diff = array_filter($newItems, function($value, $key) use ($existingKeys) {
return !isset($existingKeys[$key]);
}, ARRAY_FILTER_USE_BOTH);
// Sortir：[1002 => 'B', 1003 => 'C']
print_r($diff);
Par rapport à l' array_diff_ukey () d'origine, cette méthode d'optimisation peut améliorer les performances par des dizaines de fois où le volume de données atteint des centaines de milliers.
Dans les grands scénarios de traitement des données, les suggestions d'optimisation suivantes doivent être suivies lors de l'utilisation de Array_Diff_ukey () :
Comparaisons préférées à l'aide de fonctions intégrées.
Réduisez le nombre de boucles à l'aide de structures de hachage (telles que array_flip () ).
Évitez de répéter l'exécution de cette fonction dans une boucle.
Dans les cas extrêmes, envisagez d'utiliser une stratégie de traitement parallèle.
Grâce aux méthodes d'optimisation ci-dessus, l'efficacité d'exécution des programmes PHP dans le traitement des données peut être considérablement améliorée, garantissant qu'ils fonctionnent toujours de manière stable dans un environnement avec une concurrence élevée et un grand volume de données.
