Compruebe si dos matrices tienen los mismos valores (independientemente del orden de los valores) [duplicate]

[2,5,3]    

[5,2,3]

Son iguales porque tienen los mismos valores, pero no en el mismo orden.

¿Puedo averiguarlo sin usar un foreach() bucle con in_array()? No creo que sea eficiente.

sort($a);
sort($b);
if ($a===$b) {//equal}

Llegar tarde a esta fiesta. Tenía la misma pregunta pero no quería ordenar, que era la respuesta inmediata que sabía que funcionaría. Se me ocurrió este simple de una sola línea que solo funciona para matrices de valores únicos:

$same = ( count( $a ) == count( $b ) && !array_diff( $a, $b ) )

También se trata de un factor de 5 más rápido que la opción de clasificación. No es que ninguno de los dos sea especialmente lento, así que diría que se trata más de tus preferencias personales y cuál crees que es más claro. Personalmente prefiero no ordenar.

Editar: Gracias Ray por señalar el hecho de que esto solo funciona con matrices con valores únicos.

Esto es un poco tarde para la fiesta, pero espero que sea útil:

Si está seguro de que las matrices solo contienen cadenas o que solo contienen números enteros, entonces array_count_values($a) == array_count_values($b) tiene mejor complejidad temporal. Sin embargo, la respuesta del usuario 1844933 es más general.

Si no desea ordenar matrices pero solo desea verificar la igualdad independientemente del orden de valor, use http://php.net/manual/en/function.array-intersect.php al igual que:

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

La mejor manera será usando array_diff http://php.net/manual/en/function.array-diff.php

$arr1 = [2,5,3];
$arr2 = [5,2,3];

$isEqual = array_diff($arr1,$arr2) === array_diff($arr2,$arr1);

Como ninguna de las respuestas dadas que son completamente independientes de la clave funcionan con valores duplicados (como [1,1,2] es igual [1,2,2]) He escrito el mío.

Esta variante no funciona con matrices multidimensionales. Comprueba si dos matrices contienen exactamente los mismos valores, independientemente de sus claves y orden, sin modificar ninguno de los argumentos.

function array_equals(array $either, array $other) : bool {
    foreach ($other as $element) {
        $key = array_search($element, $either, true);
        if ($key === false) {
            return false;
        }
        unset($either[$key]);
    }
    return empty($either);
}

Aunque la pregunta se refería a una variante sin foreach, no pude encontrar ninguna solución que satisficiera mis requisitos sin un bucle. Además, la mayoría de las funciones que se usan de otro modo también usan un bucle internamente.

porque no modifica $either? Debido a que los valores en PHP son de copia en escritura, entonces siempre y cuando esta sea su propia función y no el código en línea, la matriz se copia una vez que el $either el argumento se modifica por primera vez.

Si desea alinear este código, haga esto antes:

$either = $myarray;
// inline code from function above

Digamos, si tiene dos matrices definidas así:

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

Luego puede usar este fragmento de código para juzgar si son iguales:

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