Français
Français
Dans le développement quotidien de PHP, la gestion des différences de tableau est une exigence commune. La fonction Array_Diff () fournit un moyen très pratique de trouver la différence entre deux tableaux. Mais de nombreux développeurs se demanderont: Array_Diff () est-il vraiment efficace? Dans les scénarios sensibles à la performance, devrions-nous choisir de traverser manuellement le tableau pour atteindre le même objectif?
Cet article explorera les performances de Array_Diff () et la traversée manuelle dans différents scénarios d'utilisation pour vous aider à faire des choix plus intelligents.
Array_Diff () est une fonction intégrée fournie par PHP pour comparer les valeurs d'un tableau et des valeurs de retour dans le premier tableau mais pas dans d'autres tableaux. La syntaxe de base est la suivante:
$result = array_diff($array1, $array2);
Par exemple:
$a = [1, 2, 3, 4];
$b = [3, 4, 5];
$result = array_diff($a, $b); // Sortir: [0 => 1, 1 => 2]
Nous pouvons également implémenter la même fonction via ForEach :
$result = [];
foreach ($a as $value) {
if (!in_array($value, $b)) {
$result[] = $value;
}
}
Lorsque de petits tableaux sont traités (comme moins de 100 éléments), l'écart de performance entre les deux est minime. Array_Diff () est une fonction intégrée implémentée dans le langage C, avec une efficacité d'exécution élevée, tandis que la traversée manuelle ajoute uniquement des frais généraux de niveau PHP. Mais ces frais généraux sont presque négligeables dans les petits tableaux.
Lorsque le nombre de tableaux augmente, comme contenant des milliers d'éléments, l'écart de performance commence à apparaître. Voici une référence simple:
$a = range(1, 10000);
$b = range(5000, 15000);
// utiliser array_diff
$start = microtime(true);
array_diff($a, $b);
echo 'array_diffprend du temps: ' . (microtime(true) - $start) . " Deuxième\n";
// utiliser手动遍历
$start = microtime(true);
$result = [];
foreach ($a as $value) {
if (!in_array($value, $b)) {
$result[] = $value;
}
}
echo '手动遍历prend du temps: ' . (microtime(true) - $start) . " Deuxième\n";
Les résultats montrent que lorsque le volume de données est important, Array_Diff () est nettement meilleur que la traversée manuelle, en particulier lorsque le nombre d'éléments dans $ B est très grand, in_array () est O (n) chaque recherche, et la mise en œuvre interne array_diff () a un traitement de hachage plus efficace.
Si vous vous en tenez à la méthode manuelle, vous pouvez également optimiser les performances en convertissant le tableau de contraste $ B en une structure de hachage (par exemple, array_flip () ):
$hashMap = array_flip($b);
$result = [];
foreach ($a as $value) {
if (!isset($hashMap[$value])) {
$result[] = $value;
}
}
Les performances de cette manière sont presque les mêmes que Array_Diff () , et parfois encore plus rapides, en particulier dans la logique ou les scénarios complexes où un traitement supplémentaire est requis.
Gérer rapidement et concise l'ensemble de différence de deux tableaux
Scénarios avec lisibilité à un code élevé
Aucune logique de comparaison personnalisée requise
Lorsque le nombre d'éléments de tableau est modéré ou important
Besoin de personnaliser les jugements logiques (comme la comparaison uniquement de certains champs ou des tableaux structurés)
Vous savez que le tableau de comparaison est plus petit, ou vous pouvez utiliser array_flip () pour optimiser les performances
Extrêmement sensible aux performances et vous pouvez gérer manuellement la logique de traversée
Array_Diff () est une fonction de performance très pratique et généralement bonne, mais ce n'est pas toujours le meilleur choix. La traversée manuelle avec des structures de données raisonnables (telles que les tables de hachage) peut être plus avantageuse lorsque un contrôle flexible ou une optimisation extrême des performances est nécessaire.
N'oubliez pas que le cœur de l'optimisation est toujours de choisir en fonction des compromis de scénario , plutôt que de poursuivre aveuglément une certaine méthode "plus rapide".
