PHP - Vérifiez si deux tableaux sont égaux

Je voudrais vérifier si deux tableaux sont égaux. Je veux dire: même taille, même indice, mêmes valeurs. Comment puis je faire ça?

En utilisant !==comme suggéré par un utilisateur, je m'attends à ce que ce qui suit imprime enter si au moins un élément du ou des tableaux est différent, mais en fait ce n'est pas le cas.

if (($_POST['atlOriginal'] !== $oldAtlPosition) 
    or ($_POST['atl'] !== $aext) 
    or ($_POST['sidesOriginal'] !== $oldSidePosition) 
    or ($_POST['sidesOriginal'] !== $sideext)) {

    echo "enter";
}

$arraysAreEqual = ($a == $b); // TRUE if $a and $b have the same key/value pairs.
$arraysAreEqual = ($a === $b); // TRUE if $a and $b have the same key/value pairs in the same order and of the same types.

Voir Opérateurs de baies .

ÉDITER

L'opérateur d'inégalité est !=alors que l' opérateur de non-identité !==doit correspondre à l'opérateur d'égalité ==et à l'opérateur d'identité ===.

Selon cette page .

REMARQUE: la réponse acceptée fonctionne pour les tableaux associatifs, mais elle ne fonctionnera pas comme prévu avec les tableaux indexés (expliqués ci-dessous). Si vous souhaitez comparer l'un ou l'autre, utilisez cette solution. En outre, cette fonction peut ne pas fonctionner avec les tableaux multidimensionnels (en raison de la nature de la fonction array_diff).

Test de deux tableaux indexés, dont les éléments sont dans un ordre différent, en utilisant $a == $bou $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")par rapport à 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)
    );
}
?>

La comparaison des tailles de tableau a été ajoutée (suggérée par super_ton) car elle peut améliorer la vitesse.

Essayez de sérialiser. Cela vérifiera également les sous-réseaux imbriqués.

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

Solution 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) );
}

Comparez-les avec d'autres valeurs:

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

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

!===ne fonctionnera pas car il s'agit d'une erreur de syntaxe. La bonne façon est !==(pas trois symboles "égaux à")

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

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

De mon point de vue, il est préférable d'utiliser array_diff que array_intersect car avec des vérifications de cette nature, les différences retournées sont généralement inférieures aux similitudes, de cette façon la conversion booléenne est moins gourmande en mémoire.

Modifier Notez que cette solution est pour les tableaux simples et complète celle == et === publiée ci-dessus qui n'est valable que pour les dictionnaires.

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 array1avec un ou plusieurs autres tableaux et renvoie les valeurs array1qui ne sont présentes dans aucun des autres tableaux.

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

$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 également avec des tableaux multidimensionnels 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;
}

function compareIsEqualArray(array $array1,array $array):bool
{

   return array_diff($array1,$array2)==[];

}

Une façon: (implémenter «considéré comme égal» pour http://tools.ietf.org/html/rfc6902#section-4.6 )

De cette façon, les tableaux associatifs dont les membres sont classés différemment - par exemple, ils seraient considérés comme égaux dans toutes les langues, mais 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));
}

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); 

Voici l'exemple comment comparer aux tableaux et obtenir ce qui est différent entre eux.

$array1 = ['1' => 'XXX', 'second' => [
            'a' => ['test' => '2'],
            'b' => 'test'
        ], 'b' => ['no test']];

        $array2 = [
            '1' => 'XX',
            'second' => [
                'a' => ['test' => '5', 'z' => 5],
                'b' => 'test'
            ],
            'test'
        ];


        function compareArrayValues($arrayOne, $arrayTwo, &$diff = [], $reversed = false)
        {
            foreach ($arrayOne as $key => $val) {
                if (!isset($arrayTwo[$key])) {
                    $diff[$key] = 'MISSING IN ' . ($reversed ? 'FIRST' : 'SECOND');
                } else if (is_array($val) && (json_encode($arrayOne[$key]) !== json_encode($arrayTwo[$key]))) {
                    compareArrayValues($arrayOne[$key], $arrayTwo[$key], $diff[$key], $reversed);
                } else if ($arrayOne[$key] !== $arrayTwo[$key]) {
                    $diff[$key] = 'DIFFERENT';
                }
            }
        }

        $diff = [];
        $diffSecond = [];

        compareArrayValues($array1, $array2, $diff);
        compareArrayValues($array2, $array1, $diffSecond, true);

        print_r($diff);
        print_r($diffSecond);

        print_r(array_merge($diff, $diffSecond));

Résultat:

Array
(
    [0] => DIFFERENT
    [second] => Array
        (
            [a] => Array
                (
                    [test] => DIFFERENT
                    [z] => MISSING IN FIRST
                )

        )

    [b] => MISSING IN SECOND
    [1] => DIFFERENT
    [2] => MISSING IN FIRST
)

Utilisez la fonction php array_diff (array1, array2);

Il retournera la différence entre les tableaux. Si c'est vide, 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; 

Si vous souhaitez vérifier les tableaux non associatifs, voici la solution:

$a = ['blog', 'company'];
$b = ['company', 'blog'];

(count(array_unique(array_merge($a, $b))) === count($a)) ? 'Equals' : 'Not Equals';
// Equals