Maîtriser la fonction PHP array_uintersect_uassoc

PHP est un langage puissant disposant de nombreuses fonctions, et array_uintersect_uassoc est l'une des fonctions les plus polyvalentes de la bibliothèque de fonctions de tableaux PHP. Cette fonction vous permet de calculer l'intersection de tableaux avec des fonctions de comparaison de clés définies par l'utilisateur.

Si vous cherchez un moyen de comparer deux tableaux et d'obtenir les valeurs présentes dans tous ceux-ci, la fonction array_uintersect_uassoc est ce qu'il vous faut. Elle offre la flexibilité de comparer des tableaux à l'aide de fonctions de comparaison personnalisées, ce qui en fait un outil précieux pour tout développeur PHP.

Voici une présentation détaillée de la fonction array_uintersect_uassoc, accompagnée d'exemples pour vous aider à comprendre son fonctionnement.

Qu'est-ce que la fonction array_uintersect_uassoc ?

La fonction array_uintersect_uassoc est une fonction native PHP utilisée pour calculer l'intersection de tableaux à l'aide de fonctions de comparaison définies par l'utilisateur pour les données et les clés. Elle compare les valeurs de deux tableaux et retourne les valeurs présentes dans tous ceux-ci, à condition que leurs clés correspondent également selon la fonction de comparaison de clés.

L'une des caractéristiques essentielles de la fonction array_uintersect_uassoc est sa capacité à comparer des tableaux à l'aide de fonctions de comparaison de clés et de valeurs définies par l'utilisateur. Cela signifie que vous pouvez personnaliser la logique de comparaison selon vos besoins spécifiques.

Comment utiliser la fonction array_uintersect_uassoc

La fonction array_uintersect_uassoc accepte deux tableaux ou plus, suivis de deux callbacks — le dernier argument est toujours le callback de comparaison de clés, et celui qui le précède est le callback de comparaison de valeurs. Voici la syntaxe :

Syntaxe de la fonction PHP array_uintersect_uassoc

array_uintersect_uassoc(
    array $array1,
    array $array2,
    array ...$arrays,
    callable $value_compare_func,
    callable $key_compare_func
): array

Paramètres :

• array1 : Le tableau de base. Les valeurs qui survivent à la comparaison sont issues de ce tableau, avec leurs clés d'origine préservées.
• array2, ...$arrays : Un ou plusieurs tableaux à comparer avec array1.
• value_compare_func : Un callback pour comparer les valeurs. Il reçoit deux valeurs et doit retourner un entier inférieur, égal ou supérieur à 0 — exactement comme un comparateur de tri. Retourner 0 signifie « égaux ».
• key_compare_func : Un callback pour comparer les clés, avec le même contrat de retour à trois valeurs.

Valeur de retour : Retourne un tableau contenant toutes les entrées de array1 dont la valeur et la clé correspondent à une entrée dans chacun des autres tableaux. Un élément survit uniquement lorsque les deux callbacks retournent 0 pour un élément de chaque autre tableau.

Étant donné que les deux callbacks suivent le contrat standard <=> (opérateur vaisseau spatial), retourner 1 ou -1 indique simplement à PHP que les éléments ne sont pas égaux — seul 0 compte comme correspondance.

Voyons un exemple d'utilisation de la fonction array_uintersect_uassoc pour comparer deux tableaux :

PHP — Utiliser la fonction array_uintersect_uassoc pour comparer deux tableaux

<?php

function compare_data($a, $b)
{
    if ($a === $b) {
        return 0;
    }
    return ($a > $b) ? 1 : -1;
}

function compare_keys($a, $b)
{
    if ($a === $b) {
        return 0;
    }
    return ($a > $b) ? 1 : -1;
}

$array1 = ["a" => "green", "b" => "brown", "c" => "blue", "d" => "red"];
$array2 = ["a" => "green", "b" => "yellow", "blue", "d" => "red"];

$result = array_uintersect_uassoc($array1, $array2, "compare_data", "compare_keys");
print_r($result);

?>

Dans l'exemple ci-dessus, nous définissons d'abord deux fonctions de comparaison personnalisées pour les données et les clés, puis nous définissons deux tableaux à comparer. Nous appelons ensuite la fonction array_uintersect_uassoc avec les deux tableaux et les deux fonctions de comparaison comme arguments.

La fonction array_uintersect_uassoc retourne un tableau contenant les valeurs présentes dans les deux tableaux. Dans cet exemple, le résultat serait :

Array
(
    [a] => green
    [d] => red
)

Pourquoi seulement a et d ? Un élément survit uniquement lorsque sa clé et sa valeur correspondent.

• [a] => green correspond : la clé a et la valeur green existent dans les deux tableaux. Conservé.
• [b] => brown est supprimé : la clé b existe dans les deux, mais les valeurs (brown vs yellow) diffèrent.
• [c] => blue est supprimé : array1 le contient sous la clé c, mais array2 stocke blue sous la clé numérique auto-assignée 0, donc les clés ne correspondent pas.
• [d] => red correspond : la clé d et la valeur red existent dans les deux. Conservé.

Ce dernier cas illustre précisément ce qui distingue cette fonction de l'intersection basée uniquement sur les valeurs : même lorsqu'une valeur est présente dans les deux tableaux, une clé non correspondante l'exclut.

Remarque : L'exemple utilise des fonctions nommées pour une large compatibilité, mais PHP moderne (7.4+) prend en charge les fonctions fléchées concises (ex. : fn($a, $b) => $a <=> $b). Choisissez la syntaxe adaptée aux exigences de version PHP de votre projet.

Quand utiliser cette fonction

Utilisez array_uintersect_uassoc lorsque les trois conditions suivantes sont réunies : vous avez besoin d'une intersection, les clés sont significatives (données associatives), et les valeurs ou les clés nécessitent une logique de comparaison personnalisée (chaînes insensibles à la casse, objets, tri sensible à la locale, tolérance sur les flottants, etc.). Si seulement l'une de ces conditions s'applique, une fonction plus simple conviendra mieux :

• array_intersect — valeurs uniquement, comparaison native.
• array_intersect_assoc — clé et valeur, comparaison native.
• array_uintersect — valeurs uniquement, callback de valeurs personnalisé.
• array_uintersect_assoc — callback de valeurs personnalisé, comparaison de clés native.
• array_intersect_uassoc — comparaison de valeurs native, callback de clés personnalisé.

Consultez le chapitre PHP Arrays pour une vue d'ensemble plus complète du travail avec les tableaux.

Exemple concret : correspondance insensible à la casse

Le premier exemple utilisait des comparateurs stricts, il se comporte donc comme le array_intersect_assoc natif. La véritable puissance apparaît lorsque les callbacks font quelque chose que les fonctions natives ne peuvent pas faire — ici, faire correspondre les clés et les valeurs indépendamment de la casse :

<?php

$inventory = ["Apple" => "RED", "Banana" => "yellow", "Cherry" => "dark-red"];
$catalog   = ["apple" => "red", "banana" => "GREEN", "cherry" => "DARK-RED"];

$result = array_uintersect_uassoc(
    $inventory,
    $catalog,
    fn($a, $b) => strcasecmp($a, $b), // compare values, ignoring case
    fn($a, $b) => strcasecmp($a, $b)  // compare keys, ignoring case
);

print_r($result);

?>

strcasecmp retourne 0 lorsque deux chaînes sont égales en ignorant la casse, ce qui s'intègre parfaitement dans le contrat de comparateur. Le résultat conserve les entrées de $inventory dont la clé et la valeur correspondent à $catalog sans tenir compte de la casse :

Array
(
    [Apple] => RED
    [Cherry] => dark-red
)

Banana est exclu car, même si les clés correspondent, les valeurs (yellow vs GREEN) diffèrent même en ignorant la casse. Un simple array_intersect_assoc n'aurait retenu aucune de ces entrées, car sa comparaison native est sensible à la casse.

Avantages de l'utilisation de la fonction array_uintersect_uassoc

L'utilisation de la fonction array_uintersect_uassoc dans vos projets PHP présente plusieurs avantages. Voici les principaux :

1. Correspondance précise clé-valeur

Contrairement à array_uintersect, cette fonction garantit que seuls les éléments avec des clés et des valeurs correspondantes sont retournés. Cela évite les faux positifs lors de la comparaison de tableaux associatifs où les clés ont une signification sémantique.

2. Logique de comparaison personnalisée

Vous pouvez définir des règles d'égalité précises pour les valeurs et les clés, en gérant des types de données complexes ou des exigences de tri personnalisées que les opérateurs natifs ne peuvent pas couvrir.

3. Performances natives

Implémentée en C au cœur de PHP, elle s'exécute efficacement pour les opérations standard sur les tableaux sans dépendances externes, ce qui la rend adaptée aux ensembles de données de taille modérée.

Conseils pour utiliser la fonction array_uintersect_uassoc

Voici quelques conseils pour utiliser la fonction array_uintersect_uassoc dans vos projets PHP :

1. Définir des fonctions de comparaison personnalisées

Pour tirer le meilleur parti de la fonction array_uintersect_uassoc, il est essentiel de définir des fonctions de comparaison personnalisées. Cela vous permettra de personnaliser la logique de comparaison selon les besoins spécifiques de votre projet.

2. Utiliser une comparaison sûre par rapport aux types

Lorsque vous définissez vos fonctions de comparaison personnalisées, il est important d'utiliser des opérateurs de comparaison sûrs par rapport aux types. Cela garantira que la comparaison est effectuée sur les types de données corrects, ce qui améliorera la précision des résultats.

3. Tester vos fonctions de comparaison

Avant d'utiliser vos fonctions de comparaison personnalisées en production, il est important de les tester minutieusement. Cela vous aidera à identifier les éventuels bogues ou problèmes et à vous assurer que votre logique de comparaison fonctionne correctement.

Conclusion

Dans cet article, nous avons exploré la fonction array_uintersect_uassoc en PHP. Cette fonction est un outil puissant pour comparer des tableaux et trouver les valeurs présentes dans tous ceux-ci. En utilisant des fonctions de comparaison personnalisées pour les données et les clés, vous pouvez adapter la logique de comparaison aux besoins spécifiques de votre projet.

Si vous souhaitez faire passer vos compétences PHP au niveau supérieur, maîtriser la fonction array_uintersect_uassoc est un excellent point de départ. Grâce à sa flexibilité et sa polyvalence, cette fonction est un outil indispensable pour tout développeur PHP.

Merci d'avoir lu notre guide sur la fonction array_uintersect_uassoc. Nous espérons que vous l'avez trouvé utile et instructif. Si vous avez des questions ou des commentaires, n'hésitez pas à nous contacter.

Pratique