PHP: Funzione integrata per verificare se due valori di matrice sono uguali (Ignorare l'ordine)

Question

Esiste una funzione integrata per PHP che consente di verificare se due array contengono gli stessi valori (ordine non importante?).

Ad esempio, voglio una funzione che restituisce mi vero per i due ingressi:

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

Edit: avrei potuto ordinato due array e confrontarli, ma come io sono un ragazzo pigro , Preferirei comunque un one-liner che posso estrarre e utilizzare.

Answer 1

array_diff si presenta come un'opzione:

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

o come oneliner nel codice:

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

Answer 2

La soluzione migliore è di ordinare sia matrice e poi confrontarli:

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

In funzione:

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

Ecco un altro algoritmo ricerca di ogni elemento di A se è in 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; 
} 

Ma questo ha una complessità di O (n^2). Quindi è meglio usare il metodo di smistamento.

Answer 3

È possibile utilizzare 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 
} 

Tuttavia, un problema con questo approccio è che gli array possono contenere elementi duplicati e corrispondono ancora.

Answer 4

Il metodo array_diff() di cui sopra non funzionerà. manuale

di php.net dice che array_diff() fa questo:

"restituisce un array contenente tutte le voci di array1 che non sono presenti in nessuna delle altre matrici."

Così il metodo effettivo array_diff() sarebbe:

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

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

Comunque vado con l'ordine: D

Answer 5

È possibile utilizzare array_intersect() invece di 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))); 

prestazioni saggio. soluzione, dove due fattori sono importanti:

• più spesso array sono corrispondenti, più array_intersect() è veloce.
• più array sono grandi (più di 10 valori), più array_intersect() è veloce.

In base a questi fattori, un metodo può essere due o tre volte più veloce dell'altro. Per i grandi array con poche (o nessuna) combinazioni di corrispondenza, o per piccoli array con un sacco di corrispondenza, entrambi i metodi sono equivalenti.

Tuttavia, il metodo di ordinamento è sempre più veloce, tranne nel caso di piccoli array con poche o nessuna combinazione di corrispondenza. In questo caso il metodo array_diff() è più veloce del 30%.

Answer 6

È necessario solo confrontare a senso unico utilizzando array_diff() e utilizzare count() per la relazione invertita.

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

Answer 7

Se gli array a confronto consistere solo stringhe e/o interi, array_count_values ti permette di confrontare le matrici rapidamente (in O(n) tempo vs O(n log n) per l'ordinamento) verificando che entrambi gli array contengono gli stessi valori e che ogni il valore si verifica lo stesso numero di volte in entrambi gli array.

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