Français
Français
array_diff_key () est une fonction de PHP qui compare deux tableaux et renvoie des éléments avec différents noms de clés. Ses fonctions semblent simples, mais lors d'une utilisation réelle, il ne fonctionnera parfois pas correctement. Cet article introduira certains problèmes communs et leurs solutions pour vous aider à mieux dépanner et résoudre les problèmes connexes de Array_Diff_Key () .
Lorsque nous utilisons Array_Diff_Key () , nous comparons généralement deux tableaux en tant que paramètres, renvoyant les paires de valeurs clés dans le premier tableau qui ne sont pas dans le deuxième tableau. La syntaxe de base est la suivante:
array_diff_key(array $array1, array $array2): array
Par exemple, supposons qu'il y ait deux tableaux comme suit:
$array1 = [
'apple' => 1,
'banana' => 2,
'cherry' => 3
];
$array2 = [
'banana' => 2,
'date' => 4
];
$result = array_diff_key($array1, $array2);
print_r($result);
Pour le moment, la sortie de $ Résultat devrait être:
Array
(
[apple] => 1
[cherry] => 3
)
Dans cet exemple, array_diff_key () renvoie un élément dont le nom de la clé intermédiaire dans $ array1 n'apparaît pas dans $ array2 .
array_diff_key () est sensible à la casse et le type affecte également le résultat lors de la comparaison des noms de clés. La situation la plus courante est que le type (chaîne ou numéro) des noms clés est incohérent, ce qui entraîne des résultats de comparaison incorrects. Par exemple:
$array1 = [
1 => 'apple',
'2' => 'banana'
];
$array2 = [
'1' => 'apple',
2 => 'banana'
];
$result = array_diff_key($array1, $array2);
print_r($result);
Dans le code ci-dessus, array_diff_key () considérera 1 et «1» comme des clés différentes, tout comme 2 et «2» . Par conséquent, les résultats retournés peuvent vous confondre.
Solution : assurez-vous que les types de noms de clés dans le tableau comparé sont cohérents. Ce problème peut être évité en convertissant explicitement le type de clés du tableau. Par exemple, convertissez tous les noms de clés en chaînes ou numéros:
$array1 = array_map('strval', $array1);
$array2 = array_map('strval', $array2);
array_diff_key () est comparé en fonction des noms de clés, et il ne compare pas les valeurs dans le tableau. Par conséquent, si vous modifiez accidentellement la référence au tableau d'origine lors du passage du tableau, cela peut entraîner des résultats incorrects.
$array1 = [
'apple' => 1,
'banana' => 2
];
$array2 = &$array1; // Passe de référence
$array2['apple'] = 3;
$result = array_diff_key($array1, $array2);
print_r($result);
Dans le code ci-dessus, puisque $ array2 est une référence à $ array1 , la modification de la valeur en informatique affectera également $ array1 . Dans ce cas, le résultat de comparaison de Array_Diff_Key () peut être pire que prévu.
Solution : évitez de passer des références aux tableaux ou copier le tableau avant de les exploiter:
$array2 = $array1;
Parfois, les noms clés d'un tableau peuvent contenir des caractères invisibles, tels que des espaces, des onglets ou d'autres caractères de contrôle. Ces caractères ne seront pas affichés visuellement, mais affecteront les résultats de comparaison de Array_Diff_Key () . Par exemple:
$array1 = [
'apple' => 1,
' banana' => 2
];
$array2 = [
'apple' => 1,
'banana' => 2
];
$result = array_diff_key($array1, $array2);
print_r($result);
Dans le code ci-dessus, la clé «banane» dans $ array1 (avec un espace devant elle) ne correspond pas à la clé «banane» dans $ array2 , ce qui fait que l'élément est incorrectement inclus dans le résultat de sortie.
Solution : vous pouvez utiliser TRIM () ou une expression régulière pour éliminer les espaces inutiles ou les caractères spéciaux.
$array1 = array_map('trim', $array1);
$array2 = array_map('trim', $array2);
array_diff_key () ne peut comparer que les noms de clés des tableaux unidimensionnels. Si votre tableau est multidimensionnel, array_diff_key () ne compare pas les clés récursivement dans les sous-réseaux.
$array1 = [
'fruits' => [
'apple' => 1,
'banana' => 2
]
];
$array2 = [
'fruits' => [
'banana' => 2
]
];
$result = array_diff_key($array1, $array2);
print_r($result);
À ce stade, array_diff_key () ne renvoie pas la différence dans la clé «fruits» . Il compare uniquement les noms de clés de niveau supérieur.
Solution : Si vous devez comparer les clés des tableaux multidimensionnels, vous pouvez utiliser des méthodes récursives pour y parvenir. Vous pouvez écrire une fonction récursive pour itérer via des tableaux multidimensionnels et effectuer des comparaisons clés.
function recursive_diff_key($array1, $array2) {
$result = [];
foreach ($array1 as $key => $value) {
if (!array_key_exists($key, $array2)) {
$result[$key] = $value;
} elseif (is_array($value)) {
$result[$key] = recursive_diff_key($value, $array2[$key] ?? []);
}
}
return $result;
}
$result = recursive_diff_key($array1, $array2);
print_r($result);
array_diff_key () est une fonction PHP très utile, mais elle est sujette à certains problèmes lors de l'utilisation. Comprendre les erreurs courantes et le dépannage efficace de ces problèmes peut vous aider à terminer votre travail de développement plus facilement. Vous pouvez éviter les problèmes les plus courants en vous assurant que le type de nom de clé est cohérent, en évitant la référence, en nettoyant des caractères spéciaux et en travaillant avec des tableaux multidimensionnels en temps opportun.
J'espère que l'introduction de cet article peut vous aider à comprendre certains problèmes potentiels de Array_Diff_Key () et vous fournir des solutions.
