Français
Français
Dans la programmation PHP, la fonction array_diff_assoc () est utilisée pour comparer les paires de valeurs clés de deux tableaux ou plus, renvoyant ces paires de valeurs clés qui sont dans le premier tableau mais pas dans d'autres tableaux. Il fonctionne en comparant la somme des tableaux. Cependant, de nombreux développeurs rencontrent des problèmes lors de l'utilisation de Array_Diff_assoc () , en particulier lorsqu'ils traitent des chaînes et des types numériques. Cet article explorera ces malentendus communs et leurs raisons.
Avant de discuter du problème en détail, passons en revue l'utilisation de base de la fonction array_diff_assoc () :
<?php
$array1 = ['a' => 'apple', 'b' => 10, 'c' => 15];
$array2 = ['a' => 'apple', 'b' => '10', 'c' => 20];
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>
Le résultat de la sortie est:
Array
(
[b] => 10
[c] => 15
)
Dans l'exemple ci-dessus, bien que la valeur de clé 'B' dans le tableau $ array2 soit la chaîne '10' et la valeur de clé 'b' dans $ array1 est l'entier 10 , array_diff_assoc () les considère différents et les renvoie comme une différence.
Ce problème se produit avec une conversion de type implicite en PHP. Lorsque vous essayez de comparer différents types de données, PHP le convertira automatiquement au même type. Par exemple, lors de la comparaison array_diff_assoc () , si une paire de valeurs clés dans le tableau contient le type de chaîne et le type numérique, PHP les traitera comme différents types, entraînant des erreurs.
Par exemple:
<?php
$array1 = [0 => '10'];
$array2 = [0 => 10];
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>
Ce code sortira:
Array
(
[0] => 10
)
Bien que Array_Diff_assoc () soit utilisé pour comparer les clés et les valeurs, et les deux sont les mêmes "10" dans le tableau, la fonction les considère comme différentes en raison de types incohérents (l'un est une chaîne et l'autre est un entier).
La conversion de type implicite dans PHP peut entraîner le renvoi de la fonction Array_Diff_assoc () . Par exemple, lorsque vous passez dans une chaîne et un nombre comme comparaison, PHP convertira le numéro en une chaîne ou une chaîne en nombre par défaut, selon le contexte.
Par exemple, le code suivant rencontrera une erreur:
<?php
$array1 = ['a' => '123'];
$array2 = ['a' => 123];
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>
Sortir:
Array
(
[a] => 123
)
array_diff_assoc () estime que «123» et 123 sont différents car l'un est une chaîne et l'autre est un nombre, ce qui fait que le résultat ne répond pas aux attentes.
Pour éviter les erreurs de comparaison dues à l'incohérence de type, il est recommandé de s'assurer que les types de valeur dans le tableau sont cohérents lors de l'utilisation de Array_Diff_assoc () . Si vous devez comparer différents types de valeurs, vous pouvez envisager de réaliser explicitement la conversion de type.
Avant de faire la comparaison, toutes les valeurs peuvent être explicitement converties en même type, par exemple en chaîne ou en nombre:
<?php
$array1 = ['a' => (string) 123];
$array2 = ['a' => '123'];
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>
Ce code garantit que les deux sont du même type (chaîne), évitant ainsi des erreurs inutiles.
Si vous avez besoin de traiter par lots toutes les valeurs dans un tableau, vous pouvez utiliser la fonction array_map () :
<?php
$array1 = ['a' => 123, 'b' => 456];
$array2 = ['a' => '123', 'b' => '456'];
$array1 = array_map('strval', $array1); // Convertir toutes les valeurs en chaînes
$array2 = array_map('strval', $array2);
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>
Cela garantit que les valeurs dans les deux tableaux restent cohérentes dans la comparaison array_diff_assoc () .
Lorsque vous utilisez la fonction array_diff_assoc () , les types de chaîne et de nombres sont souvent erronés, en raison de la conversion de type implicite en php. Lorsqu'un développeur effectue des comparaisons de tableau, il est préférable de s'assurer que tous les types de valeur impliqués dans la comparaison sont cohérents. La conversion de type explicite ou l'utilisation de fonctions d'assistance telles que Array_Map () peut aider à éviter les problèmes causés par les incohérences de type, ce qui rend les comparaisons plus précises.
