Français
Français
En PHP, les opérations de réseau sont des tâches très courantes. En particulier dans le traitement des données, trouver des doublons dans les tableaux est un problème très courant. PHP fournit plusieurs fonctions pour nous aider à atteindre cet objectif, Array_Chunk et Array_INTERSECT étant deux fonctions très utiles. Cet article présentera comment utiliser ces deux fonctions pour trouver des doublons dans un tableau et à quoi vous devez faire attention lorsque vous traitez avec le Big Data.
La fonction Array_Chunk divise un grand tableau en plusieurs petits tableaux. Il accepte deux paramètres, le premier est le tableau d'origine et le second est la taille de chaque petit tableau. Cette fonction renvoie un tableau contenant plusieurs petits tableaux.
$input = range(1, 10); // Générer un 1 arriver 10 Tableau de
$chunks = array_chunk($input, 3); // Divisez le tableau en chacun contenant 3 Sous-réseau d'éléments
print_r($chunks);
Sortir:
Array
(
[0] => Array
(
[0] => 1
[1] => 2
[2] => 3
)
[1] => Array
(
[0] => 4
[1] => 5
[2] => 6
)
[2] => Array
(
[0] => 7
[1] => 8
[2] => 9
)
[3] => Array
(
[0] => 10
)
)
Avec Array_Chunk, nous pouvons diviser de grands tableaux en tableaux plus petits, ce qui, dans certains cas, rendra les opérations ultérieures plus efficaces.
La fonction Array_INTERSECT est utilisée pour trouver les mêmes éléments dans deux tableaux. Il renvoie un tableau contenant les intersections en deux tableaux.
$array1 = [1, 2, 3, 4, 5];
$array2 = [3, 4, 5, 6, 7];
$intersection = array_intersect($array1, $array2);
print_r($intersection);
Sortir:
Array
(
[2] => 3
[3] => 4
[4] => 5
)
Pour trouver des doublons dans un tableau, nous pouvons utiliser Array_Chunk pour diviser le tableau en plusieurs petits morceaux et trouver des éléments en double entre les différents petits morceaux via Array_Intersect . Supposons que nous ayons un tableau avec une grande quantité de données et que nous voulons y trouver les doublons.
Voici un exemple simple montrant comment combiner array_chunk et array_intersect pour trouver des doublons:
// 假设这是我们要处理Tableau de
$array = [1, 2, 3, 4, 5, 3, 6, 7, 8, 9, 10, 3, 2];
// Divisez le tableau en morceaux plus petits
$chunks = array_chunk($array, 3);
// Trouver des doublons entre les blocs
$duplicates = [];
for ($i = 0; $i < count($chunks); $i++) {
for ($j = $i + 1; $j < count($chunks); $j++) {
$intersection = array_intersect($chunks[$i], $chunks[$j]);
if (!empty($intersection)) {
$duplicates = array_merge($duplicates, $intersection);
}
}
}
// Doublons de sortie
$duplicates = array_unique($duplicates); // Aller au lourd
print_r($duplicates);
Sortir:
Array
(
[0] => 3
[1] => 2
)
Bien que les fonctions Array_Chunk et Array_INTERSECT soient très efficaces lors du traitement de petits ensembles de données, nous devons considérer les points suivants lors du traitement des mégadonnées:
Utilisation de la mémoire : Array_Chunk divise le tableau en plusieurs petits tableaux, ce qui peut entraîner l'augmentation de l'utilisation de la mémoire. Si l'ensemble de données est très grand, envisagez de traiter le bloc de données par bloc au lieu de charger toutes les données en mémoire à la fois.
Problème d'efficacité : Array_INTERSECT peut parcourir l'ensemble du tableau à chaque fois qu'il est appelé, ce qui sera très lent pour les grands ensembles de données. Pensez à utiliser des structures de données plus efficaces, telles que des tables de hachage, pour trouver des doublons.
Traitement par lots : Pour les ensembles de données extrêmement importants, les tableaux de traitement par lots sont plus efficaces que le traitement de l'ensemble du tableau à la fois. Les générateurs peuvent être utilisés pour éviter de charger toutes les données en mémoire à la fois.
L'utilisation de Array_Chunk vous permet de diviser de grands tableaux en petits tableaux, ce qui facilite le traitement des données.
L'utilisation de Array_INTERSECT peut nous aider à trouver des éléments en double dans deux tableaux.
Lors du traitement des mégadonnées, une attention particulière doit être accordée aux problèmes de gestion de la mémoire et d'efficacité. Vous pouvez envisager de traiter les données par lots et d'utiliser des structures de données plus efficaces pour optimiser les performances.
Espérons que, à travers les exemples de cet article, vous serez plus compétent pour utiliser Array_Chunk et Array_INTERSECT pour trouver des doublons dans les tableaux et prendre des mesures appropriées pour améliorer les performances de votre code lorsque vous faites face au Big Data.
