Français
Français
En PHP, l'alignement du tableau est une tâche courante, en particulier lorsqu'il est nécessaire de gérer les différences entre plusieurs tableaux. La fonction intégrée de PHP Array_Diff_assoc () est un outil très puissant qui peut être utilisé pour comparer les paires de valeurs clés de deux tableaux ou plus et des éléments de retour qui existent dans le premier tableau mais pas dans d'autres tableaux. Cependant, dans les applications pratiques, il peut y avoir des défis lorsqu'il est nécessaire de gérer efficacement les tâches d'alignement de plusieurs tableaux.
Cet article présentera comment utiliser Array_Diff_assoc () et la structure de boucle pour gérer efficacement les tâches de comparaison multiples multiples, en particulier comment éviter les goulots d'étranglement des performances lorsqu'ils sont confrontés à des comparaisons complexes à plusieurs tableaux.
La fonction array_diff_assoc () est utilisée pour comparer les paires de valeurs clés de deux tableaux. Il renvoie des éléments qui existent dans le premier tableau mais pas dans d'autres tableaux, et prend en compte le nom de clé et la valeur clé en comparant.
grammaire:
array_diff_assoc(array $array1, array $array2, array ...$arrays): array
$ Array1 : Le premier tableau à comparer.
$ array2 , $ Arrays : le tableau qui doit être comparé à l'avenir.
Exemple:
$array1 = ["a" => "apple", "b" => "banana", "c" => "cherry"];
$array2 = ["a" => "apple", "b" => "banana"];
$array3 = ["a" => "apple", "b" => "pear"];
$result = array_diff_assoc($array1, $array2, $array3);
print_r($result);
Sortir:
Array
(
[c] => cherry
)
Dans cet exemple, array_diff_assoc () ne renvoie le terme de différence que dans le tableau $ array1 , c'est-à-dire C => cerise , car le terme existe dans $ array2 et $ array3 .
Lorsque plusieurs tableaux doivent être traités, nous pouvons combiner la structure de boucle pour utiliser à leur tour la fonction array_diff_assoc () . La clé de cette méthode est de déterminer d'abord un tableau principal et de comparer les différences entre les autres tableaux et le tableau principal un par un, et enfin de retourner tous les éléments incompatibles.
Exemple:
// Initialiser plusieurs tableaux
$array1 = ["a" => "apple", "b" => "banana", "c" => "cherry"];
$array2 = ["a" => "apple", "b" => "banana"];
$array3 = ["a" => "apple", "b" => "pear"];
// Stockez plusieurs tableaux en un seul tableau
$arrays = [$array2, $array3];
// Initialiser le tableau de différence
$diff = $array1;
// Cycle de comparaison
foreach ($arrays as $array) {
$diff = array_diff_assoc($diff, $array);
}
print_r($diff);
Sortir:
Array
(
[c] => cherry
)
Dans cet exemple, nous définissons d'abord un tableau principal $ array1 , puis stockons les autres tableaux à comparer dans un tableau. Ensuite, comparez chaque tableau avec $ array1 en séquence via une boucle foreach pour enfin obtenir la différence.
Dans les applications pratiques, si le nombre de tableaux est important, en comparant directement avec la boucle et array_diff_assoc () peut entraîner des problèmes de performance. Afin d'améliorer les performances, il est possible d'envisager d'optimiser la structure des données à l'avance pour réduire le nombre de comparaisons à chaque itération. Par exemple, nous pouvons réduire à l'avance des comparaisons inutiles en fusionnant ou en triant des tableaux à l'avance.
Exemple:
// Initialiser plusieurs tableaux
$array1 = ["a" => "apple", "b" => "banana", "c" => "cherry"];
$array2 = ["a" => "apple", "b" => "banana"];
$array3 = ["a" => "apple", "b" => "pear"];
// Baisses de pré-fusion pour réduire les calculs en double
$mergedArrays = array_merge($array1, $array2, $array3);
// Comparaison des tableaux fusionnés
$diff = array_diff_assoc($array1, $mergedArrays);
print_r($diff);
Cette méthode d'optimisation peut réduire plusieurs traversées du tableau, mais elle doit être appliquée de manière flexible en fonction du scénario spécifique.
Supposons que vous travaillez sur une grande tâche de comparaison des données utilisateur et que vous devez comparer plusieurs tableaux d'utilisateurs pour savoir quelles données utilisateur n'existent pas dans d'autres ensembles de données. Vous pouvez combiner array_diff_assoc () et boucles pour effectuer efficacement les tâches.
// Tableau de données utilisateur
$userData1 = ["user1" => "John", "user2" => "Jane", "user3" => "Tom"];
$userData2 = ["user1" => "John", "user2" => "Jane"];
$userData3 = ["user1" => "John", "user2" => "Alice"];
// Stocker plusieurs données utilisateur
$userDataSets = [$userData2, $userData3];
// Initialiser le tableau de différence
$diffUsers = $userData1;
// Traiter la différence à travers la boucle
foreach ($userDataSets as $userDataSet) {
$diffUsers = array_diff_assoc($diffUsers, $userDataSet);
}
print_r($diffUsers);
Sortir:
Array
(
[user3] => Tom
)
Dans cet exemple complexe, nous traitons plusieurs ensembles de données utilisateur via la fonction Array_Diff_assoc () en combinaison avec des boucles et finissons enfin User3 => Tom , qui est un utilisateur qui n'est pas disponible dans d'autres ensembles de données.
En utilisant rationnellement array_diff_assoc () et la structure de boucle, les tâches de comparaison entre plusieurs tableaux peuvent être gérées efficacement. Cette méthode convient particulièrement aux scénarios où plusieurs différences de tableau doivent être comparées, en gagnant du temps et en améliorant la lisibilité du code. Lors du traitement de grandes quantités de données, vous pouvez encore améliorer les performances en optimisant la structure du tableau.
N'oubliez pas non plus que Array_Diff_assoc () ne comparera que les différences entre les paires de valeurs clés, et si vous avez besoin de conditions de comparaison plus complexes, vous pouvez avoir besoin d'une fonction personnalisée pour répondre aux exigences.
