/php-array

PHP数组及相关函数

MIT LicenseMIT

收藏的PHP数组函数

目录

类型

索引数组

带有数字索引的数组

$cars=array("Volvo","BMW","SAAB");

// anothor ways
$cars[0]="Volvo";
$cars[1]="BMW";
$cars[2]="SAAB";


⬆ Back to top

关联数组

使用您分配给数组的指定键的数组。

$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");

// another ways
$age['Peter']="35";
$age['Ben']="37";
$age['Joe']="43";


⬆ Back to top

多维数组

包含一个或多个数组的数组。

$cars = array
  (
  array("Volvo",22,18),
  array("BMW",15,13),
  );

// another ways
$cars[0][0] = 'Volvo' ;
$cars[0][1] = 22;
$cars[0][2] = 18 ;
$cars[1][0] = 'BMW';
$cars[1][0] = 15;
$cars[1][0] = 13;


⬆ Back to top

取值

输出数组中当前元素的值

current()

$people = array("Bill", "Steve", "Mark", "David");

echo current($people); // 当前元素是 Bill


⬆ Back to top

输出数组中最后一个元素的值

end()

$people = array("Bill", "Steve", "Mark", "David");

echo end($people); // 最后一个元素是 David


⬆ Back to top

输出数组中下一个元素的值

next()

$people = array("Bill", "Steve", "Mark", "David");

echo next($people); // Bill 的下一个元素是 Steve


⬆ Back to top

输出数组中上一个元素的值

prev()

$people = array("Bill", "Steve", "Mark", "David");

echo prev($people); // David 之前的元素是 Mark


⬆ Back to top

输出数组中第一个元素的值

reset()

$people = array("Bill", "Steve", "Mark", "David");

echo reset($people); // 把内部指针移动到数组的首个元素,即 Bill


⬆ Back to top

输出数组中当前元素的键名和键值,并将内部指针向前移动

each()

$people = array("Bill", "Steve", "Mark", "David");

each($people); // 返回当前元素的键名和键值,即'0'=> Bill
echo current($people); // 并将内部指针向前移动, 即Steve


⬆ Back to top

输出数组中当前元素键名

key()

$a = array('key'=>'value');

echo key($a); // key


⬆ Back to top

返回数组中部分的或所有的键名

array_keys()

$array = array(0 => 100, "color" => "red");

$result = array_keys($array);
print_r($result); // Array ( [0] => 0 [1] => color )


⬆ Back to top

返回数组中所有的值

array_values()

$array = array("size" => "XL", "color" => "gold");

$result = array_values($array);
print_r($result); // Array ( [0] => XL [1] => gold )


⬆ Back to top

返回单元顺序相反的数组

array_reverse()

$input  = array("php", 4.0, array("green", "red"));

$reversed = array_reverse($input);
print_r($reversed); // Array ( [0] => Array ( [0] => green [1] => red ) [1] => 4 [2] => php )


⬆ Back to top

返回数组中指定的一列

array_column()

// Array representing a possible record set returned from a database
$records = array(
    array(
        'id' => 2135,
        'first_name' => 'John',
        'last_name' => 'Doe',
    ),
    array(
        'id' => 3245,
        'first_name' => 'Sally',
        'last_name' => 'Smith',
    ),
    array(
        'id' => 5342,
        'first_name' => 'Jane',
        'last_name' => 'Jones',
    ),
    array(
        'id' => 5623,
        'first_name' => 'Peter',
        'last_name' => 'Doe',
    )
);

$first_names = array_column($records, 'first_name');
print_r($first_names); // Array ( [0] => John [1] => Sally [2] => Jane [3] => Peter )


⬆ Back to top

从数组中随机取出一个或多个单元

array_rand()

$input = array("Neo", "Morpheus", "Trinity", "Cypher", "Tank");

$rand_keys = array_rand($input, 2);
print_r($rand_keys); // Array ( [0] => 2 [1] => 4 )
echo $input[$rand_keys[0]]; // Neo
echo $input[$rand_keys[1]]; // Tank


⬆ Back to top

操作

将数组中的所有键名修改为全大写或小写

array_change_key_case()

$input_array = array("FirSt" => 1, "SecOnd" => 4);

// upper
$case_upper = array_change_key_case($input_array, CASE_UPPER);
print_r($case_upper); // Array ( [FIRST] => 1 [SECOND] => 4 )
// lower
$case_lower= array_change_key_case($input_array, CASE_LOWER);
print_r($case_lower); // Array ( [first] => 1 [second] => 4 )


⬆ Back to top

从数组中取出一段

array_slice()

$input = array("a", "b", "c", "d", "e");

$output = array_slice($input, 2);      // returns "c", "d", and "e"
$output = array_slice($input, -2, 1);  // returns "d"
$output = array_slice($input, 0, 3);   // returns "a", "b", and "c"


⬆ Back to top

把数组中的值赋给一组变量

list()

$info = array('coffee', 'brown', 'caffeine');

list($drink, $color, $power) = $info;
echo "$drink is $color and $power makes it special."; // coffee is brown and caffeine makes it special.


⬆ Back to top

建立一个包含指定范围单元的数组

range()

$number = range(0, 5);
print_r($number); // Array ( [0] => 0 [1] => 1 [2] => 2 [3] => 3 [4] => 4 [5] => 5 )


⬆ Back to top

去掉数组中的某一部分并用其它值取代

array_splice()

$input = array("red", "green", "blue", "yellow");

array_splice($input, 1, 1, "orange");
print_r($input); //Array ( [0] => red [1] => orange [2] => blue [3] => yellow )


⬆ Back to top

在数组中搜索给定的值,如果成功则返回首个相应的键名

array_search()

$array = array(0 => 'blue', 1 => 'red', 2 => 'green', 3 => 'red');

$key = array_search('green', $array);
print_r($key); // 2


⬆ Back to top

打乱数组

shuffle

$number = range(0, 5);

shuffle($number);
print_r($number); //  Array ( [0] => 2 [1] => 4 [2] => 0 [3] => 5 [4] => 3 [5] => 1 )


⬆ Back to top

移除数组中重复的值

array_unique()

$array = array(1, "hello", 1, "world", "hello");

$result = array_unique($array);
print_r($result); // Array ( [0] => 1 [1] => hello [3] => world )


⬆ Back to top

将一个数组分割成多个

array_chunk()

$input_array = array('a', 'b', 'c', 'd', 'e');

$output_array = array_chunk($input_array, 2);
print_r($output_array);
// Array ( [0] => Array ( [0] => a [1] => b ) [1] => Array ( [0] => c [1] => d ) [2] => Array ( [0] => e ) )


⬆ Back to top

交换数组中的键和值

array_flip()

$input = array("oranges", "apples", "pears");

$flipped = array_flip($input);
print_r($flipped); // Array ( [oranges] => 0 [apples] => 1 [pears] => 2 )


⬆ Back to top

创建一个数组,用一个数组的值作为其键名,另一个数组的值作为其值

array_combine()

$a = array('green', 'red', 'yellow');
$b = array('avocado', 'apple', 'banana');

$c = array_combine($a, $b);
print_r($c); // Array ( [green] => avocado [red] => apple [yellow] => banana )


⬆ Back to top

创建包含变量名和它们的值的数组

compact()

$firstname = "Bill";
$lastname = "Gates";
$age = "60";

$result = compact("firstname", "lastname", "age");

print_r($result); // Array ( [firstname] => Bill [lastname] => Gates [age] => 60 )


⬆ Back to top

从数组中将变量导入到当前的符号表

extract()

$var_array = array("color" => "blue",
                   "size"  => "medium",
                   "shape" => "sphere");
extract($var_array);

echo "$color, $size, $shape"; // blue, medium, sphere


⬆ Back to top

排序

对数组排序,由低到高

sort()

// Array to be sorted
$fruits = array("lemon", "orange", "banana", "apple");

// Sort and print the resulting array
sort($fruits);
print_r($fruits); //  Array ( [0] => apple [1] => banana [2] => lemon [3] => orange )


⬆ Back to top

对数组逆向排序,由高到低

rsort()

// Array to be sorted
$fruits = array("lemon", "orange", "banana", "apple");

// Sort and print the resulting array
rsort($fruits);
print_r($fruits); // Array ( [0] => orange [1] => lemon [2] => banana [3] => apple )


⬆ Back to top

对数组按照键名排序,由低到高

ksort()

// Array to be sorted
$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");

// Sort and print the resulting array
ksort($fruits);
print_r($fruits); // Array ( [a] => orange [b] => banana [c] => apple [d] => lemon )


⬆ Back to top

对数组按照键名逆向排序,由高到低

krsort()

// Array to be sorted
$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");

// Sort and print the resulting array
krsort($fruits);
print_r($fruits); // Array ( [d] => lemon [c] => apple [b] => banana [a] => orange )


⬆ Back to top

对数组进行排序并保持索引关系,由低到高

asort()

// Array to be sorted
$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");

// Sort and print the resulting array
asort($fruits);
print_r($fruits); // Array ( [c] => apple [b] => banana [d] => lemon [a] => orange )


⬆ Back to top

对数组进行逆向排序并保持索引关系,由高到低

arsort()

// Array to be sorted
$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");

// Sort and print the resulting array
arsort($fruits);
print_r($fruits); // Array ( [a] => orange [d] => lemon [b] => banana [c] => apple )


⬆ Back to top

使用用户自定义的比较函数对数组中的值进行排序

usort()

function cmp($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

// Array to be sorted
$a = array(3, 2, 5, 6, 1);

// Sort and print the resulting array
usort($a, "cmp");
print_r($a); // Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 5 [4] => 6 )


⬆ Back to top

使用用户自定义的比较函数对数组中的值进行排序并保持索引关联

uasort()

function cmp($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

// Array to be sorted
$array = array('a' => 4, 'b' => 8, 'c' => -1, 'd' => -9, 'e' => 2, 'f' => 5, 'g' => 3, 'h' => -4);

// Sort and print the resulting array
uasort($array, 'cmp');
print_r($array); // Array ( [d] => -9 [h] => -4 [c] => -1 [e] => 2 [g] => 3 [a] => 4 [f] => 5 [b] => 8 )


⬆ Back to top

使用用户自定义的比较函数对数组中的键名进行排序

uksort()

function cmp($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

// Array to be sorted
$array = array('f' => 5, 'a' => 4, 'h' => -4, 'd' => -9, 'c' => -1, 'e' => 2, 'g' => 3, 'b' => 8);

// Sort and print the resulting array
uksort($array, 'cmp');
print_r($array); // Array ( [a] => 4 [b] => 8 [c] => -1 [d] => -9 [e] => 2 [f] => 5 [g] => 3 [h] => -4 )


⬆ Back to top

用“自然排序”算法对数组排序

natsort()

// Array to be sorted
$array1 = $array2 = array("img12.png", "img10.png", "img2.png", "img1.png");

// Standard sorting
asort($array1);
print_r($array1); //  Array ( [3] => img1.png [1] => img10.png [0] => img12.png [2] => img2.png )

//nNatural order sorting
natsort($array2);
print_r($array2); // Array ( [3] => img1.png [2] => img2.png [1] => img10.png [0] => img12.png )


⬆ Back to top

用“自然排序”算法对数组进行不区分大小写字母的排序

natcasesort()

// Array to be sorted
$array1 = $array2 = array('IMG0.png', 'img12.png', 'img10.png', 'img2.png', 'img1.png', 'IMG3.png');

// Standard sorting
sort($array1);
print_r($array1);
// Array ( [0] => IMG0.png [1] => IMG3.png [2] => img1.png [3] => img10.png [4] => img12.png [5] => img2.png )

// nNatural order sorting (case-insensitive)
natcasesort($array2);
print_r($array2);
// Array ( [0] => IMG0.png [4] => img1.png [3] => img2.png [5] => IMG3.png [2] => img10.png [1] => img12.png )


⬆ Back to top

对多个数组或多维数组进行排序

array_multisort()

$arr = array(
    array(
        'top' => 0,
        'cnt' => 20,
    ),
    array(
        'top' => 0,
        'cnt' => 10,
    ),
    array(
        'top' => 1,
        'cnt' => 30,
    ),
);

array_multisort(array_column($arr, 'top'), SORT_DESC, SORT_NUMERIC,
    array_column($arr, 'cnt'), SORT_ASC, SORT_NUMERIC,
    $arr);
print_r($arr); // Array ( [0] => Array ( [top] => 1 [cnt] => 30 ) [1] => Array ( [top] => 0 [cnt] => 10 ) [2] => Array ( [top] => 0 [cnt] => 20 ) )


⬆ Back to top

计算

统计数组中元素数量

count()

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

echo count($a); // 4


⬆ Back to top

统计数组中所有的值

array_count_values()

$array = array(1, "hello", 1, "world", "hello");

$result = array_count_values($array);
print_r($result); // Array ( [1] => 2 [hello] => 2 [world] => 1 )


⬆ Back to top

对数组中所有值求和

array_sum()

$a = array(2, 4, 6, 8);
$sum = array_sum($a);
echo "sum(a) = " . $sum; // sum(a) = 20


⬆ Back to top

计算数组中所有值的乘积

array_product()

$a = array(2, 4, 6, 8);

$result = array_product($a);
print_r($result); // 384


⬆ Back to top

检查

检查数组里是否有指定的键名或索引

array_key_exists()

$search_array = array('first' => 1, 'second' => 4);
echo array_key_exists('first', $search_array); // 1


⬆ Back to top

检查数组中是否存在某个值

in_array()

$os = array("Mac", "NT", "Irix", "Linux");
echo in_array("Irix", $os); // 1


⬆ Back to top

合并

合并一个或多个数组

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] => green [0] => 2 [1] => 4 [2] => a [3] => b [shape] => trapezoid [4] => 4 )


⬆ Back to top

递归地合并一个或多个数组

array_merge_recursive()

$ar1 = array("color" => array("favorite" => "red"), 5);
$ar2 = array(10, "color" => array("favorite" => "green", "blue"));

$result = array_merge_recursive($ar1, $ar2);
print_r($result); // Array ( [color] => Array ( [favorite] => Array ( [0] => red [1] => green ) [0] => blue ) [0] => 5 [1] => 10 )


⬆ Back to top

替换

使用传递的数组替换第一个数组的元素

array_replace()

$base = array("orange", "banana", "apple", "raspberry");
$replacements = array(0 => "pineapple", 4 => "cherry");
$replacements2 = array(0 => "grape");

$basket = array_replace($base, $replacements, $replacements2);
print_r($basket); // Array ( [0] => grape [1] => banana [2] => apple [3] => raspberry [4] => cherry )


⬆ Back to top

使用传递的数组递归替换第一个数组的元素

array_replace_recursive()

$base = array('citrus' => array( "orange") , 'berries' => array("blackberry", "raspberry"), );
$replacements = array('citrus' => array('pineapple'), 'berries' => array('blueberry'));

$basket = array_replace_recursive($base, $replacements);
print_r($basket); // Array ( [citrus] => Array ( [0] => pineapple ) [berries] => Array ( [0] => blueberry [1] => raspberry )

$basket = array_replace($base, $replacements);
print_r($basket); // Array ( [citrus] => Array ( [0] => pineapple ) [berries] => Array ( [0] => blueberry ) )


⬆ Back to top

填充

使用指定的键和值填充数组

array_fill_keys()

$keys = array('foo', 5, 10, 'bar');

$a = array_fill_keys($keys, 'banana');
print_r($a); // Array ( [foo] => banana [5] => banana [10] => banana [bar] => banana )


⬆ Back to top

用给定的值填充数组

array_fill()

$a = array_fill(5, 3, 'banana');

print_r($a); // Array ( [5] => banana [6] => banana [7] => banana )


⬆ Back to top

以指定长度将一个值填充进数组

array_pad()

$input = array(12, 10, 9);

$result = array_pad($input, 5, 0);
print_r($result); // Array ( [0] => 12 [1] => 10 [2] => 9 [3] => 0 [4] => 0 )


⬆ Back to top

堆栈

将数组开头的单元移出数组

array_shift()

stack = array("orange", "banana", "apple", "raspberry");
$fruit = array_shift($stack);

print_r($stack); // Array ( [0] => banana [1] => apple [2] => raspberry )


⬆ Back to top

在数组开头插入一个或多个单元

array_unshift()

$queue = array("orange", "banana");
array_unshift($queue, "apple", "raspberry");

print_r($queue); // Array ( [0] => apple [1] => raspberry [2] => orange [3] => banana )


⬆ Back to top

弹出数组最后一个单元(出栈)

array_pop()

$stack = array("orange", "banana", "apple", "raspberry");
$fruit = array_pop($stack);

print_r($stack); // Array ( [0] => orange [1] => banana [2] => apple )


⬆ Back to top

将一个或多个单元压入数组的末尾(入栈)

array_push()

$stack = array("orange", "banana");
array_push($stack, "apple", "raspberry");

print_r($stack); // Array ( [0] => orange [1] => banana [2] => apple [3] => raspberry )


⬆ Back to top

回调

使用用户自定义函数对数组中的每个元素做回调处理

array_walk()

$fruits = array("d" => "lemon", "a" => "orange");

function test_alter(&$item1, $key, $prefix)
{
    $item1 = "$prefix: $item1";
}

array_walk($fruits, 'test_alter', 'fruit');
print_r($fruits); // Array ( [d] => fruit: lemon [a] => fruit: orange )


⬆ Back to top

对数组中的每个成员递归地应用用户函数

array_walk_recursive()

$sweet = array('a' => 'apple', 'b' => 'banana');
$fruits = array('sweet' => $sweet, 'sour' => 'lemon');

function test_alter(&$item1, $key, $prefix)
{
    $item1 = "$prefix: $item1";
}

array_walk_recursive($fruits, 'test_alter','fruit');
print_r($fruits); // Array ( [sweet] => Array ( [a] => fruit: apple [b] => fruit: banana ) [sour] => fruit: lemon )


⬆ Back to top

为数组的每个元素应用回调函数

array_map()

function cube($n)
{
    return($n * $n * $n);
}

$a = array(1, 2, 3, 4, 5);

$b = array_map("cube", $a);
print_r($b); // Array ( [0] => 1 [1] => 8 [2] => 27 [3] => 64 [4] => 125 )


⬆ Back to top

用回调函数迭代地将数组简化为单一的值

array_reduce()

function sum($carry, $item)
{
    $carry += $item;
    return $carry;
}

$a = array(1, 2, 3, 4, 5);

$result = array_reduce($a, "sum");
print_r($result); // 15


⬆ Back to top

用回调函数过滤数组中的单元

array_filter()

function odd($var)
{
    // returns whether the input integer is odd
    return($var & 1);
}

function even($var)
{
    // returns whether the input integer is even
    return(!($var & 1));
}

$array1 = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
$array2 = array(6, 7, 8, 9, 10, 11, 12);

print_r(array_filter($array1, "odd")); //  Array ( [a] => 1 [c] => 3 [e] => 5 )
print_r(array_filter($array2, "even")); // Array ( [0] => 6 [2] => 8 [4] => 10 [6] => 12 )


⬆ Back to top

差集

计算数组的差集

array_diff()

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

$result = array_diff($array1, $array2);
print_r($result); // Array ( [b] => brown [c] => blue )


⬆ Back to top

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

array_udiff()

function value_compare_func($key1, $key2)
{
    if ($key1 === $key2)
        return 0;
    else if ($key1 > $key2)
        return 1;
    else
        return -1;
}

$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green",  "yellow", "red");
$result = array_udiff($array1, $array2, "value_compare_func");
print_r($result); // Array ( [b] => brown [c] => blue )


⬆ Back to top

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

array_diff_assoc()

$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 )


⬆ Back to top

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

array_diff_uassoc()

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 )


⬆ Back to top

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

array_udiff_assoc()

function value_compare_func($key1, $key2)
{
    if ($key1 === $key2)
        return 0;
    else if ($key1 > $key2)
        return 1;
    else
        return -1;
}

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


⬆ Back to top

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

array_udiff_uassoc()

function key_compare_func($key1, $key2)
{
    if ($key1 === $key2)
        return 0;
    else if ($key1 > $key2)
        return 1;
    else
        return -1;
}

function value_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_udiff_uassoc($array1, $array2, "value_compare_func", "key_compare_func");
print_r($result); // Array ( [b] => brown [c] => blue [0] => red )


⬆ Back to top

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

array_diff_key()

$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 )


⬆ Back to top

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

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("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "b" => "yellow", "red");

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


⬆ Back to top

交集

计算数组的交集

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 )


⬆ Back to top

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

array_uintersect()

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

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

$result = array_uintersect($array1, $array2,'value_compare_func');
print_r($result); // Array ( [a] => green [0] => red )


⬆ Back to top

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

array_intersect_assoc()

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

$result_array = array_intersect_assoc($array1, $array2);
print_r($result_array); // Array ( [a] => green )


⬆ Back to top

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

array_intersect_uassoc()

function key_compare_func($key1, $key2)
{
    if ($key1 === $key2)
        return 0;
    else if ($key1 > $key2)
        return 1;
    else
        return -1;
}
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "b" => "yellow", "blue", "red");

$result_array = array_intersect_uassoc($array1, $array2,"key_compare_func");
print_r($result_array); // Array ( [a] => green )


⬆ Back to top

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

array_uintersect_assoc()

function value_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", "b" => "yellow", "blue", "red");

$result_array = array_uintersect_assoc($array1, $array2, "value_compare_func");
print_r($result_array); // Array ( [a] => green )


⬆ Back to top

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

array_uintersect_uassoc()

function key_compare_func($key1, $key2)
{
    if ($key1 === $key2)
        return 0;
    else if ($key1 > $key2)
        return 1;
    else
        return -1;
}

function value_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", "b" => "yellow", "blue", "red");

$result_array = array_uintersect_uassoc($array1, $array2, "value_compare_func", "key_compare_func");
print_r($result_array); // Array ( [a] => green )


⬆ Back to top

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

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 )


⬆ Back to top

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

array_intersect_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);

$result = array_intersect_ukey($array1, $array2, "key_compare_func");
print_r($result); // Array ( [blue] => 1 [green] => 3 )


⬆ Back to top