PHP-vérifier si deux tableaux sont égaux

Selon cette page .

NOTE: la réponse acceptée fonctionne pour les tableaux associatifs, mais elle ne fonctionnera pas comme prévu avec les tableaux indexés (expliqué ci-dessous). Si vous voulez comparer l'un d'eux, puis d'utiliser cette solution. De plus, Cette fonction peut ne pas fonctionner avec des tableaux multidimensionnels (en raison de la nature de la fonction array_diff).

testant deux tableaux indexés, dont les éléments sont l'ordre différent, en utilisant $a == $b ou $a === $b échoue, par exemple:

<?php
    (array("x","y") == array("y","x")) === false;
?>

c'est parce que ce qui précède signifie:

array(0 => "x", 1 => "y") vs. array(0 => "y", 1 => "x") .

Pour résoudre ce problème, utilisez:

<?php
function array_equal($a, $b) {
    return (
         is_array($a) 
         && is_array($b) 
         && count($a) == count($b) 
         && array_diff($a, $b) === array_diff($b, $a)
    );
}
?>

comparant les tailles des tableaux a été ajouté (suggéré par super_ton) car il peut améliorer la vitesse.

essayez serialize. Cela vérifiera subarrays imbriqués aussi bien.

$foo =serialize($array_foo);
$bar =serialize($array_bar);
if ($foo == $bar) echo "Foo and bar are equal";

!=== ne fonctionnera pas parce que c'est une erreur de syntaxe. La bonne façon est !== (pas trois" égale à "des symboles)

comparez-les avec d'autres valeurs:

if($array_a == $array_b) {
  //they are the same
}

vous pouvez lire à propos de tous les opérateurs array ici: http://php.net/manual/en/language.operators.array.php Notez par exemple que === vérifie également que le type et l'ordre des éléments dans les tableaux sont les mêmes.

Vous pouvez utiliser array_diff_assoc pour vérifier les différences entre les deux.

solution de travail courte qui fonctionne même avec des tableaux dont les clés sont données dans un ordre différent:

public static function arrays_are_equal($array1, $array2)
{
    array_multisort($array1);
    array_multisort($array2);
    return ( serialize($array1) === serialize($array2) );
}

une autre méthode pour vérifier l'égalité indépendamment de l'ordre de valeur fonctionne en utilisant http://php.net/manual/en/function.array-intersect.php , comme ainsi:

$array1 = array(2,5,3);
$array2 = array(5,2,3);
if($array1 === array_intersect($array1, $array2) && $array2 === array_intersect($array2, $array1)) {
    echo 'Equal';
} else {
    echo 'Not equal';
}

Voici une version qui fonctionne aussi avec des tableaux multidimensionnels en utilisant http://php.net/manual/en/function.array-uintersect.php :

$array1 = array(
    array(5, 2),
    array(3, 6),
    array(2, 9, 4)
);
$array2 = array(
    array(3, 6),
    array(2, 9, 4),
    array(5, 2)
);

if($array1 === array_uintersect($array1, $array2, 'compare') && $array2 === array_uintersect($array2, $array1, 'compare')) {
    echo 'Equal';
} else {
    echo 'Not equal';
}

function compare($v1, $v2) {
    if ($v1===$v2) {
        return 0;
    }
    if ($v1 > $v2) return 1;
    return -1;
}

d'Une manière: (mise en œuvre de "égaux" pour http://tools.ietf.org/html/rfc6902#section-4.6 )

permet ainsi des tableaux associatifs dont les membres sont ordonnés différemment-par exemple, ils seraient considérés comme égaux dans toutes les langues sauf le php :)

// recursive ksort
function rksort($a) {
  if (!is_array($a)) {
    return $a;
  }
  foreach (array_keys($a) as $key) {
    $a[$key] = ksort($a[$key]);
  }
  // SORT_STRING seems required, as otherwise
  // numeric indices (e.g. "0") aren't sorted.
  ksort($a, SORT_STRING);
  return $a;
}


// Per http://tools.ietf.org/html/rfc6902#section-4.6
function considered_equal($a1, $a2) {
  return json_encode(rksort($a1)) === json_encode(rksort($a2));
}

array_diff-calcule la différence des tableaux

http://php.net/manual/en/function.array-diff.php

array array_diff ( array $array1 , array $array2 [, array $... ] )

compare array1 avec un ou plusieurs autres tableaux et renvoie les valeurs de array1 qui ne sont présentes dans aucun des autres tableaux.

Utiliser la fonction php array_diff(matrice1, matrice2);

il retournera la différence entre les tableaux. Si son vide, alors ils sont égaux.

exemple:

$array1 = array(
    'a' => 'value1',

    'b' => 'value2',

    'c' => 'value3'
 );

$array2 = array(
    'a' => 'value1',

    'b' => 'value2',

    'c' => 'value4'
 );

$diff = array_diff(array1, array2);

var_dump($diff); 

//it will print array = (0 => ['c'] => 'value4' ) 

exemple 2:

$array1 = array(
    'a' => 'value1',

    'b' => 'value2',

    'c' => 'value3',
 );

$array2 = array(
    'a' => 'value1',

    'b' => 'value2',

    'c' => 'value3',
 );

$diff = array_diff(array1, array2);

var_dump($diff); 

//it will print empty; 

problème de syntaxe sur vos tableaux

$array1 = array(
    'a' => 'value1',
    'b' => 'value2',
    'c' => 'value3',
 );

$array2 = array(
    'a' => 'value1',
    'b' => 'value2',
    'c' => 'value3',
 );

$diff = array_diff($array1, $array2);

var_dump($diff); 

if (array_diff($a,$b) == array_diff($b,$a)) {
  // Equals
}

if (array_diff($a,$b) != array_diff($b,$a)) {
  // Not Equals
}

de mon pov il est préférable d'utiliser array_diff que array_intersect parce qu'avec des vérifications de cette nature les différences retournées sont généralement moins que les similitudes, de cette façon la conversion de bool est moins avide de mémoire.

Edit notez que cette solution est pour les tableaux simples et complète le == et = = = = un affiché ci-dessus qui n'est valide que pour les dictionnaires.