Français
Français
Comment utiliser la fonction Array_Diff () de PHP pour implémenter la comparaison de profondeur des tableaux multidimensionnels? Doit-il être traité récursivement?
Dans PHP, Array_Diff () est une fonction très courante qui renvoie des valeurs différentes dans deux tableaux ou plus. Lors de la comparaison des tableaux multidimensionnels, array_diff () ne peut que comparer uniquement la dimensionnalité du tableau. Si nous devons effectuer des comparaisons profondes sur des tableaux multidimensionnels, Array_Diff () ne suffit pas pour terminer cette tâche. Afin d'obtenir une comparaison de profondeur des tableaux multidimensionnels, nous devons utiliser la récursivité pour comparer chaque couche d'élément de tableau par couche.
Cet article présentera comment utiliser la fonction Array_Diff () conjointement avec Recursion pour implémenter une comparaison profonde des tableaux multidimensionnels et expliquer pourquoi la récursivité est nécessaire.
Tout d'abord, comprenons l'utilisation de base de Array_Diff () . Cette fonction renvoie un tableau contenant tous les éléments qui apparaissent dans le premier tableau mais pas dans le tableau suivant. Sa syntaxe de base est la suivante:
array_diff(array $array1, array ...$arrays): array
Par exemple, le code suivant montre comment comparer deux tableaux unidimensionnels avec array_diff () :
$array1 = [1, 2, 3, 4];
$array2 = [3, 4, 5, 6];
$result = array_diff($array1, $array2);
print_r($result);
Sortir:
Array
(
[0] => 1
[1] => 2
)
Comme vous pouvez le voir, Array_Diff () retournera des éléments qui existent dans le Array $ array1 mais pas dans $ array2 .
À titre de comparaison des tableaux multidimensionnels, array_diff () ne peut pas être effectué directement par défaut car il compare uniquement les tableaux unidimensionnels. Lorsque l'élément du tableau lui-même est un tableau, array_diff () comparera directement les références du tableau au lieu de comparer récursivement.
Afin d'atteindre une comparaison profonde des tableaux multidimensionnels, nous devons écrire une fonction récursive qui compare chaque élément de la couche de tableau par couche. Voici un exemple de mise en œuvre récursive de la comparaison de la profondeur multidimensionnelle:
function array_diff_recursive($array1, $array2) {
$result = [];
// Itérer sur le premier tableau
foreach ($array1 as $key => $value) {
if (is_array($value) && isset($array2[$key]) && is_array($array2[$key])) {
// Si la valeur est un tableau et qu'il y a aussi un tableau correspondant dans le deuxième tableau，Appel récursif
$recursive_diff = array_diff_recursive($value, $array2[$key]);
if (!empty($recursive_diff)) {
$result[$key] = $recursive_diff;
}
} else {
// Si la valeur n'est pas un tableau，Utiliser directement array_diff Faire une comparaison
if (!in_array($value, $array2)) {
$result[$key] = $value;
}
}
}
return $result;
}
$array1 = [
'a' => 1,
'b' => [2, 3, 4],
'c' => 5
];
$array2 = [
'a' => 1,
'b' => [2, 3],
'c' => 5
];
$result = array_diff_recursive($array1, $array2);
print_r($result);
Sortir:
Array
(
[b] => Array
(
[2] => 4
)
)
Dans cet exemple, array_diff_recursive () vérifiera récursivement chaque élément dans $ array1 et $ array2 . Si un élément est un tableau et dispose de tableaux correspondants dans les deux tableaux, il continuera de comparer récursivement le sous-réseau; Si un élément n'est pas un tableau, il utilisera directement Array_Diff () pour comparaison.
La récursivité est la clé de la mise en œuvre de la comparaison profonde des tableaux multidimensionnels, car les tableaux multidimensionnels peuvent contenir des sous-réseaux, et ces sous-réseaux peuvent également contenir plus de sous-réseaux, etc. L'utilisation de la récursivité garantit que chaque couche de tableau est correctement comparée. Si vous n'utilisez pas de récursivité, vous ne pouvez comparer que la couche supérieure du tableau et vous ne pouvez pas aller profondément dans chaque couche.
Bien que la fonction Array_Diff () de PHP soit très adaptée à la comparaison des tableaux unidimensionnels, nous devons utiliser la récursivité pour la comparaison de profondeur des tableaux multidimensionnels. Grâce à la récursivité, nous pouvons nous assurer que les éléments de chaque couche de tableau peuvent être comparés un par un. Cette approche est très efficace pour traiter les tableaux multidimensionnels, en particulier lorsqu'ils traitent des tableaux imbriqués.
Si vous devez faire face à des comparaisons de tableaux plus complexes ou si vous devez optimiser davantage les performances récursives, vous devrez peut-être également prendre en compte certaines mesures d'optimisation supplémentaires, mais la méthode de comparaison récursive de base peut répondre à la plupart des besoins.
Espérons que les exemples de cet article vous aident à comprendre comment utiliser PHP pour mettre en œuvre une comparaison profonde des tableaux multidimensionnels.
