Détecter s'il existe plusieurs valeurs différentes dans le tableau PHP

Cet article vise à fournir une méthode efficace pour déterminer si un tableau PHP contient au moins deux valeurs différentes. En utilisant la fonction Array_count_values pour compter la fréquence d'occurrence de chaque valeur dans le tableau et combiner le compte du tableau de résultat, nous pouvons vérifier rapidement et avec précision l'unicité des éléments dans le tableau, fournissant ainsi des jugements critiques lorsque la cohérence des données est nécessaire.

1. Problème Contexte et exigences

Dans le développement de PHP, nous rencontrons souvent des scénarios où nous devons vérifier la cohérence des ensembles de données. Par exemple, lors de la gestion des opérations par lots ou des importations de données, il peut être nécessaire de garantir qu'un certain identifiant clé (tel que "ID de vendeur", "ID de catégorie de produit", etc.) est unique dans un tableau donné, ou au moins plusieurs valeurs différentes ne peuvent pas apparaître. Si deux valeurs différentes ou plus apparaissent dans le tableau, une logique ou une invite spécifique doit être déclenchée.

Par exemple, il y a un tableau d'identifices du vendeur:

 $ vendeurs = [1, 10]; // il y a deux ID de vendeur différents
$ vendeurs = [10, 10, 10]; // Tous les ID des vendeurs sont les mêmes

Notre objectif est de pouvoir identifier et répondre lorsqu'il y a au moins deux ID de vendeur différents dans le tableau.

2. Solution de base: utilisez array_count_values ()

PHP fournit une fonction intégrée array_count_values (), qui peut résoudre ce problème très gracieusement.

2.1 Explication détaillée de la fonction array_count_values ()

La fonction array_count_values () est utilisée pour compter la fréquence d'occurrence de toutes les valeurs dans un tableau. Il renvoie un tableau associatif où la clé est les seules valeurs du tableau d'origine, et la valeur est le nombre de fois que ces valeurs uniques apparaissent dans le tableau d'origine.

grammaire:

 array_count_values (array $ array): array

Comment ça marche:

1. Itérer sur le réseau d'entrée.
2. Pour chaque valeur dans le tableau, s'il s'agit d'une nouvelle valeur, une nouvelle entrée dans le tableau de résultat avec la valeur en tant que clé et son nombre est définie sur 1.
3. Si la valeur existe déjà dans le tableau de résultat, le nombre correspondant est augmenté de 1.

2.2 Logique d'implémentation

Après avoir obtenu un tableau contenant des valeurs uniques et leur nombre via array_count_values (), nous devons seulement vérifier le nombre d'éléments de ce tableau de résultat. Si son nombre d'éléments est supérieur à 1, cela signifie qu'il y a au moins deux valeurs différentes dans le tableau d'origine.

Étapes spécifiques:

1. Passez le tableau à vérifier comme argument à array_count_values ().
2. Obtient le tableau de résultat renvoyé par array_count_values ().
3. Utilisez la fonction Count () pour calculer le nombre d'éléments dans le tableau résultant.
4. Si le résultat de Count () est supérieur à 1, cela signifie qu'il existe plusieurs valeurs différentes dans le tableau d'origine.

2.3 Exemple de code

Le code suivant montre comment utiliser array_count_values () pour détecter s'il existe plusieurs valeurs différentes dans un tableau:

  Php

/ **
 * Vérifiez s'il y a plus d'une valeur différente dans le tableau *
 * @param array $ tableau tableau à cocher * @return bool return true s'il y a plus d'une valeur différente; Sinon, renvoyez false.
 * /
La fonction contient la réévalue de la réévaluation (tableau $ array): bool
{
    // Utilisez Array_count_values pour compter le nombre d'occurrences de chaque valeur $ uniquevaluesCount = array_count_values ($ array);

    // Si le nombre d'éléments dans le tableau des résultats statistiques est supérieur à 1, cela signifie qu'il y a plus d'une valeur différente dans le nombre de retours de tableau d'origine ($ uniquesCountSownt)> 1;
}

// Exemple 1: Toutes les valeurs sont les mêmes $ Sellers1 = [10, 10, 10];
Echo "Array Sellers1:". Implode (',', $ Sellers1). "\ n";
if (contientMoreThanOneUniqueValue ($ Sellers1)) {
    Echo "Résultat: il y a plus d'une valeur différente dans le tableau. \ n";
} autre {
    Echo "Résultat: toutes les valeurs du tableau sont les mêmes (ou une seule valeur). \ n";
}
echo "----------------------------------------------------------------------------------------------------------------------------

// Exemple 2: Il existe différentes valeurs $ sellers2 = [1, 10];
Echo "Array Sellers2:". Implode (',', $ Sellers2). "\ n";
if (contientMoreThanOneUniqueValue ($ Sellers2)) {
    Echo "Résultat: il y a plus d'une valeur différente dans le tableau. \ n";
} autre {
    Echo "Résultat: toutes les valeurs du tableau sont les mêmes (ou une seule valeur). \ n";
}
echo "----------------------------------------------------------------------------------------------------------------------------

// Exemple 3: Array vide $ Sellers3 = [];
Echo "Array Sellers3:". Implode (',', $ Sellers3). "\ n";
if (contientMoreThanOneUniqueValue ($ Sellers3)) {
    Echo "Résultat: il y a plus d'une valeur différente dans le tableau. \ n";
} autre {
    Echo "Résultat: toutes les valeurs du tableau sont les mêmes (ou une seule valeur). \ n";
}
echo "----------------------------------------------------------------------------------------------------------------------------

// Exemple 4: tableau avec un seul élément $ sellers4 = [5];
Echo "Array Sellers4:". Implode (',', $ Sellers4). "\ n";
if (contientMoreThanOneUniqueValue ($ Sellers4)) {
    Echo "Résultat: il y a plus d'une valeur différente dans le tableau. \ n";
} autre {
    Echo "Résultat: toutes les valeurs du tableau sont les mêmes (ou une seule valeur). \ n";
}
echo "----------------------------------------------------------------------------------------------------------------------------

// Exemple 5: Array $ articles contenant des chaînes = ["pomme", "banane", "pomme"];
Echo "Articles Array:". Improde (',', $ items). "\ n";
if (contientMoreThanOneUniqueValue ($ items)) {
    Echo "Résultat: il y a plus d'une valeur différente dans le tableau. \ n";
} autre {
    Echo "Résultat: toutes les valeurs du tableau sont les mêmes (ou une seule valeur). \ n";
}
echo "----------------------------------------------------------------------------------------------------------------------------

?>

Explication du code:

• La fonction contient la fonctionnalité de la réévaluation de la façon dont la logique principale pour le rendre réutilisable.
• $ UniQuevaluesCount = array_count_values ($ array); Cette ligne est la clé, qui convertit le tableau d'origine en un tableau ne contenant que des valeurs uniques sous forme de clés.
• Return Count ($ UniQuevaluesCount)> 1; En vérifiant la longueur du tableau converti, déterminez directement s'il y a plus d'une valeur unique dans le tableau d'origine.

3. Précautions et alternatives

• Prise en charge du type de données : la fonction array_count_values () convient à la gestion des valeurs et des chaînes numériques. Pour les tableaux contenant des types de données complexes tels que des objets ou des ressources, leur comportement peut ne pas être comme prévu car ces types ne peuvent pas être directement utilisés comme clés pour les tableaux associatifs.
• Considérations de performances : pour les tableaux très grands (par exemple, des tableaux contenant des centaines de milliers ou même des millions d'éléments), Array_count_values () construit une nouvelle table de hachage en mémoire pour stocker le nombre de chaque valeur. Cela peut entraîner une consommation de mémoire plus élevée. Dans des scénarios extrêmement sensibles aux performances, d'autres algorithmes peuvent devoir être pris en compte, par exemple, si le tableau est trié, il peut être vérifié par une seule traversée.
• Alternative: Array_Unique () : Une autre façon d'atteindre le même objectif est d'utiliser la fonction Array_Unique (), qui supprime les valeurs en double du tableau, puis nous vérifions la longueur du tableau résultant.

   Fonction contient lamethanoneuniquevalueAlternative (array $ array): bool
  {
      Return Count (Array_Unique ($ array))> 1;
  }

  Cette méthode est tout aussi efficace et concise. Dans la plupart des cas, la différence de performance entre les deux n'est pas significative, mais array_count_values () est plus avantageuse dans certains scénarios où il doit connaître le nombre spécifique d'occurrences de chaque valeur, car elle fournit des statistiques plus détaillées. Si vous souhaitez simplement déterminer s'il existe plusieurs valeurs uniques, les deux méthodes sont acceptables.

4. Résumé

L'utilisation de la fonction array_count_values () est un moyen simple et efficace de détecter si un tableau contient plusieurs valeurs différentes en PHP. Il profite des caractéristiques d'optimisation des fonctions intégrées PHP pour effectuer rapidement une analyse statistique du contenu de la matrice. Dans la plupart des scénarios d'entreprise, cette approche est suffisante pour répondre aux besoins et peut améliorer efficacement la lisibilité et la maintenance du code. Lorsque vous traitez avec des tableaux extrêmement importants, vous devez prêter attention à leur consommation potentielle de mémoire et choisir la solution la plus appropriée en fonction de la situation spécifique.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!