<?php
highlight_file(__FILE__);
echo '<hr/><pre>';
$array1 = array("a" => "green", "x"=>"red", "blue", "yellow", "v"=>"brown", "t"=>"purple", "orange");
$array2 = array("b" => "green", "c"=>"yellow", "red", "X"=>"BLUE", "z"=>"a", "gray","v"=>"brown", "T"=>"purple");

print_r($array1);
print_r($array2);
echo '-----' . "\n"; 
echo 'array_intersect' . "\n"; 
print_r(array_intersect($array1, $array2)); 
// quelles valeurs  (et leurs clé dans array1) sont dans les 2 tableaux ?

echo '-----' . "\n"; 
echo 'array_intersect_assoc' . "\n"; 
print_r(array_intersect_assoc($array1, $array2)); 
// quels couples clé-valeurs sont dans les 2 tableaux ?

echo '-----' . "\n"; 
echo 'array_intersect_key' . "\n"; 
print_r(array_intersect_key($array1, $array2));
// quelles clés (et leurs valeurs dans array1) 
// notez que bleu qui avait automatiquement reçu la clé 0
// et yellow la clé 1 sont repris car red avait cette clé 0 et gray la 1 dans array2, 
// par contre orange n'est pas repris

echo '-----' . "\n"; 
echo 'array_uintersect' . "\n"; 
$array2['T']='purple';
print_r(array_uintersect($array1, $array2, "strcasecmp"));
// ici on va donc comparer les valeurs de array 1 et 2 
// si strcasecmp retourne vrai on reprend la valeur et sa clé dans array 1

echo '-----' . "\n"; 
echo 'array_intersect_uassoc' . "\n"; 
print_r(array_intersect_uassoc($array1, $array2, "strcasecmp"));
// C'est comme array_intersect_assoc 
// mais on donne la fonction qui décide si les clés et les valeurs sont "les mêmes" 
// ici strcasecmp rends la comparaison insensible Ã  la casse, du coup t = T et purple s'ajoute au brown

echo '-----' . "\n"; 
echo 'array_intersect_ukey' . "\n"; 
$array2['T']='gold';
print_r(array_intersect_ukey($array1, $array2, 'strcasecmp'));
echo ' - - - - -' . "\n"; 
$array1['T']='black';
print_r(array_intersect_ukey($array1, $array2, 'strcasecmp'));
echo ' - - - - -' . "\n"; 
print_r(array_intersect_ukey($array1, $array2, 'key_compare_func'));
// C'est comme array_intersect_key 
// on ne regarde que les clés mais on donne la fonction qui traite la comparaison
// ici strcasecmp rends la comparaison insensible Ã  la casse, 
// du cup t =T et  purple s'ajoute au brown alors que la valeur associée au t avait Ã©té changée.
// Notez que si on ajoute Ã  array1 une valeur pour T (alors que t existe toujours, c'est purple qui sera retourné et non black
// pour le troisieme exemple on prend une fonction maison qui compare

echo '-----' . "\n"; 
$array1['t']='PuRple';
$array2['T']='purple';
$array1['x']='silver';
$array2['x']='SilVer';
$array1['y']='yyyy';
$array2['Y']='YYYY';
$array1['G']='G';
$array2['g']='g';
$array1['h']='h';
$array2['h']='h';
$array1['J']='J';
$array2['J']='J';

echo 'array_uintersect_assoc' . "\n"; 
// La doc n'est pas claire car les 2 fonctions on la même description
print_r(array_uintersect_assoc($array1, $array2, "strcasecmp")); //Calcule l'intersection de deux tableaux avec des tests sur les index, compare les index en utilisant une fonction de rappel
print_r(array_intersect_uassoc($array1, $array2, "strcasecmp")); //Calcule l'intersection de deux tableaux avec des tests sur les index, compare les index en utilisant une fonction de rappel
// et pourtant les résultats differrent.puis que la première accepte x=>silver 
// je ne suis pas sur de moi mais je dirait que pour la première strcasecmp s'applique au clé et au valeurs contrairement Ã  ce que dit la doc.

 
echo '-----' . "\n"; 
echo 'array_uintersect_uassoc' . "\n"; 
print_r(array_uintersect_uassoc($array1, $array2, "strcasecmp", "strcasecmp"));
// Dans ce cas on peut choisir une fonction utilisateur pour les clés et une pour les valeurs

function key_compare_func($key1, $key2)
{
    if ($key1 == $key2)
        return 0;
    else if ($key1 > $key2)
        return 1;
    else
        return -1;
}



?>

 
Array
(
    [a] => green
    [x] => red
    [0] => blue
    [1] => yellow
    [v] => brown
    [t] => purple
    [2] => orange
)
Array
(
    [b] => green
    [c] => yellow
    [0] => red
    [X] => BLUE
    [z] => a
    [1] => gray
    [v] => brown
    [T] => purple
)
-----
array_intersect
Array
(
    [a] => green
    [x] => red
    [1] => yellow
    [v] => brown
    [t] => purple
)
-----
array_intersect_assoc
Array
(
    [v] => brown
)
-----
array_intersect_key
Array
(
    [0] => blue
    [1] => yellow
    [v] => brown
)
-----
array_uintersect
Array
(
    [a] => green
    [x] => red
    [0] => blue
    [1] => yellow
    [v] => brown
    [t] => purple
)
-----
array_intersect_uassoc
Array
(
    [v] => brown
    [t] => purple
)
-----
array_intersect_ukey
Array
(
    [x] => red
    [0] => blue
    [1] => yellow
    [v] => brown
    [t] => purple
)
 - - - - -
Array
(
    [x] => red
    [0] => blue
    [1] => yellow
    [v] => brown
    [t] => purple
)
 - - - - -
Array
(
    [a] => green
    [0] => blue
    [1] => yellow
    [v] => brown
)
-----
array_uintersect_assoc
Array
(
    [x] => silver
    [v] => brown
    [h] => h
    [J] => J
)
Array
(
    [v] => brown
    [h] => h
    [J] => J
)
-----
array_uintersect_uassoc
Array
(
    [v] => brown
    [t] => PuRple
    [y] => yyyy
    [G] => G
    [h] => h
    [J] => J
)
Je m'arrète là je continuerais à propos des itérateurs dans un autre posts. Et pour ces fonctions je vais donc creuser pour cette array_uintersect_assoc() que je n'ai pas correctement cerné.