差集

array_diff — 计算数组的差集(比较值)

语法

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

描述

• 对比返回在 array1 中但是不在 array2 及任何其它参数数组中的值

参数

返回值

• 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。注意键名保留不变

举例

// 示例
$array1 = array("a" => "green", "red", "blue", "red");
$array2 = array("b" => "green", "yellow", "red");
$result = array_diff($array1, $array2);
print_r($result);
// 结果
Array
(
    [1] => blue
)

array_diff_key — 使用键名比较计算数组的差集(比较键)

语法

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

描述

• 根据 array1 中的键名和 array2 进行比较，返回不同键名的项。本函数和 array_diff() 相同只除了比较是根据键名而不是值来进行的

参数

返回值

• array_diff_key() 返回一个数组，该数组包括了所有出现在 array1 中但是未出现在任何其它参数数组中的键名的值

举例

// 示例
$array1 = array('blue'  => 1, 'red'  => 2, 'green'  => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan'   => 8);
var_dump(array_diff_key($array1, $array2));
// 结果
array(2) {
  ["red"]=>
  int(2)
  ["purple"]=>
  int(4)
}

array_diff_assoc — 带索引检查计算数组的差集(同时比较键和值)

语法

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

描述

• array_diff_assoc() 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。注意和 array_diff() 不同的是键名也用于比较

参数

返回值

• 返回一个数组，该数组包括了所有出现在 array1 中但是未出现在任何其它参数数组中的键名的值

举例

// 示例1
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_assoc($array1, $array2);
print_r($result);
// 结果
Array
(
    [b] => brown
    [c] => blue
    [0] => red
)

// 示例2
$array1 = array(0, 1, 2);
$array2 = array("00", "01", "2");
$result = array_diff_assoc($array1, $array2);
print_r($result);
// 结果
Array
(
    [0] => 0
    [1] => 1
)

array_diff_uassoc — 用用户提供的回调函数做索引检查来计算数组的差集(同时比较键和值，键是自定义函数)

语法

array array_diff_uassoc( array $array1, array $array2[, array $...], callable $key_compare_func)

描述

• 对比了 array1 和 array2 并返回不同之处。注意和 array_diff() 不同的是键名也用于比较。
• 和 array_diff_assoc() 不同的是使用了用户自定义的回调函数，而不是内置的函数

参数

返回值

• 返回一个 array，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值

举例

// 示例
function key_compare_func($a, $b)
{
    if ($a === $b) {
        return 0;
    }
    return ($a > $b)? 1:-1;
}

$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_uassoc($array1, $array2, "key_compare_func");
print_r($result);
// 结果
Array
(
    [b] => brown
    [c] => blue
    [0] => red
)

array_diff_ukey — 用回调函数对键名比较计算数组的差集(比较键，键是自定义函数)

语法

array array_diff_ukey( array $array1, array $array2[, array $ ...], callable $key_compare_func)

描述

• array_diff_ukey() 返回一个数组，该数组包括了所有出现在 array1 中但是未出现在任何其它参数数组中的键名的值。注意关联关系保留不变。本函数和 array_diff() 相同只除了比较是根据键名而不是值来进行的
• 此比较是通过用户提供的回调函数来进行的。如果认为第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数

参数

返回值

• 举例

// 示例
function key_compare_func($key1, $key2)
{
    if ($key1 == $key2)
        return 0;
    else if ($key1 > $key2)
        return 1;
    else
        return -1;
}
$array1 = array('blue'  => 1, 'red'  => 2, 'green'  => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan'   => 8);
var_dump(array_diff_ukey($array1, $array2, 'key_compare_func'));
// 结果
array(2) {
  ["red"]=>
  int(2)
  ["purple"]=>
  int(4)
}

array_udiff_assoc — 带索引检查计算数组的差集，用回调函数比较数据(同时比较键和值，值是自定义函数)

语法

array array_udiff_assoc( array $array1, array $array2[, array $ ...], callable $data_compare_func)

描述

• 此比较是通过用户提供的回调函数来进行的。如果认为第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数
• Note: 注意本函数只检查了多维数组中的一维。当然，可以用 array_udiff_assoc($array1[0], $array2[0], "some_comparison_func"); 来检查更深的维度。

参数

返回值

• array_udiff_assoc() 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。
• 注意和 array_diff() 与 array_udiff() 不同的是键名也用于比较。
• 数组数据的比较是用用户提供的回调函数进行的。在此方面和 array_diff_assoc() 的行为正好相反，后者是用内部函数进行比较的。

举例

// 示例
class cr {
    private $priv_member;
    function cr($val)
    {
        $this->priv_member = $val;
    }

    static function comp_func_cr($a, $b)
    {
        if ($a->priv_member === $b->priv_member) return 0;
        return ($a->priv_member > $b->priv_member)? 1:-1;
    }
}
$a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1=> new cr(4), 2 => new cr(-15),);
$b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1=> new cr(4), 2 => new cr(-15),);
$result = array_udiff_assoc($a, $b, array("cr", "comp_func_cr"));
print_r($result);
// 结果
Array
(
    [0.1] => cr Object
        (
            [priv_member:private] => 9
        )

    [0.5] => cr Object
        (
            [priv_member:private] => 12
        )

    [0] => cr Object
        (
            [priv_member:private] => 23
        )
)

array_udiff_uassoc — 带索引检查计算数组的差集，用回调函数比较数据和索引(同时比较键和值，键和值都是自定义函数)

语法

array array_udiff_uassoc( array $array1, array $array2[, array $ ...], callable $data_compare_func, callable $key_compare_func)

描述

• array_udiff_uassoc() 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。
• 注意和 array_diff() 与 array_udiff() 不同的是键名也用于比较。

参数

返回值

• 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值

举例

// 示例
class cr {
    private $priv_member;
    function cr($val)
    {
        $this->priv_member = $val;
    }

    static function comp_func_cr($a, $b)
    {
        if ($a->priv_member === $b->priv_member) return 0;
        return ($a->priv_member > $b->priv_member)? 1:-1;
    }

    static function comp_func_key($a, $b)
    {
        if ($a === $b) return 0;
        return ($a > $b)? 1:-1;
    }
}
$a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1=> new cr(4), 2 => new cr(-15),);
$b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1=> new cr(4), 2 => new cr(-15),);
$result = array_udiff_uassoc($a, $b, array("cr", "comp_func_cr"), array("cr", "comp_func_key"));
print_r($result);
// 结果
Array
(
    [0.1] => cr Object
        (
            [priv_member:private] => 9
        )

    [0.5] => cr Object
        (
            [priv_member:private] => 12
        )

    [0] => cr Object
        (
            [priv_member:private] => 23
        )
)

array_udiff — 用回调函数比较数据来计算数组的差集(比较值，值是自定义函数)

语法

array array_udiff( array $array1, array $array2[, array $ ...], callable $data_compare_func)

描述

• array_udiff() 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。
• 注意键名保持不变。数据的比较是用 data_compare_func 进行的。如果认为第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数。这和 array_diff() 不同，后者使用了内部函数来比较数据

参数

返回值

• 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值

举例

// 示例
class cr {
    private $priv_member;
    function cr($val)
    {
        $this->priv_member = $val;
    }

    static function comp_func_cr($a, $b)
    {
        if ($a->priv_member === $b->priv_member) return 0;
        return ($a->priv_member > $b->priv_member)? 1:-1;
    }
}
$a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1=> new cr(4), 2 => new cr(-15),);
$b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1=> new cr(4), 2 => new cr(-15),);
$result = array_udiff($a, $b, array("cr", "comp_func_cr"));
print_r($result);
// 结果
Array
(
    [0.5] => cr Object
        (
            [priv_member:private] => 12
        )

    [0] => cr Object
        (
            [priv_member:private] => 23
        )

)