PHP - Überprüfen Sie, ob zwei Arrays gleich sind

Ich möchte überprüfen, ob zwei Arrays gleich sind. Ich meine: gleiche Größe, gleicher Index, gleiche Werte. Wie kann ich das machen?

!==Ich gehe davon aus, dass bei Verwendung der von einem Benutzer vorgeschlagenen Verwendung die Eingabetaste gedruckt wird , wenn mindestens ein Element in den Arrays unterschiedlich ist, dies jedoch nicht der Fall ist.

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.

Siehe Array-Operatoren .

BEARBEITEN

Der Ungleichungsoperator ist, !=während der Nichtidentitätsoperator !==mit dem Gleichheitsoperator ==und dem Identitätsoperator übereinstimmen soll ===.

Nach dieser Seite .

HINWEIS: Die akzeptierte Antwort funktioniert für assoziative Arrays, funktioniert jedoch nicht wie erwartet mit indizierten Arrays (siehe unten). Wenn Sie einen von beiden vergleichen möchten, verwenden Sie diese Lösung. Diese Funktion funktioniert möglicherweise auch nicht mit mehrdimensionalen Arrays (aufgrund der Art der Funktion array_diff).

Testen von zwei indizierten Arrays, deren Elemente sich in unterschiedlicher Reihenfolge befinden, mit $a == $boder ohne $a === $bFehler, zum Beispiel:

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

Das liegt daran, dass das oben Genannte bedeutet:

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

Verwenden Sie zur Lösung dieses Problems:

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

Der Vergleich der Arraygrößen wurde hinzugefügt (von super_ton vorgeschlagen), da dies die Geschwindigkeit verbessern kann.

Versuchen Sie, zu serialisieren. Dadurch werden auch verschachtelte Subarrays überprüft.

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

Kurze Lösung, die auch mit Arrays funktioniert, deren Schlüssel in unterschiedlicher Reihenfolge angegeben werden:

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

Vergleichen Sie sie als andere Werte:

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

Informationen zu allen Array-Operatoren finden Sie hier: http://php.net/manual/en/language.operators.array.php Beachten Sie beispielsweise, dass ===auch die Typen und die Reihenfolge der Elemente in den Arrays identisch sind.

!===funktioniert nicht, da es sich um einen Syntaxfehler handelt. Der richtige Weg ist !==(nicht drei "gleich" Symbole)

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

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

Aus meiner Sicht ist es besser, array_diff als array_intersect zu verwenden, da bei Überprüfungen dieser Art die üblicherweise zurückgegebenen Unterschiede geringer sind als die Ähnlichkeiten. Auf diese Weise ist die Bool-Konvertierung weniger speicherhungrig.

Bearbeiten Beachten Sie, dass diese Lösung für einfache Arrays gilt und die oben angegebenen == und === ergänzt, die nur für Wörterbücher gültig sind.

Eine andere Methode zum Überprüfen der Gleichheit unabhängig von der Wertreihenfolge funktioniert mithilfe von http://php.net/manual/en/function.array-intersect.php wie folgt:

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

Hier ist eine Version, die auch mit mehrdimensionalen Arrays unter Verwendung von http://php.net/manual/en/function.array-uintersect.php funktioniert :

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

array_diff - Berechnet die Differenz der Arrays

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

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

Vergleicht array1mit einem oder mehreren anderen Arrays und gibt die Werte zurück array1, die in keinem der anderen Arrays vorhanden sind.

function compareIsEqualArray(array $array1,array $array):bool
{

   return array_diff($array1,$array2)==[];

}

Ein Weg: (Implementierung von 'als gleich angesehen' für http://tools.ietf.org/html/rfc6902#section-4.6 )

Auf diese Weise können assoziative Arrays, deren Mitglieder unterschiedlich geordnet sind, z. B. in jeder Sprache außer PHP als gleich angesehen werden :)

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

Syntaxproblem auf Ihren Arrays

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

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

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

var_dump($diff); 

Hier ist das Beispiel, wie Sie mit Arrays vergleichen und herausfinden, was zwischen ihnen unterschiedlich ist.

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

Ergebnis:

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

        )

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

Verwenden Sie die PHP-Funktion array_diff (array1, array2).

Es wird der Unterschied zwischen Arrays zurückgegeben. Wenn es leer ist, sind sie gleich.

Beispiel:

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

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

Wenn Sie nicht assoziative Arrays überprüfen möchten, finden Sie hier die Lösung:

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

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