PHP中的数组(集合)

并集

array_merge

合并一个或多个数组。一个数组中的值附加在前一个数组的后面,返回作为结果的数组。

别忘了数字键名将会被重新编号!

$array1 = array("color" => "red", 2, 4);
$array2 = array("a", "b", "color" => "green", "shape" => "trapezoid", 4);
$result = array_merge($array1, $array2);
print_r($result);

Array
(
    [color] => red
    [0] => 2
    [1] => 4
)
Array
(
    [0] => a
    [1] => b
    [color] => green
    [shape] => trapezoid
    [2] => 4
)
Array
(
    [color] => green
    [0] => 2
    [1] => 4
    [2] => a
    [3] => b
    [shape] => trapezoid
    [4] => 4
)

如果你想完全保留原有数组并只想新的数组附加到后面,用 + 运算符。如果两个被合并的数组含有相同的key,则保留第一个,忽略后边的。

$array1 = array(0 => 'zero_a', 2 => 'two_a', 3 => 'three_a');
$array2 = array(1 => 'one_b', 3 => 'three_b', 4 => 'four_b');
$result = $array1 + $array2;
print_r($result);

Array
(
    [0] => zero_a
    [2] => two_a
    [3] => three_a
    [1] => one_b
    [4] => four_b
)

差集

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_diff() 相同只除了比较是根据键名而不是值来进行的。

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

Array
(
    [red] => 2
    [purple] => 4
)

array_diff_assoc

带索引检查计算数组的差集

注意和 array_diff() 不同的是键名也用于比较。

$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_assoc($array1, $array2);
print_r($array1);
print_r($array2);
print_r($result);

Array
(
    [a] => green
    [b] => brown
    [c] => blue
    [0] => red
)
Array
(
    [a] => green
    [0] => yellow
    [1] => red
)
Array
(
    [b] => brown
    [c] => blue
    [0] => red
)

可以看到键值对 “a” => “green” 在两个数组中都有,因此不在本函数的输出中。键值对 0 => “red” 出现在输出中是因为第二个参数中的 “red” 的键名是 1。

$array1 = array(0, 1, 2);
$array2 = array("00", "01", "2");
$result = array_diff_assoc($array1, $array2);
print_r($result);

Array
(
    [0] => 0
    [1] => 1
)

键值对 key => value 中的两个值仅在 (string) elem1===(string) elem2 时被认为相等。也就是说使用了严格检查,字符串的表达必须相同。

array_udiff

用回调函数比较数据来计算数组的差集

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

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

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:cr:private] => 12
        )

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

)

array_diff_ukey

用回调函数对键名比较计算数组的差集

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);
print_r(array_diff_ukey($array1, $array2, 'key_compare_func'));

Array
(
    [red] => 2
    [purple] => 4
)

array_diff_uassoc

用用户提供的回调函数做索引检查来计算数组的差集

compare KEYS with custom comparison functions and values with default comparison function

array_udiff_assoc

带索引检查计算数组的差集,用回调函数比较数据

compare VALUES with custom comparison function and keys with default comparison function

function compare_func($a, $b) {
    if(abs($a) == abs($b)) return 0;
    return (abs($a) > abs($b))?1:-1;
}
$test1 = array(
    1   =>  "a",
    2   =>  "b",
    3   =>  "c"
);
$test2 = array(
    -1  =>  "a",
    -2  =>  "b",
    -3  =>  "c"
);
print_r(array_diff_uassoc($test1, $test2, "compare_func"));
print_r(array_udiff_assoc($test1, $test2, "compare_func"));

Array
(
)
Array
(
    [1] => a
    [2] => b
    [3] => c
)

array_udiff_uassoc

带索引检查计算数组的差集,用回调函数比较数据和索引

compare both KEYS and VALUES with a custom comparison function


交集

array_intersect

计算数组的交集

$array1 = array("a" => "green", "red", "blue");
$array2 = array("b" => "green", "yellow", "red");
$result = array_intersect($array1, $array2);
print_r($result);

Array
(
    [a] => green
    [0] => red
)

array_intersect_key

使用键名比较计算数组的交集

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

Array
(
    [blue] => 1
    [green] => 3
)

array_intersect_assoc

带索引检查计算数组的交集

$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "b" => "yellow", "blue", "red");
$result = array_intersect_assoc($array1, $array2);
print_r($result);

Array
(
    [a] => green
)

array_uintersect

计算数组的交集,用回调函数比较数据

$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");
$result = array_uintersect($array1, $array2, "strcmp");
print_r($result);

Array
(
    [b] => brown
    [0] => red
)

array_intersect_ukey

用回调函数比较键名来计算数组的交集

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

Array
(
    [blue] => 1
    [green] => 3
)

array_intersect_uassoc

带索引检查计算数组的交集,用回调函数比较索引

用自定义函数比较KEYS

array_uintersect_assoc

带索引检查计算数组的交集,用回调函数比较数据

用自定义函数比较VALUES

array_uintersect_uassoc

带索引检查计算数组的交集,用回调函数比较数据和索引

用自定义函数比较KEYS and VALUES

参考

  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值