PHP: comprueba si dos matrices son iguales

Me gustaría comprobar si dos matrices son iguales. Quiero decir: mismo tamaño, mismo índice, mismos valores. ¿Cómo puedo hacer eso?

Utilizando !==según lo sugerido por un usuario, espero que lo siguiente imprima enter si al menos un elemento en la matriz (s) es diferente, pero de hecho no lo hace.

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.

Ver Operadores de matrices .

EDITAR

El operador de desigualdad es !=mientras que el operador de no identidad !==debe coincidir con el operador de igualdad ==y el operador de identidad ===.

De acuerdo a esta página .

NOTA: La respuesta aceptada funciona para matrices asociativas, pero no funcionará como se esperaba con las matrices indexadas (explicadas a continuación). Si desea comparar cualquiera de ellos, use esta solución. Además, esta función puede no funcionar con matrices multidimensionales (debido a la naturaleza de la función array_diff).

Probar dos matrices indexadas, qué elementos están en diferente orden, usando $a == $bo $a === $bfallando, por ejemplo:

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

Eso es porque lo anterior significa:

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

Para resolver ese problema, use:

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

Se agregó la comparación de tamaños de matriz (sugerida por super_ton) ya que puede mejorar la velocidad.

Intenta serializar. Esto verificará también las submatrices anidadas.

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

Solución corta que funciona incluso con matrices cuyas claves se dan en diferente orden:

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

Compárelos como otros valores:

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

Puede leer sobre todos los operadores de matriz aquí: http://php.net/manual/en/language.operators.array.php Tenga en cuenta, por ejemplo, que ===también comprueba que los tipos y el orden de los elementos en las matrices son los mismos.

!===no funcionará porque es un error de sintaxis. La forma correcta es !==(no tres símbolos "iguales a")

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

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

Desde mi punto de vista, es mejor usar array_diff que array_intersect porque con las comprobaciones de esta naturaleza, las diferencias devueltas suelen ser menores que las similitudes, de esta manera la conversión de bool consume menos memoria.

Editar Tenga en cuenta que esta solución es para matrices simples y complementa la == y === una publicada anteriormente que solo es válida para los diccionarios.

array_diff - Calcula la diferencia de matrices

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

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

Se compara array1con una o más matrices y devuelve los valores array1que no están presentes en ninguna de las otras matrices.

Otro método para verificar la igualdad independientemente del orden de valor funciona mediante el uso de http://php.net/manual/en/function.array-intersect.php , de esta manera:

$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';
}

Aquí hay una versión que también funciona con matrices multidimensionales usando 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)==[];

}

Una forma: (implementando 'considerado igual' para http://tools.ietf.org/html/rfc6902#section-4.6 )

De esta forma, se permiten matrices asociativas cuyos miembros están ordenados de manera diferente, por ejemplo, se considerarían iguales en todos los idiomas excepto 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));
}

Problema de sintaxis en sus matrices

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

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

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

var_dump($diff); 

Aquí está el ejemplo de cómo comparar las matrices y obtener lo que es diferente entre ellas.

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

Resultado:

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

        )

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

Utilice la función php array_diff (array1, array2);

Devolverá la diferencia entre las matrices. Si está vacío, entonces son iguales.

ejemplo:

$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' ) 

Ejemplo 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 desea verificar matrices no asociativas, esta es la solución:

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

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