Für zwei Arrays $arr1 und $arr2 kann geprüft werden:
- Ob diese exakt identisch sind (gleiche Schlüssel, Werte und Reihenfolge): $arr1 === $arr2
- Ob diese die gleichen Werte enthalten: array_diff($arr1, $arr2) === array_diff($arr2, $arr1)
- Ob diese die gleichen Schlüssel enthalten: array_diff_key($arr1, $arr2) === array_diff_key($arr2, $arr1)
- Ob diese die gleichen Schlüssel-Wert-Paare enthalten: array_diff_assoc($arr1, $arr2) === array_diff_assoc($arr2, $arr1)
1. Prüfen über Identitätsoperator (===)
Zwei Arrays können über den Identitätsoperator „===” miteinander verglichen werden. Stehen die Arrays $a und $b zur Verfügung und wird auf diese der Operator über $a === $b angewendet, so erhält man (bool)true, wenn $a und $b exakt identisch sind. Sie sind exakt identisch, wenn alle Werte und Schlüssel den gleichen Datentyp, Inhalt und Reihenfolge haben. Das nächste Beispiel zeigt die Anwendung des Operators. Es wird ein Array $arr1 mit den Werten 1, 2 und 3 definiert (denen die Schlüssel 0, 1 und 2 automatisch zugeordnet werden). Dieses wird nacheinander mit mehreren Variationen verglichen: Andere Reihenfolge, andere Schlüssel, andere Werte, andere Datentypen. Wie zu sehen ist, verhält sich der Operator wie erwartet (mit einer Ausnahme).
<?php
$arr1 = array(1, 2, 3);
$arr2 = array(1, 2, 3);
$arr3 = array('x'=>1, 2, 3);
$arr4 = array(1, 3, 3);
$arr5 = array(1, 2, 3, 3);
$arr6 = array(3, 2, 1);
$arr7 = array(1, 2, 3, 4);
$arr8 = array('a', 'b', 'c');
$arr9 = array('1', '2', '3');
// Dieses Array ist eine nicht intuitive Ausnahme.
// Die Schlüssel sind zwar Strings (im Gegensatz zu Integern
// bei $arr1), trotzdem sind $arr1 und $arr10 nach $arr1 === $arr10 exakt identisch.
// Das liegt daran, dass PHP erkennt, dass die String-Schlüssel bei $arr10 gültige
// Integer wären und sie daher im Hintergrund kommentarlos in Integer umwandelt.
$arr10 = array('0' => 1, '1' => 2, '2' => 3);
var_dump($arr1 === $arr2); // true, da $arr1 und $arr2 exakt identisch definiert sind
var_dump($arr1 === $arr3); // false
var_dump($arr1 === $arr4); // false
var_dump($arr1 === $arr5); // false
var_dump($arr1 === $arr6); // false
var_dump($arr1 === $arr7); // false
var_dump($arr1 === $arr8); // false
var_dump($arr1 === $arr9); // false
var_dump($arr1 === $arr10); // true !
?>
bool(true) bool(false) bool(false) bool(false) bool(false) bool(false) bool(false) bool(false) bool(true)
2. Prüfen über Gleichheitsoperator (==)
Der Gleichheitsoperator bei Arrays arbeitet ähnlich zum Identitätsoperator. Grundsätzlich ist er allerdings toleranter: Auch Werte und Schlüssel unterschiedlicher Datentypen können beim Vergleich true ergeben, wenn sie nach Umwandlung in den selben Datentyp identisch sind. So sind etwa (string)"1" und (int)1 gleich. Auch (string)"1a" == (int)1 ergibt true, da bei der Konvertierung von "1a" zu Integer das "a" am Ende automatisch weggekürzt wird. Ansonsten gilt auch hier, dass die Werte und Schlüssel in der selben Reihenfolge im Array stehen müssen.
<?php
$arr1 = array(1, 2, 3);
$arr2 = array(1, 2, 3);
$arr3 = array('x'=>1, 2, 3);
$arr4 = array(1, 3, 3);
$arr5 = array(1, 2, 3, 3);
$arr6 = array(3, 2, 1);
$arr7 = array(1, 2, 3, 4);
$arr8 = array('a', 'b', 'c');
$arr9 = array('1', '2', '3');
$arr10 = array('0' => 1, '1' => 2, '2' => 3);
// Beim Vergleich mit Integern werden diese Strings in 1, 2, 3 umgewandelt:
$arr11 = array('1a', '2a', '3a');
var_dump($arr1 == $arr2); // true, da $arr1 und $arr2 exakt identisch definiert sind
var_dump($arr1 == $arr3); // false
var_dump($arr1 == $arr4); // false
var_dump($arr1 == $arr5); // false
var_dump($arr1 == $arr6); // false
var_dump($arr1 == $arr7); // false
var_dump($arr1 == $arr8); // false
var_dump($arr1 == $arr9); // true, Strings werden automatisch in Integer konvertiert
var_dump($arr1 == $arr10); // true, String-Schlüssel werden bereits bei Definition automatisch in Integer konvertiert
var_dump($arr1 == $arr11); // true !
?>
bool(true) bool(false) bool(false) bool(false) bool(false) bool(false) bool(false) bool(true) bool(true) bool(true)
Im Hinblick auf Objekte verhält sich == ebenfalls toleranter als ===. Während für === zwei Objekte nur dann gleich sind, wenn diese die selbe Instanz sind, ergibt == bereits dann true, wenn es sich um zwei Objekte der selben Klasse handelt. Das nächste Beispiel demonstriert dies:
<?php
$obj1 = new stdClass();
$obj2 = new stdClass();
$a = array($obj1);
$b = array($obj2);
echo("Vergleich der Objekte/Instanzen:\n");
var_dump($obj1 == $obj2); // true
var_dump($obj1 === $obj2); // false
var_dump($obj1 === $obj1); // true
echo("Vergleich der Objekte/Instanzen in Arrays:\n");
var_dump($a == $b); // true
var_dump($a === $b); // false
?>
Vergleich der Objekte/Instanzen: bool(true) bool(false) bool(true) Vergleich der Objekte/Instanzen in Arrays: bool(true) bool(false)
3. array_intersect()
Will man nur wissen, ob zwei Arrays die selben Werte enthalten, dann kann auf die Funktion array_intersect($arr1, $arr2) zurückgegriffen werden. Diese ermittelt die Schnittmenge der Werte aus $arr1 und $arr2, gibt also alle Werte aus $arr1 zurück, die auch in $arr2 enthalten sind. Diese Rückgabe lässt sich mit dem ursprünglichen Array ($arr1) vergleichen. Sind sowohl alle Werte aus $arr1 in $arr2 und alle aus $arr2 in $arr1 enthalten, dann bestehen entsprechend beide Arrays aus den selben Werten. Das nächste Beispiel verdeutlicht dies (wie zu erkennen ist, werden die Abfragen aber recht lang):
<?php
$arr1 = array(1, 2, 3);
$arr2 = array(1, 2, 3);
$arr3 = array('x'=>1, 2, 3);
$arr4 = array(1, 3, 3);
$arr5 = array(1, 2, 3, 3);
$arr6 = array(3, 2, 1);
$arr7 = array(1, 2, 3, 4);
$arr8 = array('a', 'b', 'c');
// jedes Element aus $arr1 muss in $arr2 sein UND jedes Element aus $arr2 muss in $arr1 sein
var_dump(array_intersect($arr1, $arr2) === $arr1 && array_intersect($arr2, $arr1) === $arr2); // true
var_dump(array_intersect($arr1, $arr3) === $arr1 && array_intersect($arr3, $arr1) === $arr3); // true
var_dump(array_intersect($arr1, $arr4) === $arr1 && array_intersect($arr4, $arr1) === $arr4); // false
var_dump(array_intersect($arr1, $arr5) === $arr1 && array_intersect($arr5, $arr1) === $arr5); // true
var_dump(array_intersect($arr1, $arr6) === $arr1 && array_intersect($arr6, $arr1) === $arr6); // true
var_dump(array_intersect($arr1, $arr7) === $arr1 && array_intersect($arr7, $arr1) === $arr7); // false
var_dump(array_intersect($arr1, $arr8) === $arr1 && array_intersect($arr8, $arr1) === $arr8); // false
?>
bool(true) bool(true) bool(false) bool(true) bool(true) bool(false) bool(false)
4. array_diff()
Im Vergleich zu array_intersect() ist die Anwendung von array_diff($arr1, $arr2) etwas angenehmer. Diese Funktion berechnet die Differenz der Arrays $arr1 und $arr2, gibt demnach also alle Elemente aus $arr1 zurück, deren Wert nicht in $arr2 enthalten ist. Sollen beide Arrays gleich sein, dann muss entsprechend array_diff($arr1, $arr2) ein leeres Array zurückgeben, da alle Werte aus $arr1 in $arr2 enthalten sein sollen. Enthält $arr1 Werte, die nicht in $arr2 sind, dann enthält das Ergebnis von array_diff($arr1, $arr2) mindestens ein Element, welches nicht zurückgegeben wird wenn man array_diff($arr2, $arr1) anwendet (da das Element/die Elemente ja nicht in $arr2 enthalten ist/sind). Wenn beide Arrays gleich sind geben daher sowohl array_diff($arr1, $arr2) als auch array_diff($arr2, $arr1) jeweils ein leeres Array zurück. Das ist die einzige Situation in der die Ergebnisse von array_diff($arr1, $arr2) und array_diff($arr2, $arr1) gleich sind. Daher muss nur geprüft werden, ob gilt array_diff($arr1, $arr2) === array_diff($arr2, $arr1), um herauszufinden, ob beide Arrays gleich sind. (Bei array_intersect() funktioniert das nicht.)
<?php
$arr1 = array(1, 2, 3);
$arr2 = array(1, 2, 3);
$arr3 = array('x'=>1, 2, 3);
$arr4 = array(1, 3, 3);
$arr5 = array(1, 2, 3, 3);
$arr6 = array(3, 2, 1);
$arr7 = array(1, 2, 3, 4);
$arr8 = array('a', 'b', 'c');
var_dump(array_diff($arr1, $arr2) === array_diff($arr2, $arr1)); // true
var_dump(array_diff($arr1, $arr3) === array_diff($arr3, $arr1)); // true, unterschiedliche Schlüssel sind kein Problem
var_dump(array_diff($arr1, $arr4) === array_diff($arr4, $arr1)); // false
var_dump(array_diff($arr1, $arr5) === array_diff($arr5, $arr1)); // true, da es für array_diff() keine Rolle spielt, wie oft ein Wert in einem der Arrays vorkommt
var_dump(array_diff($arr1, $arr6) === array_diff($arr6, $arr1)); // true, unterschiedliche Reihenfolge ist kein Problem
var_dump(array_diff($arr1, $arr7) === array_diff($arr7, $arr1)); // false
var_dump(array_diff($arr1, $arr8) === array_diff($arr8, $arr1)); // false
?>
bool(true) bool(true) bool(false) bool(true) bool(true) bool(false) bool(false)
5. array_intersect_key()
Will man nur wissen, ob zwei Arrays die gleichen Schlüssel enthalten, kann array_intersect_key($arr1, $arr2) angewendet werden. Die Funktionsweise ist identisch zu array_intersect(), nur dass die Schlüssel und nicht die Werte betrachtet werden. Entsprechend werden hier die selben Abfragen zum Vergleich der Arrays verwendet.
<?php
$arr1 = array('a' => 'I', 0 => 'II', 1 => 'III');
$arr2 = array('a' => 'I', 0 => 'II', 1 => 'III');
$arr3 = array(1 => 'III', 0 => 'II', 'a' => 'I');
$arr4 = array('x' => 'I', 0 => 'II', 1 => 'III');
$arr5 = array('a' => 'I', 0 => 'II', 1 => 'III', 2 => 'IV');
$arr6 = array('a' => 'I', 0 => 'II');
$arr7 = array(1 => 'I', 0 => 'II', 'a' => 'III');
$arr8 = array('1' => 'I', '2' => 'II', '3' => 'III');
var_dump(array_intersect_key($arr1, $arr2) === $arr1 && array_intersect_key($arr2, $arr1) === $arr2); // true
var_dump(array_intersect_key($arr1, $arr3) === $arr1 && array_intersect_key($arr3, $arr1) === $arr3); // true
var_dump(array_intersect_key($arr1, $arr4) === $arr1 && array_intersect_key($arr4, $arr1) === $arr4); // false
var_dump(array_intersect_key($arr1, $arr5) === $arr1 && array_intersect_key($arr5, $arr1) === $arr5); // false
var_dump(array_intersect_key($arr1, $arr6) === $arr1 && array_intersect_key($arr6, $arr1) === $arr6); // false
var_dump(array_intersect_key($arr1, $arr7) === $arr1 && array_intersect_key($arr7, $arr1) === $arr7); // true
var_dump(array_intersect_key($arr1, $arr8) === $arr1 && array_intersect_key($arr8, $arr1) === $arr8); // false
?>
bool(true) bool(true) bool(false) bool(false) bool(false) bool(true) bool(false)
6. array_diff_key()
Analog zu array_intersect() und array_intersect_key() gibt es auch für array_diff() eine Variante, die nur die Schlüssel zweier Arrays vergleicht. Ebenso gilt hier, dass wieder die Abfragen zum Vergleich der Arrays genauso sind wie bei array_diff() — nur wird array_diff() eben durch array_diff_key() ausgetauscht.
<?php
$arr1 = array('a' => 'I', 0 => 'II', 1 => 'III');
$arr2 = array('a' => 'I', 0 => 'II', 1 => 'III');
$arr3 = array(1 => 'III', 0 => 'II', 'a' => 'I');
$arr4 = array('x' => 'I', 0 => 'II', 1 => 'III');
$arr5 = array('a' => 'I', 0 => 'II', 1 => 'III', 2 => 'IV');
$arr6 = array('a' => 'I', 0 => 'II');
$arr7 = array(1 => 'I', 0 => 'II', 'a' => 'III');
$arr8 = array('1' => 'I', '2' => 'II', '3' => 'III');
var_dump(array_diff_key($arr1, $arr2) === array_diff_key($arr2, $arr1)); // true
var_dump(array_diff_key($arr1, $arr3) === array_diff_key($arr3, $arr1)); // true
var_dump(array_diff_key($arr1, $arr4) === array_diff_key($arr4, $arr1)); // false
var_dump(array_diff_key($arr1, $arr5) === array_diff_key($arr5, $arr1)); // false
var_dump(array_diff_key($arr1, $arr6) === array_diff_key($arr6, $arr1)); // false
var_dump(array_diff_key($arr1, $arr7) === array_diff_key($arr7, $arr1)); // true
var_dump(array_diff_key($arr1, $arr8) === array_diff_key($arr8, $arr1)); // false
?>
bool(true) bool(true) bool(false) bool(false) bool(false) bool(true) bool(false)
7. array_intersect_assoc()
Statt nur Schlüssel oder nur Werte können auch gleichzeitig sowohl Schlüssel als auch Werte geprüft werden. Genauer werden die Paare aus Schlüsseln und Werten untersucht. Dazu dient die Funktion array_intersect_assoc(), welche analog zu array_intersect() und array_intersect_key() benutzt wird. Zwei Arrays gelten bei richtiger Anwendung dann als gleich, wenn sie die selben Schlüssel-Wert-Paare enthalten.
<?php
$arr1 = array('a' => 'I', 0 => 'II', 1 => 'III');
$arr2 = array('a' => 'I', 0 => 'II', 1 => 'III');
$arr3 = array(1 => 'III', 0 => 'II', 'a' => 'I');
$arr4 = array('x' => 'I', 0 => 'II', 1 => 'III');
$arr5 = array('a' => 'I', 0 => 'II', 1 => 'III', 2 => 'IV');
$arr6 = array('a' => 'I', 0 => 'II');
$arr7 = array(1 => 'I', 0 => 'II', 'a' => 'III');
$arr8 = array('1' => 'I', '2' => 'II', '3' => 'III');
var_dump(array_intersect_assoc($arr1, $arr2) === $arr1 && array_intersect_assoc($arr2, $arr1) === $arr2); // true
var_dump(array_intersect_assoc($arr1, $arr3) === $arr1 && array_intersect_assoc($arr3, $arr1) === $arr3); // true
var_dump(array_intersect_assoc($arr1, $arr4) === $arr1 && array_intersect_assoc($arr4, $arr1) === $arr4); // false
var_dump(array_intersect_assoc($arr1, $arr5) === $arr1 && array_intersect_assoc($arr5, $arr1) === $arr5); // false
var_dump(array_intersect_assoc($arr1, $arr6) === $arr1 && array_intersect_assoc($arr6, $arr1) === $arr6); // false
var_dump(array_intersect_assoc($arr1, $arr7) === $arr1 && array_intersect_assoc($arr7, $arr1) === $arr7); // false
var_dump(array_intersect_assoc($arr1, $arr8) === $arr1 && array_intersect_assoc($arr8, $arr1) === $arr8); // false
?>
bool(true) bool(true) bool(false) bool(false) bool(false) bool(false) bool(false)
8. array_diff_assoc()
Auch beim Vergleich von Schlüssel-Wert-Paaren gibt es eine zu array_intersect_assoc() analoge Funktion für die Differenz, nämlich array_diff_assoc($arr1, $arr2). Ebenfalls erfolgt die Anwendung wieder genauso wie in den vorherigen Fällen, nur dass die Differenz diesmal einzig dann ein leeres Array ergibt, wenn $arr1 und $arr2 die selben Schlüssel-Wert-Paare enthalten.
<?php
$arr1 = array('a' => 'I', 0 => 'II', 1 => 'III');
$arr2 = array('a' => 'I', 0 => 'II', 1 => 'III');
$arr3 = array(1 => 'III', 0 => 'II', 'a' => 'I');
$arr4 = array('x' => 'I', 0 => 'II', 1 => 'III');
$arr5 = array('a' => 'I', 0 => 'II', 1 => 'III', 2 => 'IV');
$arr6 = array('a' => 'I', 0 => 'II');
$arr7 = array(1 => 'I', 0 => 'II', 'a' => 'III');
$arr8 = array('1' => 'I', '2' => 'II', '3' => 'III');
var_dump(array_diff_assoc($arr1, $arr2) === array_diff_assoc($arr2, $arr1)); // true
var_dump(array_diff_assoc($arr1, $arr3) === array_diff_assoc($arr3, $arr1)); // true
var_dump(array_diff_assoc($arr1, $arr4) === array_diff_assoc($arr4, $arr1)); // false
var_dump(array_diff_assoc($arr1, $arr5) === array_diff_assoc($arr5, $arr1)); // false
var_dump(array_diff_assoc($arr1, $arr6) === array_diff_assoc($arr6, $arr1)); // false
var_dump(array_diff_assoc($arr1, $arr7) === array_diff_assoc($arr7, $arr1)); // false
var_dump(array_diff_assoc($arr1, $arr8) === array_diff_assoc($arr8, $arr1)); // false
?>
bool(true) bool(true) bool(false) bool(false) bool(false) bool(false) bool(false)