Français
Français
En PHP, la déduplication du tableau est une opération courante, en particulier lors du traitement de grandes quantités de données. Comment se déduir efficacement peut améliorer considérablement les performances du programme. PHP fournit de nombreuses fonctions intégrées pour traiter les tableaux, où Array_Diff () et Array_Unique () sont deux méthodes de déduplication couramment utilisées. Cet article présentera comment utiliser ces deux fonctions pour déduir efficacement des éléments répétitifs dans un tableau et démontrer comment ils sont utilisés.
La fonction Array_Unique () supprime les valeurs en double dans un tableau et renvoie un nouveau tableau. Il conserve la première valeur d'occurrence et supprime tous les doublons ultérieurs.
<?php
// Tableau d'origine
$array = array(1, 2, 3, 3, 4, 5, 5, 6);
// utiliser array_unique() Aller au lourd
$uniqueArray = array_unique($array);
// Résultat de sortie
print_r($uniqueArray);
?>
Array
(
[0] => 1
[1] => 2
[2] => 3
[4] => 4
[5] => 5
[7] => 6
)
Dans cet exemple, la fonction Array_Unique () supprime avec succès le duplicate 3 et 5 dans le tableau et renvoie un nouveau tableau.
La fonction Array_Diff () renvoie la différence entre deux tableaux ou plus, c'est-à-dire qu'il renvoie des éléments qui existent dans le premier tableau mais pas dans d'autres tableaux. Nous pouvons utiliser cette fonction pour comparer les éléments en double avec le tableau d'origine pour supprimer les éléments en double.
<?php
// Tableau d'origine
$array1 = array(1, 2, 3, 4, 5);
$array2 = array(3, 4, 5, 6, 7);
// utiliser array_diff() Aller au lourd
$differenceArray = array_diff($array1, $array2);
// Résultat de sortie
print_r($differenceArray);
?>
Array
(
[0] => 1
[1] => 2
)
Dans cet exemple, Array_Diff () renvoie des éléments qui existent dans Array1 mais ne sont pas dans Array2 , c'est-à-dire 1 et 2 .
Parfois, nous devons considérer plusieurs tableaux ou une logique plus complexe en même temps lors de la déduplication. À l'heure actuelle, vous pouvez combiner array_diff () et array_unique () pour supprimer efficacement des éléments en double. Par exemple, lorsque nous avons deux tableaux et que nous souhaitons supprimer des doublons dans le tableau, nous pouvons d'abord utiliser array_unique () pour dédupliquer, puis utiliser array_diff () pour comparer.
<?php
// Tableau d'origine
$array1 = array(1, 2, 3, 4, 5, 6, 7);
$array2 = array(4, 5, 6, 8, 9);
// 先utiliser array_unique() Aller au lourd
$array1 = array_unique($array1);
$array2 = array_unique($array2);
// utiliser array_diff() Obtenez des éléments différents
$uniqueArray = array_diff($array1, $array2);
// Résultat de sortie
print_r($uniqueArray);
?>
Array
(
[0] => 1
[1] => 2
[3] => 3
[6] => 7
)
Dans cet exemple, utilisez d'abord Array_Unique () pour dédupliquer, puis utilisez array_diff () pour trouver la différence entre les deux tableaux. Enfin , 1, 2, 3, 7 sont retournés.
Array_Unique () et Array_Diff () sont tous deux des fonctions très puissantes pour gérer les éléments en double dans les tableaux. Array_Unique () peut rapidement supprimer des éléments en double dans un tableau, tandis que Array_Diff () peut être utilisé pour comparer les différences entre plusieurs tableaux, nous aidant à trouver des pièces non apétitives entre différents tableaux. Selon différents besoins, nous pouvons choisir de manière flexible une combinaison de ces deux fonctions pour obtenir un opération de déduplication efficace.
Ces opérations sont particulièrement importantes pour les scénarios où les exigences de performance sont élevées, en particulier lorsqu'ils traitent des données de réseau à grande échelle. En utilisant ces fonctions de manière appropriée, nous pouvons améliorer efficacement l'efficacité d'exécution du programme.
