PHP: Función incorporada para verificar si dos valores de matriz son iguales (Ignorar el orden)

Question

¿Existe una función incorporada para PHP para comprobar si dos matrices contienen los mismos valores (orden no importante?).

Por ejemplo, yo quiero una función que devuelve mí cierto para las dos entradas siguientes:

array('4','5','2') 
array('2','4','5') 

Editar: Podría haber ordenado las dos matrices y compararlas, pero como soy un tipo tan perezoso , Aún preferiría un trazador de líneas que pueda sacar y usar.

Answer 1

array_diff parece una opción:

function array_equal($a1, $a2) { 
    return !array_diff($a1, $a2) && !array_diff($a2, $a1); 
} 

o como un oneliner en el código:

if(!array_diff($a1, $a2) && !array_diff($a2, $a1)) doSomething(); 

Answer 2

La mejor solución es ordenar tanto la matriz y luego compararlas:

$a = array('4','5','2'); 
$b = array('2','4','5'); 
sort($a); 
sort($b); 
var_dump($a === $b); 

En función:

function array_equal($a, $b, $strict=false) { 
    if (count($a) !== count($b)) { 
     return false; 
    } 
    sort($a); 
    sort($b); 
    return ($strict && $a === $b) || $a == $b; 
} 

Aquí hay otro algoritmo de búsqueda de cada elemento de Un si es en B:

function array_equal($a, $b, $strict=false) { 
    if (count($a) !== count($b)) { 
     return false; 
    } 
    foreach ($a as $val) { 
     $key = array_search($val, $b, $strict); 
     if ($key === false) { 
      return false; 
     } 
     unset($b[$key]); 
    } 
    return true; 
} 

Pero eso tiene una complejidad de O (n^2). Entonces es mejor que uses el método de clasificación.

Answer 3

Puede usar array_diff.

$a = array('4','5','2'); 
$b = array('2','4','5'); 

if(count(array_diff($a, $b)) == 0) { 
    // arrays contain the same elements 
} else { 
    // arrays contain different elements 
} 

Sin embargo, un problema con este enfoque es que las matrices pueden contener elementos duplicados y aun así coincidir.

Answer 4

El método array_diff() anterior no funcionará. Manual

de php.net dice que array_diff() hace esto:

"Devuelve una matriz que contiene todas las entradas de matriz1 que no están presentes en ninguna de las otras matrices."

Así que la array_diff() método real sería:

function array_equal($array1, $array2) 
{ 
    $diff1 = array_diff($array1, $array2); 
    $diff2 = array_diff($array2, $array1); 

    return 
    (
     (count($diff1) === 0) && 
     (count($diff2) === 0) 
    ); 
} 

Sin embargo voy con el método para ordenar: D

Answer 5

Puede utilizar array_intersect() en lugar de array_diff():

$a = array('4','5','2'); 
$b = array('2','4','5'); 
$ca = count($a); 
$cb = count($b); 
$array_equal = ($ca == $cb && $ca == count(array_intersect($a, $b))); 

En cuanto al rendimiento. solución, donde dos factores son importantes:

• cuanto más a menudo las matrices coinciden, más array_intersect() es rápido.
• cuantas más matrices son grandes (más de 10 valores), más array_intersect() es más rápido.

Dependiendo de estos factores, un método puede ser dos o tres veces más rápido que el otro. Para arreglos grandes con pocas (o ninguna) combinación de combinaciones, o para arreglos pequeños con muchas coincidencias, ambos métodos son equivalentes.

Sin embargo, el método de ordenación es siempre más rápido, excepto en el caso de arreglos pequeños con pocas o ninguna combinación correspondiente. En este caso, el método array_diff() es un 30% más rápido.

Answer 6

Solo tiene que comparar una vía con array_diff() y usar count() para la relación invertida.

if (count($a1) == count($a2) && !array_diff($a1, $a2)) { 
    // equal arrays 
} 

Answer 7

Si las matrices que se comparan consistir sólo cadenas y/o enteros, array_count_values le permite comparar las matrices rápidamente (en O(n) tiempo vs O(n log n) para la clasificación) verificando que ambas matrices contienen los mismos valores y que cada el valor ocurre el mismo número de veces en ambas matrices.

if(array_count_values($a1) == array_count_values($a2)) { 
    //arrays are equal 
}