PHP Doku:: Berechnet den Unterschied zwischen Arrays, indem es die Schlüssel vergleicht - function.array-diff-key.html

Verlauf / Chronik / History: (1) anzeigen

Sie sind hier:
Doku-StartseitePHP-HandbuchFunktionsreferenzVariablen- und typbezogene ErweiterungenArraysArray Funktionenarray_diff_key

Ein Service von Reinhard Neidl - Webprogrammierung.

Array Funktionen

<<array_diff_assoc

array_diff_uassoc>>

array_diff_key

(PHP 5 >= 5.1.0)

array_diff_keyBerechnet den Unterschied zwischen Arrays, indem es die Schlüssel vergleicht

Beschreibung

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

Vergleicht die Schlüssel von array1 mit den Schlüsseln von array2 und gibt die Unterschiede zurück. Diese Funktion arbeitet wie array_diff() mit dem Unterschied, dass der Vergleich mit den Schlüsseln statt den Werten arbeitet.

Parameter-Liste

array1

Das Array, das verglichen werden soll

array2

Das Array, mit dem verglichen werden soll

...

Weitere Arrays, mit denen verglichen werden soll

Rückgabewerte

Gibt ein Array mit allen Einträgen von array1 zurück, deren Schlüssel in keinem der anderen Arrays vorhanden sind.

Beispiele

Beispiel #1 array_diff_key()-Beispiel

Die beiden Schlüssel des Schlüssel => Wert-Paares werden als gleich erachtet, genau dann wenn (string) $Schlüssel1 === (string) $Schlüssel2 . Anders ausgedrückt findet eine strikte Prüfung statt, in der die String-Repräsentationen gleich sein müssen.

<?php
$array1 
= array('blau'  => 1'rot'  => 2'grün'  => 3'violett' => 4);
$array2 = array('grün' => 5'blau' => 6'gelb' => 7'türkis'   => 8);

var_dump(array_diff_key($array1$array2));
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

array(2) {
  ["rot"]=>
  int(2)
  ["violett"]=>
  int(4)
}

Anmerkungen

Hinweis:

Diese Funktion überprüft nur eine Dimension eines n-dimensionalen Arrays. Natürlich kann man tiefere Dimensionen überprüfen, indem man array_diff_key($array1[0], $array2[0]); verwendet.

Siehe auch

  • array_diff() - Ermittelt die Unterschiede zwischen Arrays
  • array_udiff() - Ermittelt den Unterschied zwischen Arrays mittels einer Callbackfunktion für den Datenvergleich
  • array_diff_assoc() - Berechnet den Unterschied zwischen Arrays mit zusätzlicher Indexprüfung
  • array_diff_uassoc() - Berechnet den Unterschied von Arrays mit zusätzlicher Indexprüfung, welche durch eine benutzerdefinierte Funktion vorgenommen wird
  • array_udiff_assoc() - Ermittelt den Unterschied zwischen Arrays mit zusätzlicher Indexprüfung, vergleicht mittels einer Callbackfunktion
  • array_udiff_uassoc() - Ermittelt den Unterschied zwischen Arrays mit zusätzlicher Indexprüfung, vergleicht Daten und Indizes mittels einer Callbackfunktion
  • array_diff_ukey() - Berechnet den Unterschied zwischen Arrays mittels einer Callbackfunktion für den Vergleich der Schlüssel
  • array_intersect() - Ermittelt die Schnittmenge von Arrays
  • array_intersect_assoc() - Ermittelt die Schnittmenge von Arrays mit Indexprüfung
  • array_intersect_uassoc() - Ermittelt die Schnittmenge von Arrays mit Indexprüfung; vergleicht Indizes mit einer Callbackfunktion
  • array_intersect_key() - Ermittelt die Schnittmenge von Arrays, indem es die Schlüssel vergleicht
  • array_intersect_ukey() - Ermittelt die Schnittmenge zweier Arrays mittels eines durch eine Callbackfunktion durchgeführten Schlüsselvergleiches


14 BenutzerBeiträge:
- Beiträge aktualisieren...
division-par-zero at zilon dot net
3.10.2008 16:02
you can use this function for return the difference of two array !

<?php
function array_unique_diff_key ($array1, $array2)
{
  if (
is_array($array1) && is_array($array2))
    return
array_diff_key($array1, $array2) + array_diff_key($array2, $array1);
  else if (
is_array($array1)) return $array1;
  else if (
is_array($array2)) return $array2;
  else return array();
}
?>
Ashton
2.04.2008 23:33
To return the unique elements (those with a key that exists only once in either array but not in both) try:
function array_unique_diff ($array1, $array2)
{
  array_merge(array_diff_key($array1, $array2), array_diff_key($array2, $array1));
}

Example:
$array1 = array('blue'  => 1, 'red'  => 2, 'green'  => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan'   => 8);

  array_diff_key($array1, $array2)

returns

  array ( 'red' => 2, 'purple' => 4 )

  array_diff_key($array2, $array1)

returns

  array ( 'yellow' => 7, 'cyan' => 8, )

  array_unique_diff($array1, $array2);
 
returns

  array ( 'red' => 2, 'purple' => 4, 'yellow' => 7, 'cyan' => 8, )
sjungwirth at matrix-consultants dot com
28.02.2008 21:08
I needed something a little different where maybe even the keys in multidimensional arrays don't match up. Setting $assoc to false will cause only to check for missing keys, otherwise it compares values as well. This was also based on '2ge at 2ge dot us' function

<?php

function n_array_diff_assoc ($a1, $a2, $assoc=true) {
   
$r = array();
    if(
is_array(current($a1))):
        foreach(
$a1 as $k => $v):
            if(isset(
$a2[$k])):
               
$diff = n_array_diff($a1[$k], $a2[$k], $assoc);
                if (!empty(
$diff)):
                   
$r[$k] = $diff;
                endif;
            else:
               
$r[$k] = $v;
            endif;
        endforeach;
    else:
       
$r = $assoc ? array_diff_assoc($a1, $a2) : array_diff_key($a1, $a2);
    endif;
    return
$r;
}
?>
coder at gs dot com
16.02.2008 23:00
The PHP4 version below works only unidirectionally. If you switch the arrays around i.e. (ar2, ar1) you get different results than (ar1, ar2).
AiFiLTr0 [at host] invyl [dot] ath.cx
29.11.2007 14:56
The recursive function suggested by '2ge at 2ge dot us' will provide you with empty arrays if there's no diff.
This variant of the function cleans up empty arrays and fixes a bug in the first suggested version. It works 100%
.
<?php
function array_diff_key_recursive ($a1, $a2) {
        foreach(
$a1 as $k => $v) {
           
//$r[$k] = is_array($v) ? $this->array_diff_key_recursive($a1[$k], $a2[$k]) : array_diff_key($a1, $a2);
       
if (is_array($v))
            {
           
$r[$k]=$this->array_diff_key_recursive($a1[$k], $a2[$k]);
            }else
            {
           
$r=array_diff_key($a1, $a2);
            }

        if (
is_array($r[$k]) && count($r[$k])==0)
            {
            unset(
$r[$k]);
            }
        }
        return
$r;
    }
?>
contact at autonoma dot fr
30.06.2007 2:01
after kwutzke's comment , here is a PHP4 array_diff_key fonction for those in need

    function PHP4_array_diff_key()
    {
        $arrs = func_get_args();
        $result = array_shift($arrs);
        foreach ($arrs as $array) {
            foreach ($result as $key => $v) {
                if (array_key_exists($key, $array)) {
                    unset($result[$key]);
                }
            }
        }
        return $result;
   }

works for me, enjoy.
kwutzke @ somewhere in the net
20.12.2006 13:27
PHP4 array_diff_key can be copied from the array_intersect_key implementation posted by some anonymous user on 2006-07-17. The only thing you have to do is to delete the '!' in the if and rename the function.
2ge at 2ge dot us
7.03.2006 20:28
Hello, if you need diff key of n-dimensional arrays here is nice solution:
<?php
function n_array_diff ($a1, $a2) {
        foreach(
$a1 as $k => $v) {
           
$r[$k] = is_array($v) ? n_array_diff($a1[$k], $a2[$k]) : array_diff_key($a1, $a2);
        }
        return
$r;
}
?>
it will print everything, what is missing in $a2.
vlad_mustafin at ukr dot net
13.01.2006 16:39
One more alternative variant :)
<?
if (!function_exists('array_diff_key')) {
    function
array_diff_key() {
       
$argCount   = func_num_args();
       
$diff_arg_prefix = 'diffArg';
       
$diff_arg_names = array();
        for (
$i=0; $i < $argCount; $i++) {
           
$diff_arg_names[$i] = 'diffArg'.$i;
            $
$diff_arg_names[$i] = array_keys((array)func_get_arg($i));
        }
       
$diffArrString = '';
        if (!empty(
$diff_arg_names)) $diffArrString '$'.implode(', $', $diff_arg_names);
        eval(
"\$result = array_diff(".$diffArrString.");");
        return
$result;
    }
}
?>
ampf at egp dot up dot pt
25.11.2005 21:55
Well, you could implement in the code something more powerfull:

http://www.php.net/manual/en/function.array-diff.php#31364
ml at iceni dot pl
7.06.2005 9:52
You may obtain this function with PEAR Package PHP_Compat (http://pear.php.net/package/PHP_Compat)

Then using such code is quite useful
<?php
if(!function_exists('array_diff_key')){
    require_once
'PHP/Compat/Function/array_diff_key.php';
}
?>
maxence at pontapreta dot net
27.05.2005 19:38
Seems to be a great function, especially for n-dimensions arrays. The only problem is that I cannot find it in php 5.0.3 and 5.0.4. Does it really exist ?! :(

[20:27:05][maxence@conurb] ~/test2/php-5.0.4$ grep PHP_FUNCTION * -r | grep -i array_diff_key
[20:27:09][maxence@conurb] ~/test2/php-5.0.4$
eric dot broersma at phil dot uu dot nl
5.03.2005 15:58
<?php
function array_diff_key()
{
   
$args = func_get_args();
    return
array_flip(call_user_func_array('array_diff',
          
array_map('array_flip',$args)));
}
?>
denis noessler
23.11.2004 13:07
if (!function_exists('array_diff_key'))
{
    /**
    * Computes the difference of arrays using keys for comparison
    *
    * @param    array    $valuesBase            Base elements for comparison, associative
    * @param    array    $valuesComp[,..]    Comparison elements, associative
    *
    * @param    array                        Elements, not existing in comparison element, associative
    */
    function array_diff_key()
    {
        $argCount   = func_num_args();
        $argValues  = func_get_args();
        $valuesDiff = array();
       
        if ($argCount < 2)
        {
            return false;
        }
       
        foreach ($argValues as $argParam)
        {
            if (!is_array($argParam))
            {
                return false;
            }
        }
       
        foreach ($argValues[0] as $valueKey => $valueData)
        {
            for ($i = 1; $i < $argCount; $i++)
            {
                if (isset($argValues[$i][$valueKey]))
                {
                    continue 2;
                }
            }
           
            $valuesDiff[$valueKey] = $valueData;
        }
       
        return $valuesDiff;
    }
}



PHP Powered Diese Seite bei php.net
The PHP manual text and comments are covered by the Creative Commons Attribution 3.0 License © the PHP Documentation Group - Impressum - mail("TO:Reinhard Neidl",...)