PHP vergleichen Array

Ist es sowieso zum vergleichen von arrays in php mit Hilfe einer eingebauten Funktion, kurz tun, irgendeine Art von Schleife?

$a1 = array(1,2,3);
$a2 = array(1,2,3);

if (array_are_same($a1, $a2)) {
    //code here
}

Btw, die array-Werte nicht immer in der gleichen Reihenfolge.

InformationsquelleAutor der Frage | 2009-05-23

  1. 36
    if ( $a == $b ) {
    echo 'We are the same!'
}

    InformationsquelleAutor der Antwort Alan Haggai Alavi

  2. 26

    Vergleich von zwei arrays haben die gleichen Werte (dupliziert oder nicht, Art-jonglieren berücksichtigt) kann erfolgen, indem array_diff() in beide Richtungen:

    !array_diff($a, $b) && !array_diff($b, $a);

    Diese gibt TRUE wenn die beiden arrays die gleichen Werte haben (nach der type-juggling). FALSE sonst. Beispiele:

    function array_equal_values(array $a, array $b) {
    return !array_diff($a, $b) && !array_diff($b, $a);
}

array_equal_values([1], []);            # FALSE
array_equal_values([], [1]);            # FALSE
array_equal_values(['1'], [1]);         # TRUE
array_equal_values(['1'], [1, 1, '1']); # TRUE

    Wie dieses Beispiel zeigt, array_diff Blätter array Schlüssel aus der Gleichung heraus und kümmert sich nicht um die Reihenfolge der Werte entweder und weder über wenn Werte vorhanden sind oder nicht.

    Soweit die Vervielfältigung hat, einen Unterschied zu machen, wird dies immer schwieriger. Soweit die "einfache" Werte betroffen sind (nur string-und integer-Werte), array_count_values() ins Spiel kommt, um die Informationen zu sammeln über welcher Wert gibt an, wie oft innerhalb eines Arrays. Diese Informationen können leicht verglichen werden mit ==:

    array_count_values($a) == array_count_values($b);

    Diese gibt TRUE wenn die beiden arrays die gleichen Werte haben (nach der type-juggling) für die gleiche Menge an Zeit. FALSE sonst. Beispiele:

    function array_equal_values(array $a, array $b) {
    return array_count_values($a) == array_count_values($b);
}

array_equal_values([2, 1], [1, 2]);           # TRUE
array_equal_values([2, 1, 2], [1, 2, 2]);     # TRUE
array_equal_values(['2', '2'], [2, '2.0']);   # FALSE
array_equal_values(['2.0', '2'], [2, '2.0']); # TRUE

    Dies kann weiter optimiert werden durch den Vergleich der Anzahl der zwei arrays, die erste, die ist relativ Billig und einen schnellen test, um zu sagen, dass die meisten arrays auseinander, wenn Zählwert Vervielfältigung einen Unterschied macht.

    Diese Beispiele sind bisher zum Teil nur string-und integer-Werte und keine strengen Vergleich ist möglich mit array_diff. Mehr speziell für die strengen Vergleich ist array_search. So Werte müssen gezählt werden und indiziert, so dass Sie verglichen werden kann, als nur drehen Sie Sie in eine Taste (wie array_search tut) wird es nicht.

    Dies ist ein bisschen mehr Arbeit. Doch am Ende der Vergleich ist der gleiche wie früher:

    $count($a) == $count($b);

    Es ist nur $count macht den Unterschied:

        $table = [];
    $count = function (array $array) use (&$table) {
        $exit   = (bool)$table;
        $result = [];
        foreach ($array as $value) {
            $key = array_search($value, $table, true);

            if (FALSE !== $key) {
                if (!isset($result[$key])) {
                    $result[$key] = 1;
                } else {
                    $result[$key]++;
                }
                continue;
            }

            if ($exit) {
                break;
            }

            $key          = count($table);
            $table[$key]  = $value;
            $result[$key] = 1;
        }

        return $result;
    };

    Dieser beinhaltet eine Tabelle von Werten, so dass beide arrays denselben index verwenden. Auch ist es möglich zu verlassen früh das erste mal in der zweiten Reihe einen neuen Wert erlebt wird.

    Diese Funktion kann auch hinzufügen, die strengen Kontext durch einen zusätzlichen parameter. Und durch das hinzufügen eines weiteren zusätzliche parameter würde dann zulassen, um suchen nach Duplikaten oder nicht. Das vollständige Beispiel:

    function array_equal_values(array $a, array $b, $strict = FALSE, $allow_duplicate_values = TRUE) {

    $add = (int)!$allow_duplicate_values;

    if ($add and count($a) !== count($b)) {
        return FALSE;
    }

    $table = [];
    $count = function (array $array) use (&$table, $add, $strict) {
        $exit   = (bool)$table;
        $result = [];
        foreach ($array as $value) {
            $key = array_search($value, $table, $strict);

            if (FALSE !== $key) {
                if (!isset($result[$key])) {
                    $result[$key] = 1;
                } else {
                    $result[$key] += $add;
                }
                continue;
            }

            if ($exit) {
                break;
            }

            $key          = count($table);
            $table[$key]  = $value;
            $result[$key] = 1;
        }

        return $result;
    };

    return $count($a) == $count($b);
}

    Beispiele:

    array_equal_values(['2.0', '2', 2], ['2', '2.0', 2], TRUE);           # TRUE
array_equal_values(['2.0', '2', 2, 2], ['2', '2.0', 2], TRUE);        # TRUE
array_equal_values(['2.0', '2', 2, 2], ['2', '2.0', 2], TRUE, FALSE); # FALSE
array_equal_values(['2'], ['2'], TRUE, FALSE);                        # TRUE
array_equal_values([2], ['2', 2]);                                    # TRUE
array_equal_values([2], ['2', 2], FALSE);                             # TRUE
array_equal_values([2], ['2', 2], FALSE, TRUE);                       # FALSE

    InformationsquelleAutor der Antwort hakre

  3. 12

    @Cleanshooter tut mir Leid, aber diese macht nicht, was es wird erwartet todo: (also tut array_diff in diesem Zusammenhang erwähnt)

    $a1 = array('one','two');
$a2 = array('one','two','three');

var_dump(count(array_diff($a1, $a2)) === 0); //returns TRUE

    (Anmerkung: Sie können nicht mit leeren Funktionen vor PHP 5.5)
    in diesem Fall ist das Ergebnis true, obwohl die arrays sind unterschiedlich.

    array_diff [...] Gibt ein array mit allen Einträgen von array1 zurück, die nicht vorhanden sind, sind in keinem der anderen arrays.

    was nicht bedeutet, dass array_diff ist so etwas wie: array_get_all_differences. Erklärt in der mathematischen Sätze es berechnet:

    {'one','two'} \ {'one','two','three'} = {}

    was so viel bedeutet wie alle Elemente aus dem ersten Satz, ohne alle Elemente vom zweiten Satz, die in den ersten Satz.
    So, dass

    var_dump(array_diff($a2, $a1));

    berechnet, um

    array(1) { [2]=> string(5) "three" }

    Die Schlussfolgerung ist, dass Sie zu tun, eine array_diff in "beide Richtungen" alle "Unterschiede" der beiden arrays.

    hoffe, das hilft 🙂

    InformationsquelleAutor der Antwort P.Scheit

  4. 4

    Sie können auch versuchen, auf diese Weise:

    if(serialize($a1) == serialize($a2))

    InformationsquelleAutor der Antwort Murz

  5. 3

    Nur überprüfen $a1 == $a2 -- was ist falsch mit, dass?

    InformationsquelleAutor der Antwort Alex Martelli

  6. 3

    array_intersect() gibt ein array mit allen die gemeinsamen Werte.

    InformationsquelleAutor der Antwort moonw

  7. 1

    Eine schnelle Methode für den Vergleich von array-Werte kann in beliebiger Reihenfolge sein...

    function arrays_are_same($array1, $array2) {
    sort($array1);
    sort($array2);
    return $array1==$array2;
}

    So...

        $array1 = array('audio', 'video', 'image');
    $array2 = array('video', 'image', 'audio');

    arrays_are_same($array1, $array2) zurück TRUE

    InformationsquelleAutor der Antwort chichilatte

  8. 1

    Schlussfolgerung aus dem Kommentar hier:

    Vergleich der array-Werte gleich sind (nach der type juggling) und in der gleichen Reihenfolge nur:

    array_values($a1) == array_values($a2)

    Vergleich der array-Werte gleich sind (nach der type juggling) und in der gleichen Reihenfolge und array-keys sind die gleichen und in der gleichen Reihenfolge:

    array_values($a1) == array_values($a2) && array_keys($a1) == array_keys($a2)

    InformationsquelleAutor der Antwort Tyron

  9. 1

    das array aus Benutzer oder Eingabe der array-Werte.Verwenden Sie Sortieren die Funktion Sortieren die beiden arrays. prüfen Sie mit einem ternären operator. Wenn die beiden arrays gleich sind, gibt es arrays gleich sind, sonst wird es print-arrays nicht gleich sind. es gibt keine loop-iteration hier.

    sort($a1);
sort($a2);
echo (($a1==$a2) ? "arrays are equal" : "arrays are not equal");

    InformationsquelleAutor der Antwort CJ Ramki

  10. 0

    stellen Sie sicher, dass die Kreuzungen zu zählen ist das gleiche wie die beiden Quell-arrays

    $intersections = array_intersect($a1, $a2);
$equality = (count($a1) == count($a2)) && (count($a2) == count($intersections)) ? true : false;

    InformationsquelleAutor der Antwort rcourtna

  11. 0

    Vergleichen die Werte von zwei arrays:

    $a = array(1,2,3);
$b = array(1,3,2);

if (array_diff($a, $b) || array_diff($b, $a)) {
    echo 'Not equal';
}else{
    echo 'Equal';
}

    InformationsquelleAutor der Antwort 1Rhino

  12. 0

    Wenn Sie nicht kümmern über Schlüssel und, dass gerade die Werte, dann ist das die beste Methode, um Werte zu vergleichen und stellen Sie sicher, dass die Duplikate gezählt werden.

    $mag = '{"1":"1","2":"2","3":"3","4":"3"}';
$mag_evo = '1|2|3';

$test1 = array_values(json_decode($mag, true));
$test2 = array_values(explode('|', $mag_evo));

if($test1 == $test2) {
    echo 'true';
}

    Dieses nicht den Wert wahr, wie $mag hat 2 Werte im array, die gleich 3.

    Dies funktioniert am besten, wenn Sie nur die Sorge um die Werte und Schlüssel, und Sie interessieren sich nicht für die Vervielfältigung.
    $mag = '{"1":"1","2":"2","3":"3","4":"3"}';
    $mag_evo = '1/2/3';

    $test1 = json_decode($mag, true);
$test2 = explode('|', $mag_evo);

//There is no difference in either array.  
if(!array_diff($test1, $test2) && !array_diff($test2, $test1)) { 
    echo 'true';
}

    Diese true zurück, da alle Werte in beiden arrays, aber wie gesagt, bevor es kümmert sich nicht um eine Vervielfältigung.

    InformationsquelleAutor der Antwort Case

  13. 0

    Wenn Sie wollen, suchen einige Arrays innerhalb eine große Auswahl von arrays (>10k) dann viel schneller ist der Vergleich der serialisierten arrays (gespeichert im cache). Beispiel aus der Arbeit mit dem URL:

    /**
@return array
*/
function createCache()
{
    $cache = [];
    foreach ($this->listOfUrl() as $url => $args)
    {
        ksort($args);
        $cache['url'][$url] = $args;
        $cache['arr'][crc32(serialize($args))] = $url;
    }
    return $cache;
}

/**
@param array $args
@return string
*/
function searchUrl($args)
{
    ksort($params);
    $crc = crc32(serialize($params));        
    return isset($this->cache['arr'][$crc]) ? $this->cache['arr'][$crc] : NULL;                
} 

/**
@param string $url
@return array
*/
function searchArgs($url)
{
    return isset($this->cache['url'][$url]) ? $this->cache['url'][$url] : NULL;
}

    InformationsquelleAutor der Antwort revoke

  14. -1

    versuchen Sie dies :

    $array1 = array("street" => array("Althan"), "city"   => "surat", "state"  => "guj", "county" => "india");
        $array2  = array("street" => array("Althan"), "city"   => "surat", "state"  => "guj", "county" => "india");

    if (array_compare($array1, $array2))
    {
             echo "<pre>";
             print_r("succsses..!");
             echo "</pre>";
             exit;

    }
    else
    {
            echo "<pre>";
            print_r("Faild..!");
            echo "</pre>";
            exit;
    }

    function array_compare($op1, $op2)
    {

            foreach ($op1 as $key => $val)
            {
                    if (is_array($val))
                    {
                            if (array_compare($val, $op2[$key]) === FALSE)
                                    return false;
                    }
                    else
                    {

                            if (!array_key_exists($key, $op2))
                            {
                                    return false; //uncomparable
                            }
                            elseif ($val < $op2[$key])
                            {
                                    return false;
                            }
                            elseif ($val > $op2[$key])
                            {
                                    return false;
                            }
                    }
            }
            return true; //$op1 == $op2
    }

    InformationsquelleAutor der Antwort Chintan

  15. -2

    Soweit ich das beurteilen kann, gibt es nicht eine single built-in Funktion, werde es für Sie tun, jedoch so etwas wie:

    if (count($a) == count($b) && (!count(array_diff($a, $b))) {
  //The arrays are the same
}

    Sollte den trick tun

    InformationsquelleAutor der Antwort pnomolos

  16. -2
    if(count($a1) == count($a2)){
    $result= array_intersect($a1, $a2);
    if(count($a1) == count($result))
        echo 'the same';
    else
        echo 'a1 different than a2';
} else
        echo 'a1 different than a2';

    InformationsquelleAutor der Antwort

Schreibe einen Kommentar