Français
Français
PHP est un langage de programmation couramment utilisé qui fournit aux développeurs des fonctions de fonctionnement de réseaux riches. Au cours du processus de traitement de la table, array_diff_assoc () est une fonction très utile qui peut être utilisée pour comparer deux tableaux et des éléments de retour qui existent dans le premier tableau mais pas dans le deuxième tableau. Cette fonction compare non seulement les clés et les valeurs, mais considère également leurs types.
Aujourd'hui, l'objectif que nous allons explorer est pourquoi Array_Diff_assoc () est sensible à la casse et comment cette différence de cas affecte le résultat.
Tout d'abord, passons rapidement en revue l'utilisation de base de la fonction array_diff_assoc () . Le prototype de cette fonction est le suivant:
array_diff_assoc(array $array1, array $array2): array
Cette fonction renvoie un tableau contenant tous les éléments dans $ array1 mais pas dans $ array2 . Il convient de noter que Array_Diff_assoc () prendra en compte le type de clé et de valeur et le contenu de la valeur.
$array1 = array(
"a" => "apple",
"b" => "banana",
"c" => "cherry"
);
$array2 = array(
"a" => "apple",
"b" => "Banana",
"c" => "cherry"
);
$result = array_diff_assoc($array1, $array2);
print_r($result);
Le résultat de la sortie est:
Array
(
[b] => banana
)
La raison pour laquelle array_diff_assoc () est sensible à la casse est sa méthode de comparaison. À l'intérieur de la fonction, PHP utilise l'opérateur de convergence ( === ) pour comparer les paires de valeurs clés de deux tableaux. Les opérateurs congruents comparent non seulement le contenu des valeurs, mais aussi leurs types et leurs cas majuscules et majuscules.
Dans l'exemple de code ci-dessus, nous voyons:
La valeur de $ array1 ["b"] est "banane"
La valeur de $ array2 ["b"] est "banane"
Étant donné que Array_Diff_assoc () utilise des opérateurs de convergence à titre de comparaison, PHP considérera "banane" et "banane" comme des chaînes différentes car les comparaisons de chaînes sont sensibles à la casse.
Par conséquent, Array_Diff_assoc () dans cet exemple pense que "banane" dans Array1 et "Banana" dans Array2 est différent, le renvoyant ainsi comme une différence.
La nature sensible au cas de Array_Diff_assoc () aura un impact significatif sur les résultats. Si vous ne voulez pas qu'il soit sensible à la casse, envisagez d'utiliser d'autres méthodes de comparaison. Par exemple, vous pouvez utiliser la fonction array_map () pour convertir toutes les valeurs en minuscules (ou majuscules), puis comparer.
$array1 = array(
"a" => "apple",
"b" => "banana",
"c" => "cherry"
);
$array2 = array(
"a" => "apple",
"b" => "Banana",
"c" => "cherry"
);
// Convertir toutes les valeurs en minuscules
$array1 = array_map('strtolower', $array1);
$array2 = array_map('strtolower', $array2);
$result = array_diff_assoc($array1, $array2);
print_r($result);
Ce code convertira les valeurs des deux tableaux en minuscules, puis les comparera. La sortie sera:
Array
(
[b] => banana
)
array_diff_assoc () est sensible à la casse car il utilise l'opérateur congruent pour comparer les clés et les valeurs d'un tableau, qui prend en compte les différences de cas lors de la comparaison des chaînes. Pour éviter ce problème, vous pouvez utiliser array_map () et d'autres méthodes pour convertir la valeur du tableau en cas uniforme avant d'appeler Array_Diff_assoc () pour s'assurer que le résultat ne sera pas affecté par la différence dans le cas.
J'espère que cet article vous aidera à mieux comprendre le comportement de Array_Diff_assoc () et comment il gère les différences de cas. Si vous avez d'autres questions, n'hésitez pas à poser!
