PHP: controlla se due array sono uguali

Vorrei verificare se due array sono uguali. Voglio dire: stessa dimensione, stesso indice, stessi valori. Come lo posso fare?

Utilizzando !==come suggerito da un utente, mi aspetto che il seguente sarebbe stampare entrare se almeno un elemento della matrice (s) sono diversi, ma in realtà non è così.

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.

Vedi Operatori di array .

MODIFICARE

L'operatore di disuguaglianza è !=mentre l' operatore di non identità deve !==abbinare l'operatore di uguaglianza ==e l'operatore di identità ===.

Secondo questa pagina .

NOTA: la risposta accettata funziona per gli array associativi, ma non funzionerà come previsto con gli array indicizzati (spiegato di seguito). Se si desidera confrontare uno di essi, utilizzare questa soluzione. Inoltre, questa funzione potrebbe non funzionare con array multidimensionali (a causa della natura della funzione array_diff).

Test di due array indicizzati, quali elementi sono in ordine diverso, utilizzando $a == $bo $a === $bnon riescono, ad esempio:

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

Questo perché quanto sopra significa:

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

Per risolvere il problema, utilizzare:

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

È stato aggiunto il confronto delle dimensioni degli array (suggerito da super_ton) in quanto potrebbe migliorare la velocità.

Prova a serializzare. Questo controllerà anche i subarray nidificati.

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

Soluzione breve che funziona anche con le matrici quali chiavi sono fornite in ordine diverso:

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

Confrontali come altri valori:

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

Puoi leggere tutti gli operatori di array qui: http://php.net/manual/en/language.operators.array.php Nota ad esempio che ===controlla anche che i tipi e l'ordine degli elementi negli array siano gli stessi.

!===non funzionerà perché è un errore di sintassi. Il modo corretto è !==(non tre simboli "uguali a")

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

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

Dal mio punto di vista è meglio usare array_diff che array_intersect perché con i controlli di questa natura le differenze restituite comunemente sono inferiori alle somiglianze, in questo modo la conversione bool ha meno fame di memoria.

Modifica Si noti che questa soluzione è per array semplici e integra quella == e === pubblicata sopra che è valida solo per i dizionari.

array_diff - Calcola la differenza di array

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

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

Confronta array1con uno o più altri array e restituisce i valori array1che non sono presenti in nessuno degli altri array.

Un altro metodo per controllare l'uguaglianza indipendentemente dall'ordine dei valori funziona usando http://php.net/manual/en/function.array-intersect.php , in questo modo:

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

Ecco una versione che funziona anche con array multidimensionali 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)==[];

}

Un modo: (implementando "considerato uguale" per http://tools.ietf.org/html/rfc6902#section-4.6 )

In questo modo consente matrici associative i cui membri sono ordinati in modo diverso - ad esempio, sarebbero considerati uguali in tutte le lingue ma 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 di sintassi sugli array

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

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

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

var_dump($diff); 

Ecco l'esempio di come confrontare gli array e ottenere ciò che è diverso tra loro.

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

Risultato:

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

        )

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

Usa la funzione php array_diff (array1, array2);

Restituirà la differenza tra le matrici. Se è vuoto, sono uguali.

esempio:

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

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

Se vuoi controllare array non associativi, ecco la soluzione:

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

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