PHP数组计算差集系列函数的区别

PHPllslx520 发表了文章 • 0 个评论 • 73 次浏览 • 2016-11-13 12:36 • 来自相关话题

一、函数介绍:
  PHP数组差集计算函数,用来计算一个数组与其他数组的差集。计算类型分为计算键名的差集、计算键值的差集、计算键名/值对的差集三类;计算方式分为系统默认函数计算和使用用户自定义函数计算两种。PHP数组差集计算函数共有8个。计算键名的差集:计算第一个数组与其他数组键名的差集(不考虑键值),返回时键名对应的键值保持不变一起返回。计算键名的差集函数有:array_diff_key(),array_diff_ukey()。计算键值的差集:计算第一个数组与其他数组键值的差集(不考虑键名),返回时键值对应的键名保持不变一起返回。计算键值的差集函数有:array_diff(),array_udiff()。计算键名/值对的差集:计算第一个数组与其他数组的差集(同时考虑键名和键值)。计算键名/值对的差集函数有:array_diff_assoc(),array_udiff_assoc(),array_diff_uassoc(),array_udiff_uassoc()。
 
数组差集比较函数功能差异表:函数名计算何种差集键名比较函数键值比较函数array_diff键值的差集,不考虑键名-系统默认array_udiff键值的差集,不考虑键名-自定义函数array_diff_assoc键名和键值的差集系统默认系统默认array_diff_uassoc键名和键值的差集自定义函数系统默认array_diff_key键名的差集,不考虑键值系统默认-array_diff_ukey键名的差集,不考虑键值自定义函数-array_udiff_assoc键名和键值的差集系统默认自定义函数array_udiff_uassoc键名和键值的差集自定义函数自定义函数 PHP数组计算交集系列函数的区别:http://aiezu.com/article/php_array_intersect_sets.html
 
二、参数中的自定义函数:
  差集比较函数通过比较键名、键值是否想等,把完全相等的剔除掉,从而找出它与其它数组的差集。为了方便大家实现个性化的需求,PHP为部分函数提供了接口,可以使用自定义函数来比较键名、键值是否相等。PHP会传递两个键名给键名自定义比较函数、或者两个键值给自定义键值比较函数,用户可以在自定义比较函数中根据自己的需求进行比较,只需给自定义函数一个整型返回值就行(返回0认为键名或键值相等)。
 
自定义比较函数举例:
1、使用基础函数方式:<?php
#键名比较函数
function user_key_compare_func($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
#键值比较函数
function user_value_compare_func($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}输出:<?php
array_diff_ukey($arr1, $arr2, 'user_key_compare_func');
array_udiff($arr1, $arr2, 'user_value_compare_func');
array_udiff_uassoc($arr1, $arr2, 'user_value_compare_func', 'user_key_compare_func');
array_udiff_uassoc($arr1, $arr2, $arr3, 'user_value_compare_func', 'user_key_compare_func');  
2、使用类的函数方式:<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}输出:<?php
array_diff_ukey($arr1, $arr2, array('user', 'key_compare'));
array_udiff($arr1, $arr2, array('user', 'value_compare'));
array_udiff_uassoc($arr1, $arr2, array('user', 'value_compare'), array('user', 'key_compare')); 
三、用法举例:
1、使用基础自定义函数作为比较函数完整代码:<?php
function user_key_compare_func($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}

function user_value_compare_func($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}

$arr1 = array('爱E族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');


print_r(array_diff_ukey($arr1, $arr2, 'user_key_compare_func'));
print_r(array_udiff($arr1, $arr2, 'user_value_compare_func'));
print_r(array_udiff_uassoc($arr1, $arr2, 'user_value_compare_func', 'user_key_compare_func'));Array
(
[1] => aiezu
)
Array
(
)
Array
(
[0] => 爱E族
[1] => aiezu
)
2、使用类函数作为比较函数完整代码:<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array('爱E族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
print_r(array_diff_ukey($arr1, $arr2, array('user', 'key_compare')));
print_r(array_udiff($arr1, $arr2, array('user', 'value_compare')));
print_r(array_udiff_uassoc($arr1, $arr2, array('user', 'value_compare'), array('user', 'key_compare')));输出:Array
(
[1] => aiezu
)
Array
(
)
Array
(
[0] => 爱E族
[1] => aiezu
)
3、差集比较函数的工作流程:
  这里以array_udiff_uassoc()函数举例解析差集比较函数的工作流程,array_udiff_uassoc()函数是使用自定义函数计算出第一个数组与其他数组的差集(考虑键名和键值,对键名和键值都使用自定义函数)。<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("debug key: %s vs %s %s\n", $k1, $k2, $k1===$k2 ? 0 : ($k1>$k2?1:-1) ); //debug行
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}

function user_value_compare_func($v1, $v2) {
echo sprintf("debug value: %s vs %s %s\n", $v1, $v2, $v1===$v2 ? 0 : ($v1>$v2?1:-1) ); //debug行
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}

$arr1 = array('usage', 'name'=>'aiezu', 'suffix'=>'com',);
$arr2 = array('0'=>'usage', 'name'=>'爱E族');
print_r(array_udiff_uassoc($arr1, $arr2, 'user_value_compare_func', 'user_key_compare_func'));输出:debug key: name vs 0 -1 #$arr1的key排序去重
debug key: suffix vs name 1
debug key: 0 vs name -1 #$arr2的key排序去重

debug key: name vs 0 -1
debug key: 0 vs name -1
debug key: 0 vs 0 0 #key相等,下步判断key对应的值是否相等
debug value: usage vs usage 0 #key对应的值也相等,key:0,value:usage不会出现在返回结果中
debug key: name vs name 0 #key相等,下步判断key对应的值是否相等
debug value: aiezu vs 爱E族 -1 #key对应的值不相等,key:name,value:aiezu将出现在返回结果中
debug key: suffix vs name 1
debug key: suffix vs 0 -1
Array
(
[name] => aiezu
[suffix] => com
查看全部
一、函数介绍:
  PHP数组差集计算函数,用来计算一个数组与其他数组的差集。计算类型分为计算键名的差集、计算键值的差集、计算键名/值对的差集三类;计算方式分为系统默认函数计算和使用用户自定义函数计算两种。PHP数组差集计算函数共有8个。
  • 计算键名的差集:计算第一个数组与其他数组键名的差集(不考虑键值),返回时键名对应的键值保持不变一起返回。计算键名的差集函数有:array_diff_key(),array_diff_ukey()。
  • 计算键值的差集:计算第一个数组与其他数组键值的差集(不考虑键名),返回时键值对应的键名保持不变一起返回。计算键值的差集函数有:array_diff(),array_udiff()。
  • 计算键名/值对的差集:计算第一个数组与其他数组的差集(同时考虑键名和键值)。计算键名/值对的差集函数有:array_diff_assoc(),array_udiff_assoc(),array_diff_uassoc(),array_udiff_uassoc()。

 
数组差集比较函数功能差异表:
函数名计算何种差集键名比较函数键值比较函数
array_diff键值的差集,不考虑键名-系统默认
array_udiff键值的差集,不考虑键名-自定义函数
array_diff_assoc键名和键值的差集系统默认系统默认
array_diff_uassoc键名和键值的差集自定义函数系统默认
array_diff_key键名的差集,不考虑键值系统默认-
array_diff_ukey键名的差集,不考虑键值自定义函数-
array_udiff_assoc键名和键值的差集系统默认自定义函数
array_udiff_uassoc键名和键值的差集自定义函数自定义函数
 PHP数组计算交集系列函数的区别:http://aiezu.com/article/php_array_intersect_sets.html
 
二、参数中的自定义函数:
  差集比较函数通过比较键名、键值是否想等,把完全相等的剔除掉,从而找出它与其它数组的差集。为了方便大家实现个性化的需求,PHP为部分函数提供了接口,可以使用自定义函数来比较键名、键值是否相等。PHP会传递两个键名给键名自定义比较函数、或者两个键值给自定义键值比较函数,用户可以在自定义比较函数中根据自己的需求进行比较,只需给自定义函数一个整型返回值就行(返回0认为键名或键值相等)。
 
自定义比较函数举例:
1、使用基础函数方式:
<?php
#键名比较函数
function user_key_compare_func($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
#键值比较函数
function user_value_compare_func($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
输出:
<?php
array_diff_ukey($arr1, $arr2, 'user_key_compare_func');
array_udiff($arr1, $arr2, 'user_value_compare_func');
array_udiff_uassoc($arr1, $arr2, 'user_value_compare_func', 'user_key_compare_func');
array_udiff_uassoc($arr1, $arr2, $arr3, 'user_value_compare_func', 'user_key_compare_func');
  
2、使用类的函数方式:
<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
输出:
<?php
array_diff_ukey($arr1, $arr2, array('user', 'key_compare'));
array_udiff($arr1, $arr2, array('user', 'value_compare'));
array_udiff_uassoc($arr1, $arr2, array('user', 'value_compare'), array('user', 'key_compare'));
 
三、用法举例:
1、使用基础自定义函数作为比较函数完整代码:
<?php
function user_key_compare_func($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}

function user_value_compare_func($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}

$arr1 = array('爱E族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');


print_r(array_diff_ukey($arr1, $arr2, 'user_key_compare_func'));
print_r(array_udiff($arr1, $arr2, 'user_value_compare_func'));
print_r(array_udiff_uassoc($arr1, $arr2, 'user_value_compare_func', 'user_key_compare_func'));
Array
(
[1] => aiezu
)
Array
(
)
Array
(
[0] => 爱E族
[1] => aiezu
)

2、使用类函数作为比较函数完整代码:
<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array('爱E族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
print_r(array_diff_ukey($arr1, $arr2, array('user', 'key_compare')));
print_r(array_udiff($arr1, $arr2, array('user', 'value_compare')));
print_r(array_udiff_uassoc($arr1, $arr2, array('user', 'value_compare'), array('user', 'key_compare')));
输出:
Array
(
[1] => aiezu
)
Array
(
)
Array
(
[0] => 爱E族
[1] => aiezu
)

3、差集比较函数的工作流程:
  这里以array_udiff_uassoc()函数举例解析差集比较函数的工作流程,array_udiff_uassoc()函数是使用自定义函数计算出第一个数组与其他数组的差集(考虑键名和键值,对键名和键值都使用自定义函数)。
<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("debug key: %s vs %s %s\n", $k1, $k2, $k1===$k2 ? 0 : ($k1>$k2?1:-1) ); //debug行
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}

function user_value_compare_func($v1, $v2) {
echo sprintf("debug value: %s vs %s %s\n", $v1, $v2, $v1===$v2 ? 0 : ($v1>$v2?1:-1) ); //debug行
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}

$arr1 = array('usage', 'name'=>'aiezu', 'suffix'=>'com',);
$arr2 = array('0'=>'usage', 'name'=>'爱E族');
print_r(array_udiff_uassoc($arr1, $arr2, 'user_value_compare_func', 'user_key_compare_func'));
输出:
debug key: name vs 0 -1  #$arr1的key排序去重
debug key: suffix vs name 1
debug key: 0 vs name -1 #$arr2的key排序去重

debug key: name vs 0 -1
debug key: 0 vs name -1
debug key: 0 vs 0 0 #key相等,下步判断key对应的值是否相等
debug value: usage vs usage 0 #key对应的值也相等,key:0,value:usage不会出现在返回结果中
debug key: name vs name 0 #key相等,下步判断key对应的值是否相等
debug value: aiezu vs 爱E族 -1 #key对应的值不相等,key:name,value:aiezu将出现在返回结果中
debug key: suffix vs name 1
debug key: suffix vs 0 -1
Array
(
[name] => aiezu
[suffix] => com
)
 

PHP array_uintersect_uassoc 函数

PHPllslx520 发表了文章 • 0 个评论 • 44 次浏览 • 2016-11-13 12:25 • 来自相关话题

一、函数功能:
  计算多个数组共同的键名/键值交集(同时考虑键名和键值,键名、键值的比较都使用自定义函数)。PHP 5.0起才支持此函数。关于计算数组交集系列函数的区别请参考:PHP数组计算交集系列函数的区别。

二、函数语法:array array_uintersect_uassoc($array1, $array2 [, $...], $user_value_compare_func, $user_key_compare_func )
三、函数参数:参数名描述$array1参与比较的第一个数组;$array2参与比较的第二个数组;...参与比较的更多数组;$user_value_compare_func用户自定义回调函数,用来比较键值。如果认为第一个键值小于,等于,或大于第二个键值时必须分别返回一个小于零,等于零,或大于零的整数。只有键名相等,对应的键值才会传给此自定义函数比较。$user_key_compare_func用户自定义回调函数,用来比较键名。如果认为第一个键名小于,等于,或大于第二个键名时必须分别返回一个小于零,等于零,或大于零的整数。 
四、返回值:返回一个数组,该数组包含了参数中所有数组共同的键名/键值对。
五、用法举例:
1、两个数组的键名/键值对的交集:
  键名和键值的比较都使用自定义函数。<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("debug key: %s vs %s %s\n", $k1, $k2, $k1===$k2 ? 0 : ($k1>$k2?1:-1) ); //debug行
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}

function user_value_compare_func($v1, $v2) {
echo sprintf("debug value: %s vs %s %s\n", $v1, $v2, $v1===$v2 ? 0 : ($v1>$v2?1:-1) ); //debug行
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}

$arr1 = array("name"=>'爱E族', "type"=>"domaim");
$arr2 = array("name"=>'爱E族', "type"=>'string');

$result = array_uintersect_uassoc($arr1, $arr2, "user_value_compare_func", "user_key_compare_func");
print_r($result);输出:debug key: type vs name 1 #$arr1键名的排序去重
debug key: type vs name 1 #$arr2键名的排序去重

debug key: name vs name 0 #键名相等、下步将比较键值是否相等
debug value: 爱E族 vs 爱E族 0 #键值也相等,将在返回数组中返回
debug key: type vs type 0 #键名相等、下步将比较键值是否相等
debug value: domaim vs string -1 #键值不相等,不会在返回数组中返回
Array
(
[name] => 爱E族

2、比较三个数组中共同的键名/键值对:
  找出三个数组的共同的键名/键值对,键名和键值的比较都使用自定义函数。<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array("name"=>'爱E族', "type"=>"domaim", 'en'=>'aiezu');
$arr2 = array("name"=>'爱E族', "type"=>'string', 'en'=>'aiezu');
$arr3 = array('name'=>'爱E族', 'type'=>'string');
print_r(array_uintersect_uassoc($arr1, $arr2, $arr3, array('user', 'value_compare'), array('user', 'key_compare')));输出:Array
(
[name] => 爱E族
查看全部
一、函数功能:
  计算多个数组共同的键名/键值交集(同时考虑键名和键值,键名、键值的比较都使用自定义函数)。PHP 5.0起才支持此函数。关于计算数组交集系列函数的区别请参考:PHP数组计算交集系列函数的区别

二、函数语法:
array array_uintersect_uassoc($array1, $array2 [, $...], $user_value_compare_func, $user_key_compare_func )

三、函数参数:
参数名描述
$array1参与比较的第一个数组;
$array2参与比较的第二个数组;
...参与比较的更多数组;
$user_value_compare_func用户自定义回调函数,用来比较键值。如果认为第一个键值小于,等于,或大于第二个键值时必须分别返回一个小于零,等于零,或大于零的整数。只有键名相等,对应的键值才会传给此自定义函数比较。
$user_key_compare_func用户自定义回调函数,用来比较键名。如果认为第一个键名小于,等于,或大于第二个键名时必须分别返回一个小于零,等于零,或大于零的整数。
 
四、返回值:
返回一个数组,该数组包含了参数中所有数组共同的键名/键值对。

五、用法举例:
1、两个数组的键名/键值对的交集:
  键名和键值的比较都使用自定义函数。
<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("debug key: %s vs %s %s\n", $k1, $k2, $k1===$k2 ? 0 : ($k1>$k2?1:-1) ); //debug行
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}

function user_value_compare_func($v1, $v2) {
echo sprintf("debug value: %s vs %s %s\n", $v1, $v2, $v1===$v2 ? 0 : ($v1>$v2?1:-1) ); //debug行
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}

$arr1 = array("name"=>'爱E族', "type"=>"domaim");
$arr2 = array("name"=>'爱E族', "type"=>'string');

$result = array_uintersect_uassoc($arr1, $arr2, "user_value_compare_func", "user_key_compare_func");
print_r($result);
输出:
debug key: type vs name 1   #$arr1键名的排序去重
debug key: type vs name 1 #$arr2键名的排序去重

debug key: name vs name 0 #键名相等、下步将比较键值是否相等
debug value: 爱E族 vs 爱E族 0 #键值也相等,将在返回数组中返回
debug key: type vs type 0 #键名相等、下步将比较键值是否相等
debug value: domaim vs string -1 #键值不相等,不会在返回数组中返回
Array
(
[name] => 爱E族
)
 
2、比较三个数组中共同的键名/键值对:
  找出三个数组的共同的键名/键值对,键名和键值的比较都使用自定义函数。
<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array("name"=>'爱E族', "type"=>"domaim", 'en'=>'aiezu');
$arr2 = array("name"=>'爱E族', "type"=>'string', 'en'=>'aiezu');
$arr3 = array('name'=>'爱E族', 'type'=>'string');
print_r(array_uintersect_uassoc($arr1, $arr2, $arr3, array('user', 'value_compare'), array('user', 'key_compare')));
输出:
Array
(
[name] => 爱E族
)
 

PHP array_uintersect_assoc 函数

PHPllslx520 发表了文章 • 0 个评论 • 48 次浏览 • 2016-11-13 12:17 • 来自相关话题

一、函数功能:
  计算多个数组共同的键名/键值交集(同时考虑键名和键值,键值的比较使用自定义函数)。PHP 5.0起才支持此函数。关于计算数组交集系列函数的区别请参考:PHP数组计算交集系列函数的区别。

二、函数语法:array array_uintersect_assoc($array1, $array2 [, $...], $user_value_compare_func )
三、函数参数:参数名描述$array1参与比较的第一个数组;$array2参与比较的第二个数组;...参与比较的更多数组;$user_value_compare_func用户自定义回调函数,用来比较键值。如果认为第一个键值小于,等于,或大于第二个键值时必须分别返回一个小于零,等于零,或大于零的整数。 
四、返回值:返回一个数组,该数组包含了参数中所有数组共同的键名/键值对。
五、用法举例:
1、两个数组的键名/键值对的交集(使用自定义函数比较键值):<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug value: %s vs %s %s\n", $v1, $v2, $v1===$v2 ? 0 : ($v1>$v2?1:-1) ); //debug行
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}

$arr1 = array("name"=>'爱E族', "type"=>"domaim");
$arr2 = array("name"=>'爱E族', "type"=>'string');
$result = array_uintersect_assoc($arr1, $arr2, "user_value_compare_func");
print_r($result);输出:debug value: 爱E族 vs 爱E族 0 #两个数组的键名name相等,且对应的键值也相等,将在返回数组中返回
debug value: domaim vs string -1 #两个数组的键名type相等,但对应的键值不相等,不会在返回数组中返回
Array
(
[name] => 爱E族

2、三个数组键名/键值对的交集:
  使用类中的自定义函数比较三个数组键名/键值对的交集,对应键值的比较使用自定义函数。<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array("name"=>'爱E族', "en"=>"aiezu", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'en'=>'aiezu', "type"=>'string');
$arr3 = array("name"=>'china', "en"=>'aiezu');

$result = array_uintersect_assoc($arr1, $arr2, $arr3, array('user', 'value_compare'));
print_r($result);输出:Array
(
[en] => aiezu
) 查看全部
一、函数功能:
  计算多个数组共同的键名/键值交集(同时考虑键名和键值,键值的比较使用自定义函数)。PHP 5.0起才支持此函数。关于计算数组交集系列函数的区别请参考:PHP数组计算交集系列函数的区别

二、函数语法:
array array_uintersect_assoc($array1, $array2 [, $...], $user_value_compare_func )

三、函数参数:
参数名描述
$array1参与比较的第一个数组;
$array2参与比较的第二个数组;
...参与比较的更多数组;
$user_value_compare_func用户自定义回调函数,用来比较键值。如果认为第一个键值小于,等于,或大于第二个键值时必须分别返回一个小于零,等于零,或大于零的整数。
 
四、返回值:
返回一个数组,该数组包含了参数中所有数组共同的键名/键值对。

五、用法举例:
1、两个数组的键名/键值对的交集(使用自定义函数比较键值):
<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug value: %s vs %s %s\n", $v1, $v2, $v1===$v2 ? 0 : ($v1>$v2?1:-1) ); //debug行
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}

$arr1 = array("name"=>'爱E族', "type"=>"domaim");
$arr2 = array("name"=>'爱E族', "type"=>'string');
$result = array_uintersect_assoc($arr1, $arr2, "user_value_compare_func");
print_r($result);
输出:
debug value: 爱E族 vs 爱E族 0  #两个数组的键名name相等,且对应的键值也相等,将在返回数组中返回
debug value: domaim vs string -1 #两个数组的键名type相等,但对应的键值不相等,不会在返回数组中返回
Array
(
[name] => 爱E族
)
 
2、三个数组键名/键值对的交集:
  使用类中的自定义函数比较三个数组键名/键值对的交集,对应键值的比较使用自定义函数。
<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array("name"=>'爱E族', "en"=>"aiezu", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'en'=>'aiezu', "type"=>'string');
$arr3 = array("name"=>'china', "en"=>'aiezu');

$result = array_uintersect_assoc($arr1, $arr2, $arr3, array('user', 'value_compare'));
print_r($result);
输出:
Array
(
[en] => aiezu
)

PHP array_intersect_ukey 函数

PHPllslx520 发表了文章 • 0 个评论 • 40 次浏览 • 2016-11-13 12:07 • 来自相关话题

一、函数功能:
  计算多个数组共同的键名交集(只考虑键名,不考虑键值,使用自定义函数比较键名是否完全相等)。数组的键值不参与比较,但返回数组中保留键名对应的键值不变。PHP 5.1起才支持此函数。关于计算数组交集系列函数的区别请参考:PHP数组计算交集系列函数的区别。

二、函数语法:array array_intersect_ukey($array1, $array2 [, $...], $user_key_compare_func ) 
三、函数参数:参数名描述$array1参与比较的第一个数组;$array2参与比较的第二个数组;...参与比较的更多数组;$user_key_compare_func用户自定义回调函数,用来比较键名。如果认为第一个键名小于,等于,或大于第二个键名时必须分别返回一个小于零,等于零,或大于零的整数。  
四、返回值:返回一个数组,该数组包含了参数中所有数组共同的键名及其对应的键值。
五、用法举例:
1、两个数组的键名交集(使用自定义函数):<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("debug key: %s vs %s %s\n", $k1, $k2, $k1===$k2 ? 0 : ($k1>$k2?1:-1) ); //debug行
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}

$arr1 = array("name"=>'aiezu', "suffix"=>"com", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'suffix'=>'', "en"=>'aiezu');

$result = array_intersect_ukey($arr1, $arr2, "user_key_compare_func");
print_r($result);输出:debug key: suffix vs name 1 #$arr1键名的排序去重
debug key: type vs suffix 1
debug key: suffix vs name 1 #$arr2键名的排序去重
debug key: en vs suffix -1

debug key: name vs en 1
debug key: name vs en 1
debug key: name vs name 0 #键名相等,会出现在返回数组中
debug key: suffix vs suffix 0 #键名相等,会出现在返回数组中
Array
(
[name] => aiezu
[suffix] => com

2、使用自定义类函数、找出三个数组的共同的键名交集:<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("name"=>'aiezu', "suffix"=>"com", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'suffix'=>'', "en"=>'aiezu');
$arr3 = array("name"=>'china', "en"=>'aiezu');

$result = array_intersect_ukey($arr1, $arr2, $arr3, array('user', 'key_compare'));
print_r($result);输出:Array
(
[name] => aiezu
) 查看全部
一、函数功能:
  计算多个数组共同的键名交集(只考虑键名,不考虑键值,使用自定义函数比较键名是否完全相等)。数组的键值不参与比较,但返回数组中保留键名对应的键值不变。PHP 5.1起才支持此函数。关于计算数组交集系列函数的区别请参考:PHP数组计算交集系列函数的区别

二、函数语法:
array array_intersect_ukey($array1,  $array2 [, $...], $user_key_compare_func )
 
三、函数参数:
参数名描述
$array1参与比较的第一个数组;
$array2参与比较的第二个数组;
...参与比较的更多数组;
$user_key_compare_func用户自定义回调函数,用来比较键名。如果认为第一个键名小于,等于,或大于第二个键名时必须分别返回一个小于零,等于零,或大于零的整数。
  
四、返回值:
返回一个数组,该数组包含了参数中所有数组共同的键名及其对应的键值。

五、用法举例:
1、两个数组的键名交集(使用自定义函数):
<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("debug key: %s vs %s %s\n", $k1, $k2, $k1===$k2 ? 0 : ($k1>$k2?1:-1) ); //debug行
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}

$arr1 = array("name"=>'aiezu', "suffix"=>"com", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'suffix'=>'', "en"=>'aiezu');

$result = array_intersect_ukey($arr1, $arr2, "user_key_compare_func");
print_r($result);
输出:
debug key: suffix vs name 1  #$arr1键名的排序去重
debug key: type vs suffix 1
debug key: suffix vs name 1 #$arr2键名的排序去重
debug key: en vs suffix -1

debug key: name vs en 1
debug key: name vs en 1
debug key: name vs name 0 #键名相等,会出现在返回数组中
debug key: suffix vs suffix 0 #键名相等,会出现在返回数组中
Array
(
[name] => aiezu
[suffix] => com
)
 
2、使用自定义类函数、找出三个数组的共同的键名交集:
<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("name"=>'aiezu', "suffix"=>"com", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'suffix'=>'', "en"=>'aiezu');
$arr3 = array("name"=>'china', "en"=>'aiezu');

$result = array_intersect_ukey($arr1, $arr2, $arr3, array('user', 'key_compare'));
print_r($result);
输出:
Array
(
[name] => aiezu
)

PHP array_intersect_key 函数

PHPllslx520 发表了文章 • 0 个评论 • 50 次浏览 • 2016-11-13 11:58 • 来自相关话题

一、函数功能:
  计算多个数组共同的键名交集(只考虑键名,不考虑键值)。数组的键值不参与比较,但返回数组中保留键名对应的键值不变。PHP 5.1起才支持此函数。关于计算数组交集系列函数的区别请参考:PHP数组计算交集系列函数的区别。

二、函数语法:array array_intersect_key ( $array1, $array2 [, $... ] ) 
三、函数参数:参数名描述$array1参与比较的第一个数组;$array2参与比较的第二个数组;...参与比较的更多数组。 
四、返回值:返回一个数组,该数组包含了参数中所有数组共同的键名及其对应的键值。
五、用法举例:
1、两个数组的键名交集:<?php
$arr1 = array("name"=>'aiezu', "suffix"=>"com", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'suffix'=>'', "en"=>'aiezu');
$result = array_intersect_key($arr1, $arr2);
print_r($result);输出:Array
(
[name] => aiezu
[suffix] => com

2、三个数组的键名交集:<?php
$arr1 = array("name"=>'aiezu', "suffix"=>"com", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'suffix'=>'', "en"=>'aiezu');
$arr3 = array("name"=>'');
$result = array_intersect_key($arr1, $arr2, $arr3);
print_r($result);输出:Array
(
[name] => aiezu
) 查看全部
一、函数功能:
  计算多个数组共同的键名交集(只考虑键名,不考虑键值)。数组的键值不参与比较,但返回数组中保留键名对应的键值不变。PHP 5.1起才支持此函数。关于计算数组交集系列函数的区别请参考:PHP数组计算交集系列函数的区别

二、函数语法:
array array_intersect_key ( $array1, $array2 [, $... ] )
 
三、函数参数:
参数名描述
$array1参与比较的第一个数组;
$array2参与比较的第二个数组;
...参与比较的更多数组。
 
四、返回值:
返回一个数组,该数组包含了参数中所有数组共同的键名及其对应的键值。

五、用法举例:
1、两个数组的键名交集:
<?php
$arr1 = array("name"=>'aiezu', "suffix"=>"com", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'suffix'=>'', "en"=>'aiezu');
$result = array_intersect_key($arr1, $arr2);
print_r($result);
输出:
Array
(
[name] => aiezu
[suffix] => com
)
 
2、三个数组的键名交集:
<?php
$arr1 = array("name"=>'aiezu', "suffix"=>"com", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'suffix'=>'', "en"=>'aiezu');
$arr3 = array("name"=>'');
$result = array_intersect_key($arr1, $arr2, $arr3);
print_r($result);
输出:
Array
(
[name] => aiezu
)

PHP array_intersect_uassoc 函数

PHPllslx520 发表了文章 • 0 个评论 • 44 次浏览 • 2016-11-13 11:51 • 来自相关话题

一、函数功能:
  计算多个数组共同的键名/键值交集(同时考虑键名和键值,键名的比较使用自定义函数)。PHP 5.0起才支持此函数。关于计算数组交集系列函数的区别请参考:PHP数组计算交集系列函数的区别。

二、函数语法:array array_intersect_uassoc($array1, $array2[, $... ], $user_key_compare_func)
三、函数参数:参数名描述$array1参与比较的第一个数组;$array2参与比较的第二个数组;...参与比较的更多数组;$user_key_compare_func用户自定义回调函数,用来比较键名。如果认为第一个键名小于,等于,或大于第二个键名时必须分别返回一个小于零,等于零,或大于零的整数。 
四、返回值:返回一个数组,该数组包含了参数中所有数组共同的键名/键值对。 
五、用法举例:
1、两个数组的键名/键值交集(使用自定义函数比较键名):<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("debug key: %s vs %s %s\n", $k1, $k2, $k1===$k2 ? 0 : ($k1>$k2?1:-1) ); //debug行
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}

$arr1 = array("name"=>'爱E族', "type"=>"domaim");
$arr2 = array("name"=>'爱E族', "type"=>'string');

$result = array_intersect_uassoc($arr1, $arr2, "user_key_compare_func");
print_r($result);输出:debug key: type vs name 1 #$arr1键名排序出重
debug key: type vs name 1 #$arr2键名排序出重

debug key: name vs name 0 #键名相等,键名对应的键值也相等,将在返回数组中返回
debug key: type vs type 0 #键名相等,但键名对应的键值不相等,不会在返回数组中返回
Array
(
[name] => 爱E族

2、使用类函数作为键名比较函数,找出三个数组共同交集:<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("name"=>'爱E族', "en"=>"aiezu", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'en'=>'aiezu', "type"=>'string');
$arr3 = array("name"=>'china', "en"=>'aiezu');

$result = array_intersect_uassoc($arr1, $arr2, $arr3, array('user', 'key_compare'));
print_r($result);输出:Array
(
[en] => aiezu
) 查看全部
一、函数功能:
  计算多个数组共同的键名/键值交集(同时考虑键名和键值,键名的比较使用自定义函数)。PHP 5.0起才支持此函数。关于计算数组交集系列函数的区别请参考:PHP数组计算交集系列函数的区别

二、函数语法:
array array_intersect_uassoc($array1, $array2[, $... ], $user_key_compare_func)

三、函数参数:
参数名描述
$array1参与比较的第一个数组;
$array2参与比较的第二个数组;
...参与比较的更多数组;
$user_key_compare_func用户自定义回调函数,用来比较键名。如果认为第一个键名小于,等于,或大于第二个键名时必须分别返回一个小于零,等于零,或大于零的整数。
 
四、返回值:
返回一个数组,该数组包含了参数中所有数组共同的键名/键值对。
 
五、用法举例:
1、两个数组的键名/键值交集(使用自定义函数比较键名):
<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("debug key: %s vs %s %s\n", $k1, $k2, $k1===$k2 ? 0 : ($k1>$k2?1:-1) ); //debug行
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}

$arr1 = array("name"=>'爱E族', "type"=>"domaim");
$arr2 = array("name"=>'爱E族', "type"=>'string');

$result = array_intersect_uassoc($arr1, $arr2, "user_key_compare_func");
print_r($result);
输出:
debug key: type vs name 1  #$arr1键名排序出重
debug key: type vs name 1 #$arr2键名排序出重

debug key: name vs name 0 #键名相等,键名对应的键值也相等,将在返回数组中返回
debug key: type vs type 0 #键名相等,但键名对应的键值不相等,不会在返回数组中返回
Array
(
[name] => 爱E族
)
 
2、使用类函数作为键名比较函数,找出三个数组共同交集:
<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("name"=>'爱E族', "en"=>"aiezu", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'en'=>'aiezu', "type"=>'string');
$arr3 = array("name"=>'china', "en"=>'aiezu');

$result = array_intersect_uassoc($arr1, $arr2, $arr3, array('user', 'key_compare'));
print_r($result);
输出:
Array
(
[en] => aiezu
)

PHP array_intersect_assoc 函数

PHPllslx520 发表了文章 • 0 个评论 • 49 次浏览 • 2016-11-13 11:43 • 来自相关话题

一、函数功能:
  计算多个数组共同的键名/键值交集(同时考虑键名和键值)。关于计算数组交集系列函数的区别请参考:PHP数组计算交集系列函数的区别。

二、函数语法:array array_intersect_assoc ( $array1, $array2 [, $ ... ] )
三、函数参数:参数名描述$array1参与比较的第一个数组;$array2参与比较的第二个数组;...参与比较的更多数组; 
四、返回值:返回一个数组,该数组包含了参数中所有数组共同的键名/键值对。
五、用法举例:
1、两个数组共同的键名/键值对:<?php
$arr1 = array("name"=>'爱E族', "en"=>"aiezu", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'en'=>'aiezu', "suffix"=>'aiezu');
$result = array_intersect_assoc($arr1, $arr2);
print_r($result);输出:Array
(
[name] => 爱E族
[en] => aiezu

2、三个数组共同的键名/键值对:<?php
$arr1 = array("name"=>'爱E族', "en"=>"aiezu", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'en'=>'aiezu', "suffix"=>'com');
$arr3 = array("suffix"=>'com', "name"=>'爱E族');
$result = array_intersect_assoc($arr1, $arr2, $arr3);
print_r($result);输出:Array
(
[name] => 爱E族
) 查看全部
一、函数功能:
  计算多个数组共同的键名/键值交集(同时考虑键名和键值)。关于计算数组交集系列函数的区别请参考:PHP数组计算交集系列函数的区别

二、函数语法:
array array_intersect_assoc ( $array1, $array2 [, $ ... ] )

三、函数参数:
参数名描述
$array1参与比较的第一个数组;
$array2参与比较的第二个数组;
...参与比较的更多数组;
 
四、返回值:
返回一个数组,该数组包含了参数中所有数组共同的键名/键值对。

五、用法举例:
1、两个数组共同的键名/键值对:
<?php
$arr1 = array("name"=>'爱E族', "en"=>"aiezu", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'en'=>'aiezu', "suffix"=>'aiezu');
$result = array_intersect_assoc($arr1, $arr2);
print_r($result);
输出:
Array
(
[name] => 爱E族
[en] => aiezu
)
 
2、三个数组共同的键名/键值对:
<?php
$arr1 = array("name"=>'爱E族', "en"=>"aiezu", "type"=>"domaim");
$arr2 = array("name"=>'爱E族', 'en'=>'aiezu', "suffix"=>'com');
$arr3 = array("suffix"=>'com', "name"=>'爱E族');
$result = array_intersect_assoc($arr1, $arr2, $arr3);
print_r($result);
输出:
Array
(
[name] => 爱E族
)

PHP array_uintersect 函数

PHPllslx520 发表了文章 • 0 个评论 • 40 次浏览 • 2016-11-13 11:30 • 来自相关话题

一、函数功能:
  计算多个数组共同的键值交集(只考虑键值,不考虑键名,键值的比较使用自定义函数)。数组的键名不参与比较,但返回数组中保留键值对应的键名不变。PHP 5.0起才支持此函数。关于计算数组交集系列函数的区别请参考:PHP数组计算交集系列函数的区别。

二、函数语法:array array_uintersect ($array1, $array2 [, $...], function $user_value_compare_func ) 
三、函数参数:参数名描述$array1参与比较的第一个数组;$array2参与比较的第二个数组;...参与比较的更多数组;$user_value_compare_func用户自定义回调函数,用来比较键值。如果认为第一个键值小于,等于,或大于第二个键值时必须分别返回一个小于零,等于零,或大于零的整数。 
四、返回值:返回一个数组,该数组包含了参数中所有数组共同的键值。 
五、用法举例:
1、计算两个数组的键值交集(使用自定义函数):<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug value: %s vs %s %s\n", $v1, $v2, $v1===$v2 ? 0 : ($v1>$v2?1:-1) ); //debug行
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}

$arr1 = array('爱E族', 'en'=>'aiezu');
$arr2 = array('name'=>'爱E族', 'domain');
$result = array_uintersect($arr1, $arr2, "user_value_compare_func");
print_r($result);输出:debug value: aiezu vs 爱E族 -1
debug value: domain vs 爱E族 -1
debug value: aiezu vs domain -1
debug value: 爱E族 vs domain 1
debug value: 爱E族 vs domain 1
debug value: 爱E族 vs 爱E族 0
Array
(
[0] => 爱E族

2、使用自定义类函数、找出三个数组的共同的键值交集:<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}

$arr1 = array('name'=>'爱E族', 'en'=>'aiezu');
$arr2 = array('爱E族', 'aiezu', 'domain');
$arr3 = array('aiezu', 'domain');
$result = array_uintersect($arr1, $arr2, $arr3, array('user', 'value_compare'));
print_r($result);输出:Array
(
[en] => aiezu
) 查看全部
一、函数功能:
  计算多个数组共同的键值交集(只考虑键值,不考虑键名,键值的比较使用自定义函数)。数组的键名不参与比较,但返回数组中保留键值对应的键名不变。PHP 5.0起才支持此函数。关于计算数组交集系列函数的区别请参考:PHP数组计算交集系列函数的区别

二、函数语法:
array array_uintersect ($array1, $array2 [, $...], function $user_value_compare_func )
 
三、函数参数:
参数名描述
$array1参与比较的第一个数组;
$array2参与比较的第二个数组;
...参与比较的更多数组;
$user_value_compare_func用户自定义回调函数,用来比较键值。如果认为第一个键值小于,等于,或大于第二个键值时必须分别返回一个小于零,等于零,或大于零的整数。
 
四、返回值:
返回一个数组,该数组包含了参数中所有数组共同的键值。
 
五、用法举例:
1、计算两个数组的键值交集(使用自定义函数):
<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug value: %s vs %s %s\n", $v1, $v2, $v1===$v2 ? 0 : ($v1>$v2?1:-1) ); //debug行
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}

$arr1 = array('爱E族', 'en'=>'aiezu');
$arr2 = array('name'=>'爱E族', 'domain');
$result = array_uintersect($arr1, $arr2, "user_value_compare_func");
print_r($result);
输出:
debug value: aiezu vs 爱E族 -1
debug value: domain vs 爱E族 -1
debug value: aiezu vs domain -1
debug value: 爱E族 vs domain 1
debug value: 爱E族 vs domain 1
debug value: 爱E族 vs 爱E族 0
Array
(
[0] => 爱E族
)
 
2、使用自定义类函数、找出三个数组的共同的键值交集:
<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}

$arr1 = array('name'=>'爱E族', 'en'=>'aiezu');
$arr2 = array('爱E族', 'aiezu', 'domain');
$arr3 = array('aiezu', 'domain');
$result = array_uintersect($arr1, $arr2, $arr3, array('user', 'value_compare'));
print_r($result);
输出:
Array
(
[en] => aiezu
)

PHP array_intersect 函数

PHPllslx520 发表了文章 • 0 个评论 • 57 次浏览 • 2016-11-13 11:16 • 来自相关话题

一、函数功能:
  计算多个数组共同的键值交集(只考虑键值,不考虑键名)。数组的键名不参与比较,但返回数组中保留键值对应的键名不变。关于计算数组交集系列函数的区别请参考:http://aiezu.com/article/php_array_intersect_sets.html。

二、函数语法:array array_intersect ( $array1 , $array2 [, $... ] )
三、函数参数:参数名描述$array1参与比较的第一个数组;$array2参与比较的第二个数组;...参与比较的更多数组。
四、返回值:返回一个数组,该数组包含了参数中所有数组共同的键值。
五、用法举例:
1、两个数组的比较:
  比较时忽视key,返回结果中保留键名:<?php
$arr1 = array('aa', 'z'=>'aiezu.com', 'cc');
$arr2 = array('a'=>'aa', 'aiezu.com', 'c');
print_r(array_intersect($arr1, $arr2));输出:Array
(
[0] => aa
[z] => aiezu.com

2、三个数组的比较:
  只会返回第一个数组中,同时出现在其他所有数组中的键值。<?php
$arr1 = array('aa', 'b'=>'aiezu.com', 'cc');
$arr2 = array('a'=>'aa', 'aiezu.com', 'c');
$arr3 = array('cc', '爱E族', 'aa');
print_r(array_intersect($arr1, $arr2, $arr3));输出:Array
(
[0] => aa

3、array_intersect是将数组值强制转换为"string"后进行"==="(全等于)比较:
  由于false强制转换为string后为"",数组强制转换为string后为"Array",所以下面例子运行结果返回$arr1的所有键值。<?php
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_intersect($arr1, $arr2));输出:Array
(
[0] =>
[1] => Array
(
[0] => 1
)
) 查看全部
一、函数功能:
  计算多个数组共同的键值交集(只考虑键值,不考虑键名)。数组的键名不参与比较,但返回数组中保留键值对应的键名不变。关于计算数组交集系列函数的区别请参考:http://aiezu.com/article/php_array_intersect_sets.html

二、函数语法:
array array_intersect ( $array1 , $array2 [, $... ] )

三、函数参数:
参数名描述
$array1参与比较的第一个数组;
$array2参与比较的第二个数组;
...参与比较的更多数组。

四、返回值:
返回一个数组,该数组包含了参数中所有数组共同的键值。

五、用法举例:
1、两个数组的比较:
  比较时忽视key,返回结果中保留键名:
<?php
$arr1 = array('aa', 'z'=>'aiezu.com', 'cc');
$arr2 = array('a'=>'aa', 'aiezu.com', 'c');
print_r(array_intersect($arr1, $arr2));
输出:
Array
(
[0] => aa
[z] => aiezu.com
)
 
2、三个数组的比较:
  只会返回第一个数组中,同时出现在其他所有数组中的键值。
<?php
$arr1 = array('aa', 'b'=>'aiezu.com', 'cc');
$arr2 = array('a'=>'aa', 'aiezu.com', 'c');
$arr3 = array('cc', '爱E族', 'aa');
print_r(array_intersect($arr1, $arr2, $arr3));
输出:
Array
(
[0] => aa
)
 
3、array_intersect是将数组值强制转换为"string"后进行"==="(全等于)比较:
  由于false强制转换为string后为"",数组强制转换为string后为"Array",所以下面例子运行结果返回$arr1的所有键值。
<?php
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_intersect($arr1, $arr2));
输出:
Array
(
[0] =>
[1] => Array
(
[0] => 1
)
)

PHP数组计算交集系列函数的区别

PHPllslx520 发表了文章 • 0 个评论 • 65 次浏览 • 2016-11-13 10:31 • 来自相关话题

一、函数介绍:
  PHP数组交集计算函数,用来计算多个数组元素的共同交集。计算类型分为计算键名的交集、计算键值的交集、计算键名/值对的交集三类;计算方式分为系统默认函数计算和使用用户自定义函数计算两种。PHP数组交集计算函数共有8个。计算键名的交集:计算多个数组共同的键名交集(不考虑键值),返回时键名对应的键值保持不变一起返回。计算键名的交集函数有:array_intersect_key(),array_intersect_ukey()。计算键值的交集:计算多个数组共同的键值交集(不考虑键名),返回时键值对应的键名保持不变一起返回。计算键值的交集函数有:array_intersect(),array_uintersect()。计算键名/值对的交集:计算多个数组共同的键名/键值交集(同时考虑键名和键值)。计算键名/键值对的交集函数有:array_intersect_assoc(),array_uintersect_assoc(),array_intersect_uassoc(),array_uintersect_uassoc()。
 
数组交集比较函数功能差异表:函数名计算何种交集键名比较函数键值比较函数array_intersect()键值的交集,不考虑键名->系统默认array_uintersect()键值的交集,不考虑键名-自定义函数array_intersect_assoc()键名和键值的交集系统默认系统默认array_intersect_uassoc()键名和键值的交集自定义函数系统默认array_intersect_key()键名的交集,不考虑键值系统默认-array_intersect_ukey()键名的交集,不考虑键值自定义函数-array_uintersect_assoc()键名和键值的交集系统默认自定义函数array_uintersect_uassoc()键名和键值的交集自定义函数自定义函数 PHP数组计算差集系列函数的区别:http://aiezu.com/article/php_array_diff_sets.html
 
二、参数中的自定义比较函数:
  交集比较函数通过比较键名、键值是否想等,来判断是否是相同的键名、键值。只有同时出现所有数组中的键名、键值才会在返回数组中返回。为了方便大家实现个性化的需求,PHP为部分函数提供了接口,可以使用自定义函数来比较键名、键值是否相等。PHP会传递两个键名给键名自定义比较函数、或者两个键值给自定义键值比较函数,用户可以在自定义比较函数中根据自己的需求进行比较,只需给自定义函数一个整型返回值就行(返回0认为键名或键值相等)。
 
自定义比较函数演示:
1、使用基础函数方式:<?php
//爱E族 aiezu.com
#键名比较函数
function user_key_compare_func($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
#键值比较函数
function user_value_compare_func($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}用法:<?php
array_intersect_ukey($arr1, $arr2, 'user_key_compare_func');
array_uintersect($arr1, $arr2, 'user_value_compare_func');
array_uintersect_uassoc($arr1, $arr2, 'user_value_compare_func', 'user_key_compare_func');
array_uintersect_uassoc($arr1, $arr2, $arr3, 'user_value_compare_func', 'user_key_compare_func'); 
2、使用类的函数方式:<?php
//爱E族:aiezu.com
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}用法:<?php
array_intersect_ukey($arr1, $arr2, array('user', 'key_compare'));
array_uintersect($arr1, $arr2, array('user', 'value_compare'));
array_uintersect_uassoc($arr1, $arr2, array('user', 'value_compare'), array('user', 'key_compare'));
三、用法演示:
1、使用基础自定义函数,作为比较函数完整代码:<?php
function user_key_compare_func($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}

function user_value_compare_func($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}

$arr1 = array("name"=>'爱E族', "en"=>"aiezu", "type"=>"com");
$arr2 = array("name"=>'爱E族', 'en'=>'string', "suffix"=>'com');

print_r(array_intersect_ukey($arr1, $arr2, 'user_key_compare_func'));
print_r(array_uintersect($arr1, $arr2, 'user_value_compare_func'));
print_r(array_uintersect_uassoc($arr1, $arr2, 'user_value_compare_func', 'user_key_compare_func'));输出:Array
(
[name] => 爱E族
[en] => aiezu
)
Array
(
[name] => 爱E族
[type] => com
)
Array
(
[name] => 爱E族

2、使用类函数作为比较函数完整代码:<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}


$arr1 = array("name"=>'爱E族', "en"=>"aiezu", "type"=>"com");
$arr2 = array("name"=>'爱E族', 'en'=>'string', "suffix"=>'com');

print_r(array_intersect_ukey($arr1, $arr2, array('user', 'key_compare')));
print_r(array_uintersect($arr1, $arr2, array('user', 'key_compare')));
print_r(array_uintersect_uassoc($arr1, $arr2, array('user', 'value_compare'), array('user', 'key_compare')));输出:Array
(
[name] => 爱E族
[en] => aiezu
)
Array
(
[name] => 爱E族
[type] => com
)
Array
(
[name] => 爱E族
)
3、交集比较函数的工作流程测试:
  这里以array_uintersect_uassoc()函数举例解析交集比较函数的工作流程,array_uintersect_uassoc()用来计算多个数组共同的键名/键值交集(同时考虑键名和键值,键名、键值的比较都使用自定义函数)<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("debug key: %s vs %s %s\n", $k1, $k2, $k1===$k2 ? 0 : ($k1>$k2?1:-1) ); //debug行
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}

function user_value_compare_func($v1, $v2) {
echo sprintf("debug value: %s vs %s %s\n", $v1, $v2, $v1===$v2 ? 0 : ($v1>$v2?1:-1) ); //debug行
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}

$arr1 = array("name"=>'爱E族', "type"=>"domaim");
$arr2 = array("name"=>'爱E族', "type"=>'string');

$result = array_uintersect_uassoc($arr1, $arr2, "user_value_compare_func", "user_key_compare_func");
print_r($result);输出:debug key: type vs name 1 #$arr1键名的排序去重
debug key: type vs name 1 #$arr2键名的排序去重

debug key: name vs name 0 #键名相等、下步将比较键值是否相等
debug value: 爱E族 vs 爱E族 0 #键值也相等,将在返回数组中返回
debug key: type vs type 0 #键名相等、下步将比较键值是否相等
debug value: domaim vs string -1 #键值不相等,不会在返回数组中返回
Array
(
[name] => 爱E族
) 查看全部
一、函数介绍:
  PHP数组交集计算函数,用来计算多个数组元素的共同交集。计算类型分为计算键名的交集、计算键值的交集、计算键名/值对的交集三类;计算方式分为系统默认函数计算和使用用户自定义函数计算两种。PHP数组交集计算函数共有8个。
  • 计算键名的交集:计算多个数组共同的键名交集(不考虑键值),返回时键名对应的键值保持不变一起返回。计算键名的交集函数有:array_intersect_key(),array_intersect_ukey()。
  • 计算键值的交集:计算多个数组共同的键值交集(不考虑键名),返回时键值对应的键名保持不变一起返回。计算键值的交集函数有:array_intersect(),array_uintersect()。
  • 计算键名/值对的交集:计算多个数组共同的键名/键值交集(同时考虑键名和键值)。计算键名/键值对的交集函数有:array_intersect_assoc(),array_uintersect_assoc(),array_intersect_uassoc(),array_uintersect_uassoc()。

 
数组交集比较函数功能差异表:
函数名计算何种交集键名比较函数键值比较函数
array_intersect()键值的交集,不考虑键名->系统默认
array_uintersect()键值的交集,不考虑键名-自定义函数
array_intersect_assoc()键名和键值的交集系统默认系统默认
array_intersect_uassoc()键名和键值的交集自定义函数系统默认
array_intersect_key()键名的交集,不考虑键值系统默认-
array_intersect_ukey()键名的交集,不考虑键值自定义函数-
array_uintersect_assoc()键名和键值的交集系统默认自定义函数
array_uintersect_uassoc()键名和键值的交集自定义函数自定义函数
 PHP数组计算差集系列函数的区别:http://aiezu.com/article/php_array_diff_sets.html
 
二、参数中的自定义比较函数:
  交集比较函数通过比较键名、键值是否想等,来判断是否是相同的键名、键值。只有同时出现所有数组中的键名、键值才会在返回数组中返回。为了方便大家实现个性化的需求,PHP为部分函数提供了接口,可以使用自定义函数来比较键名、键值是否相等。PHP会传递两个键名给键名自定义比较函数、或者两个键值给自定义键值比较函数,用户可以在自定义比较函数中根据自己的需求进行比较,只需给自定义函数一个整型返回值就行(返回0认为键名或键值相等)。
 
自定义比较函数演示:
1、使用基础函数方式:
<?php
//爱E族 aiezu.com
#键名比较函数
function user_key_compare_func($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
#键值比较函数
function user_value_compare_func($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
用法:
<?php
array_intersect_ukey($arr1, $arr2, 'user_key_compare_func');
array_uintersect($arr1, $arr2, 'user_value_compare_func');
array_uintersect_uassoc($arr1, $arr2, 'user_value_compare_func', 'user_key_compare_func');
array_uintersect_uassoc($arr1, $arr2, $arr3, 'user_value_compare_func', 'user_key_compare_func');
 
2、使用类的函数方式:
<?php
//爱E族:aiezu.com
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
用法:
<?php
array_intersect_ukey($arr1, $arr2, array('user', 'key_compare'));
array_uintersect($arr1, $arr2, array('user', 'value_compare'));
array_uintersect_uassoc($arr1, $arr2, array('user', 'value_compare'), array('user', 'key_compare'));

三、用法演示:
1、使用基础自定义函数,作为比较函数完整代码:
<?php
function user_key_compare_func($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}

function user_value_compare_func($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}

$arr1 = array("name"=>'爱E族', "en"=>"aiezu", "type"=>"com");
$arr2 = array("name"=>'爱E族', 'en'=>'string', "suffix"=>'com');

print_r(array_intersect_ukey($arr1, $arr2, 'user_key_compare_func'));
print_r(array_uintersect($arr1, $arr2, 'user_value_compare_func'));
print_r(array_uintersect_uassoc($arr1, $arr2, 'user_value_compare_func', 'user_key_compare_func'));
输出:
Array
(
[name] => 爱E族
[en] => aiezu
)
Array
(
[name] => 爱E族
[type] => com
)
Array
(
[name] => 爱E族
)
 
2、使用类函数作为比较函数完整代码:
<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}


$arr1 = array("name"=>'爱E族', "en"=>"aiezu", "type"=>"com");
$arr2 = array("name"=>'爱E族', 'en'=>'string', "suffix"=>'com');

print_r(array_intersect_ukey($arr1, $arr2, array('user', 'key_compare')));
print_r(array_uintersect($arr1, $arr2, array('user', 'key_compare')));
print_r(array_uintersect_uassoc($arr1, $arr2, array('user', 'value_compare'), array('user', 'key_compare')));
输出:
Array
(
[name] => 爱E族
[en] => aiezu
)
Array
(
[name] => 爱E族
[type] => com
)
Array
(
[name] => 爱E族
)

3、交集比较函数的工作流程测试:
  这里以array_uintersect_uassoc()函数举例解析交集比较函数的工作流程,array_uintersect_uassoc()用来计算多个数组共同的键名/键值交集(同时考虑键名和键值,键名、键值的比较都使用自定义函数)
<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("debug key: %s vs %s %s\n", $k1, $k2, $k1===$k2 ? 0 : ($k1>$k2?1:-1) ); //debug行
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}

function user_value_compare_func($v1, $v2) {
echo sprintf("debug value: %s vs %s %s\n", $v1, $v2, $v1===$v2 ? 0 : ($v1>$v2?1:-1) ); //debug行
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}

$arr1 = array("name"=>'爱E族', "type"=>"domaim");
$arr2 = array("name"=>'爱E族', "type"=>'string');

$result = array_uintersect_uassoc($arr1, $arr2, "user_value_compare_func", "user_key_compare_func");
print_r($result);
输出:
debug key: type vs name 1   #$arr1键名的排序去重
debug key: type vs name 1 #$arr2键名的排序去重

debug key: name vs name 0 #键名相等、下步将比较键值是否相等
debug value: 爱E族 vs 爱E族 0 #键值也相等,将在返回数组中返回
debug key: type vs type 0 #键名相等、下步将比较键值是否相等
debug value: domaim vs string -1 #键值不相等,不会在返回数组中返回
Array
(
[name] => 爱E族
)