array
PHP array_udiff_uassoc 函数
PHP • llslx520 发表了文章 • 0 个评论 • 964 次浏览 • 2016-11-14 14:25
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值的比较都使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较和键名比较都使用用户自定义函数。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff_uassoc($array1 , $array2[, $...], $user_value_compare_func, $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。只有键名比较返回0，对应的键值才会传递给此自定义函数比较。$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_uassoc 函数工作流程解析：
大体分为3步：1、每个数组key的排序去重；2、判断第一个数组的key是否与其他数组的key相等，如果相等返回0，然后执行第3步；3、判断第2步相等的key对应的值是否相等，相等返回0，此key和对应的值不会再出现在返回数组中，执行第1步比较下一对key。<?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('爱E族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, "user_value_compare_func", "user_key_compare_func");
print_r($result);输出：debug key: 1 vs 0 1 #$arr1的key排序去重
debug key: b vs 1 -1
debug key: 0 vs b -1 #$arr2的key排序去重
debug key: b vs name -1
debug key: 0 vs b -1 #key不相等
debug key: 0 vs 0 0 #key相等，下步比较key对应的键值
debug value: 爱E族 vs aiezu 1 #key对应的键值不相等，key:0，value:爱E族会出现在返回数组中
debug key: b vs 0 -1
debug key: b vs b 0 #key相等，下步比较key对应的键值
debug value: bb vs bb 0 #key对应的键值也相等，$arr1中键b和对应的键值bb不会出现在返回数组中
debug key: 1 vs 0 1
debug key: 1 vs b 1
debug key: 1 vs name 1
Array
(
[0] => 爱E族
[1] => aiezu
)
２、使用类函数作为键值和键名比较函数，找出三个数组的差集：<?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');
$arr3 = array('1'=>'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, $arr3, array("user", "value_compare"), array("user", "key_compare"));
print_r($result);输出：Array
(
[0] => 爱E族
) 查看全部
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值的比较都使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较和键名比较都使用用户自定义函数。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff_uassoc($array1 , $array2[, $...], $user_value_compare_func, $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。只有键名比较返回0，对应的键值才会传递给此自定义函数比较。$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_uassoc 函数工作流程解析：
大体分为3步：1、每个数组key的排序去重；2、判断第一个数组的key是否与其他数组的key相等，如果相等返回0，然后执行第3步；3、判断第2步相等的key对应的值是否相等，相等返回0，此key和对应的值不会再出现在返回数组中，执行第1步比较下一对key。<?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('爱E族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, "user_value_compare_func", "user_key_compare_func");
print_r($result);输出：debug key: 1 vs 0 1 #$arr1的key排序去重
debug key: b vs 1 -1
debug key: 0 vs b -1 #$arr2的key排序去重
debug key: b vs name -1
debug key: 0 vs b -1 #key不相等
debug key: 0 vs 0 0 #key相等，下步比较key对应的键值
debug value: 爱E族 vs aiezu 1 #key对应的键值不相等，key:0，value:爱E族会出现在返回数组中
debug key: b vs 0 -1
debug key: b vs b 0 #key相等，下步比较key对应的键值
debug value: bb vs bb 0 #key对应的键值也相等，$arr1中键b和对应的键值bb不会出现在返回数组中
debug key: 1 vs 0 1
debug key: 1 vs b 1
debug key: 1 vs name 1
Array
(
[0] => 爱E族
[1] => aiezu
)
２、使用类函数作为键值和键名比较函数，找出三个数组的差集：<?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');
$arr3 = array('1'=>'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, $arr3, array("user", "value_compare"), array("user", "key_compare"));
print_r($result);输出：Array
(
[0] => 爱E族
) 查看全部
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值的比较都使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较和键名比较都使用用户自定义函数。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、array_udiff_uassoc 函数工作流程解析：
大体分为3步：1、每个数组key的排序去重；2、判断第一个数组的key是否与其他数组的key相等，如果相等返回0，然后执行第3步；3、判断第2步相等的key对应的值是否相等，相等返回0，此key和对应的值不会再出现在返回数组中，执行第1步比较下一对key。
２、使用类函数作为键值和键名比较函数，找出三个数组的差集：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值的比较都使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较和键名比较都使用用户自定义函数。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_udiff_uassoc($array1 , $array2[, $...], $user_value_compare_func, $user_key_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| $user_value_compare_func | 用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。只有键名比较返回0，对应的键值才会传递给此自定义函数比较。 |
| $user_key_compare_func | 用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_uassoc 函数工作流程解析：
大体分为3步：1、每个数组key的排序去重；2、判断第一个数组的key是否与其他数组的key相等，如果相等返回0，然后执行第3步；3、判断第2步相等的key对应的值是否相等，相等返回0，此key和对应的值不会再出现在返回数组中，执行第1步比较下一对key。
<?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('爱E族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, "user_value_compare_func", "user_key_compare_func");
print_r($result);
debug key: 1 vs 0 1 #$arr1的key排序去重
debug key: b vs 1 -1
debug key: 0 vs b -1 #$arr2的key排序去重
debug key: b vs name -1
debug key: 0 vs b -1 #key不相等
debug key: 0 vs 0 0 #key相等，下步比较key对应的键值
debug value: 爱E族 vs aiezu 1 #key对应的键值不相等，key:0，value:爱E族会出现在返回数组中
debug key: b vs 0 -1
debug key: b vs b 0 #key相等，下步比较key对应的键值
debug value: bb vs bb 0 #key对应的键值也相等，$arr1中键b和对应的键值bb不会出现在返回数组中
debug key: 1 vs 0 1
debug key: 1 vs b 1
debug key: 1 vs name 1
Array
(
[0] => 爱E族
[1] => aiezu
)
２、使用类函数作为键值和键名比较函数，找出三个数组的差集：
<?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');
$arr3 = array('1'=>'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, $arr3, array("user", "value_compare"), array("user", "key_compare"));
print_r($result);
Array
(
[0] => 爱E族
)
PHP array_udiff_assoc 函数
PHP • llslx520 发表了文章 • 0 个评论 • 920 次浏览 • 2016-11-14 14:18
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较使用用户自定义函数，键名比较使用系统默认。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff_assoc($array1, $array2[, $... ], $user_value_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_assoc 的自定义函数工作流程：<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_assoc($arr1, $arr2, "user_value_compare_func");
print_r($result);输出：debug: value 爱E族 aiezu 1 #键名相等但键值不相等，“爱E族”会出现在返回结果中。
debug: value bb bb 0 #键名相等且键值也相等，，“bb”不会出现在返回结果中。
Array
(
[0] => 爱E族
[1] => aiezu #键名不相等，不会提交给user_value_compare_func函数比较键值
)
2、使用类函数作为键值比较函数，找出三个数组的差集：<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array('usage', 'aiezu', '爱E族', 'com');
$arr2 = array('com', '2'=>'爱E族');
$arr3 = array('usage');
$result = array_udiff_assoc($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);输出：Array
(
[1] => aiezu
[3] => com
) 查看全部
计算出第一个数组与其他数组的差集（考虑键名和键值，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较使用用户自定义函数，键名比较使用系统默认。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff_assoc($array1, $array2[, $... ], $user_value_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_assoc 的自定义函数工作流程：<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_assoc($arr1, $arr2, "user_value_compare_func");
print_r($result);输出：debug: value 爱E族 aiezu 1 #键名相等但键值不相等，“爱E族”会出现在返回结果中。
debug: value bb bb 0 #键名相等且键值也相等，，“bb”不会出现在返回结果中。
Array
(
[0] => 爱E族
[1] => aiezu #键名不相等，不会提交给user_value_compare_func函数比较键值
)
2、使用类函数作为键值比较函数，找出三个数组的差集：<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array('usage', 'aiezu', '爱E族', 'com');
$arr2 = array('com', '2'=>'爱E族');
$arr3 = array('usage');
$result = array_udiff_assoc($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);输出：Array
(
[1] => aiezu
[3] => com
) 查看全部
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较使用用户自定义函数，键名比较使用系统默认。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、array_udiff_assoc 的自定义函数工作流程：
2、使用类函数作为键值比较函数，找出三个数组的差集：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较使用用户自定义函数，键名比较使用系统默认。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_udiff_assoc($array1, $array2[, $... ], $user_value_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| user_value_compare_func | 用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_assoc 的自定义函数工作流程：
<?php输出：
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_assoc($arr1, $arr2, "user_value_compare_func");
print_r($result);
debug: value 爱E族 aiezu 1 #键名相等但键值不相等，“爱E族”会出现在返回结果中。
debug: value bb bb 0 #键名相等且键值也相等，，“bb”不会出现在返回结果中。
Array
(
[0] => 爱E族
[1] => aiezu #键名不相等，不会提交给user_value_compare_func函数比较键值
)
2、使用类函数作为键值比较函数，找出三个数组的差集：
<?php输出：
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array('usage', 'aiezu', '爱E族', 'com');
$arr2 = array('com', '2'=>'爱E族');
$arr3 = array('usage');
$result = array_udiff_assoc($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);
Array
(
[1] => aiezu
[3] => com
)
PHP array_diff_ukey 函数
PHP • llslx520 发表了文章 • 0 个评论 • 866 次浏览 • 2016-11-14 13:59
一、函数功能：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值，对键名的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_ukey ( $array1, $array2 [, $...], $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、array_diff_ukey 函数工作流程解析：<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_ukey($arr1, $arr2, "user_key_compare_func");
print_r($result);输出：b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，不会在出现在返回数组中
b a 1
b b 0 #键名相等，不会在出现在返回数组中
c a 1
c b 1
c d -1
Array
(
[c] => 3
)
2、使用类中的自定义函数比较三个数组。<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_ukey($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);输出：Array
(
<strong> => 2
)</strong> 查看全部
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值，对键名的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_ukey ( $array1, $array2 [, $...], $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、array_diff_ukey 函数工作流程解析：<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_ukey($arr1, $arr2, "user_key_compare_func");
print_r($result);输出：b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，不会在出现在返回数组中
b a 1
b b 0 #键名相等，不会在出现在返回数组中
c a 1
c b 1
c d -1
Array
(
[c] => 3
)
2、使用类中的自定义函数比较三个数组。<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_ukey($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);输出：Array
(
<strong> => 2
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值，对键名的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、array_diff_ukey 函数工作流程解析：
2、使用类中的自定义函数比较三个数组。
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值，对键名的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff_ukey ( $array1, $array2 [, $...], $user_key_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| $user_key_compare_func | 用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、array_diff_ukey 函数工作流程解析：
<?php输出：
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_ukey($arr1, $arr2, "user_key_compare_func");
print_r($result);
b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，不会在出现在返回数组中
b a 1
b b 0 #键名相等，不会在出现在返回数组中
c a 1
c b 1
c d -1
Array
(
[c] => 3
)
2、使用类中的自定义函数比较三个数组。
<?php输出：
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_ukey($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);
Array
(
<strong> => 2
)</strong>
PHP array_diff_key 函数
PHP • llslx520 发表了文章 • 0 个评论 • 913 次浏览 • 2016-11-14 13:54
一、函数功能：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_key ( $array1 , $array2 [, $...] )
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、两个数组的比较：
只要第一个数组中的key出现在后续数组key中，不管值是不是一样，都不会出现在返回数组中。<?php
$arr1 = array("a"=>"aa", "b"=>"aiezu.com", "c"=>"cc");
$arr2 = array("a"=>false, "aiezu.com", "c"=>"cc");
print_r(array_diff_key($arr1, $arr2));输出：Array
(
<strong> => bb
)</strong>
2、三个数组的比较：<strong><?php
$arr1 = array("a"=>"aa", "b"=>"bb", "c"=>"cc");
$arr2 = array("a"=>false);
$arr3 = array("b"=>'bb');
print_r(array_diff_key($arr1, $arr2, $arr3));</strong>输出：<strong>Array
(
[c] => cc
)</strong>
3、array_diff_key是将数组键强制转换为"string"后进行"==="(全等于)比较：<strong><?php
$arr1 = array(false=>"aa"); #false做为数组键时会自动转换为0
$arr2 = array("0"=>false);
print_r($arr1);
print_r(array_diff_key($arr1, $arr2));</strong>输出：<strong>Array
(
[0] => aa
)
Array
(
)</strong> 查看全部
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_key ( $array1 , $array2 [, $...] )
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、两个数组的比较：
只要第一个数组中的key出现在后续数组key中，不管值是不是一样，都不会出现在返回数组中。<?php
$arr1 = array("a"=>"aa", "b"=>"aiezu.com", "c"=>"cc");
$arr2 = array("a"=>false, "aiezu.com", "c"=>"cc");
print_r(array_diff_key($arr1, $arr2));输出：Array
(
<strong> => bb
)</strong>
2、三个数组的比较：<strong><?php
$arr1 = array("a"=>"aa", "b"=>"bb", "c"=>"cc");
$arr2 = array("a"=>false);
$arr3 = array("b"=>'bb');
print_r(array_diff_key($arr1, $arr2, $arr3));</strong>输出：<strong>Array
(
[c] => cc
)</strong>
3、array_diff_key是将数组键强制转换为"string"后进行"==="(全等于)比较：<strong><?php
$arr1 = array(false=>"aa"); #false做为数组键时会自动转换为0
$arr2 = array("0"=>false);
print_r($arr1);
print_r(array_diff_key($arr1, $arr2));</strong>输出：<strong>Array
(
[0] => aa
)
Array
(
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、两个数组的比较：
只要第一个数组中的key出现在后续数组key中，不管值是不是一样，都不会出现在返回数组中。
2、三个数组的比较：
3、array_diff_key是将数组键强制转换为"string"后进行"==="(全等于)比较：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff_key ( $array1 , $array2 [, $...] )
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
四、返回值：
返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、两个数组的比较：
只要第一个数组中的key出现在后续数组key中，不管值是不是一样，都不会出现在返回数组中。
<?php输出：
$arr1 = array("a"=>"aa", "b"=>"aiezu.com", "c"=>"cc");
$arr2 = array("a"=>false, "aiezu.com", "c"=>"cc");
print_r(array_diff_key($arr1, $arr2));
Array
(
<strong> => bb
)</strong>
2、三个数组的比较：
<strong><?php输出：
$arr1 = array("a"=>"aa", "b"=>"bb", "c"=>"cc");
$arr2 = array("a"=>false);
$arr3 = array("b"=>'bb');
print_r(array_diff_key($arr1, $arr2, $arr3));</strong>
<strong>Array
(
[c] => cc
)</strong>
3、array_diff_key是将数组键强制转换为"string"后进行"==="(全等于)比较：
<strong><?php输出：
$arr1 = array(false=>"aa"); #false做为数组键时会自动转换为0
$arr2 = array("0"=>false);
print_r($arr1);
print_r(array_diff_key($arr1, $arr2));</strong>
<strong>Array
(
[0] => aa
)
Array
(
)</strong>
PHP array_diff_uassoc 函数
PHP • llslx520 发表了文章 • 0 个评论 • 948 次浏览 • 2016-11-14 13:39
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名的比较使用自定义函数）。比较两到多个数组，返回第一个数组中不包含在其他任何数组中的键名/值对组成的数组。PHP 5才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_uassoc ( $array1 , $array2 [, $...], $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回在第一个数组但不在其他数组的键/值对组成数组。
五、用法举例：
1、array_diff_uassoc 函数工作流程解析：<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_uassoc($arr1, $arr2, "user_key_compare_func");
print_r($result);输出：b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，键值不相等（系统函数去比较），会出现在返回结果中
b a 1
b b 0 #键名相等，键值也相等（系统函数去比较），不会出现在返回结果中
c a 1
c b 1
c d -1
Array
(
[a] => 1
[c] => 3
)
2、使用类中的自定义函数比较三个数组：<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_uassoc($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);输出：Array
(
[a] => 1
<strong> => 2
)</strong> 查看全部
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名的比较使用自定义函数）。比较两到多个数组，返回第一个数组中不包含在其他任何数组中的键名/值对组成的数组。PHP 5才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_uassoc ( $array1 , $array2 [, $...], $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回在第一个数组但不在其他数组的键/值对组成数组。
五、用法举例：
1、array_diff_uassoc 函数工作流程解析：<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_uassoc($arr1, $arr2, "user_key_compare_func");
print_r($result);输出：b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，键值不相等（系统函数去比较），会出现在返回结果中
b a 1
b b 0 #键名相等，键值也相等（系统函数去比较），不会出现在返回结果中
c a 1
c b 1
c d -1
Array
(
[a] => 1
[c] => 3
)
2、使用类中的自定义函数比较三个数组：<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_uassoc($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);输出：Array
(
[a] => 1
<strong> => 2
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名的比较使用自定义函数）。比较两到多个数组，返回第一个数组中不包含在其他任何数组中的键名/值对组成的数组。PHP 5才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、array_diff_uassoc 函数工作流程解析：
2、使用类中的自定义函数比较三个数组：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名的比较使用自定义函数）。比较两到多个数组，返回第一个数组中不包含在其他任何数组中的键名/值对组成的数组。PHP 5才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff_uassoc ( $array1 , $array2 [, $...], $user_key_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| $user_key_compare_func | 用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回在第一个数组但不在其他数组的键/值对组成数组。
五、用法举例：
1、array_diff_uassoc 函数工作流程解析：
<?php输出：
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_uassoc($arr1, $arr2, "user_key_compare_func");
print_r($result);
b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，键值不相等（系统函数去比较），会出现在返回结果中
b a 1
b b 0 #键名相等，键值也相等（系统函数去比较），不会出现在返回结果中
c a 1
c b 1
c d -1
Array
(
[a] => 1
[c] => 3
)
2、使用类中的自定义函数比较三个数组：
<?php输出：
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_uassoc($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);
Array
(
[a] => 1
<strong> => 2
)</strong>
PHP array_diff_assoc 函数
PHP • llslx520 发表了文章 • 0 个评论 • 852 次浏览 • 2016-11-14 13:30
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名/值对。此函数和array_diff不同的是键名也参与比较。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_assoc($array1, $array2 [, $...])
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回带索引的比较第一个数组与其他数组的差集数组。
五、用法举例：
1、两个数组的比较：
例中可以看出，第一个数组中的元素，只有键值对同时包含在第二个数组中，才不会出现在结果数组中。<?php
$arr1 = array('a'=>'aaa', 'b'=>"bbb", 'c'=>"ccc");
$arr2 = array('a'=>'aaa', 'c'=>"cc", 'bb'=>'bbb');
print_r(array_diff_assoc($arr1, $arr2));输出：Array
(
<strong> => bbb
[c] => ccc
)</strong>
2、三个数组的比较：<strong><?php
$arr1 = array('a'=>'爱E族', 'b'=>"百度", 'c'=>"aiezu.com");
$arr2 = array('a'=>'爱E族', "aiezu.com");
$arr3 = array('b'=>'百度');
print_r(array_diff_assoc($arr1, $arr2, $arr3));
</strong>输出：<strong>Array
(
[c] => aiezu.com
)</strong>
3、array_diff_assoc是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。<strong><?php
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff_assoc($arr1, $arr2));</strong>输出：<strong>Array
(
)</strong> 查看全部
计算出第一个数组与其他数组的差集（考虑键名和键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名/值对。此函数和array_diff不同的是键名也参与比较。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_assoc($array1, $array2 [, $...])
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回带索引的比较第一个数组与其他数组的差集数组。
五、用法举例：
1、两个数组的比较：
例中可以看出，第一个数组中的元素，只有键值对同时包含在第二个数组中，才不会出现在结果数组中。<?php
$arr1 = array('a'=>'aaa', 'b'=>"bbb", 'c'=>"ccc");
$arr2 = array('a'=>'aaa', 'c'=>"cc", 'bb'=>'bbb');
print_r(array_diff_assoc($arr1, $arr2));输出：Array
(
<strong> => bbb
[c] => ccc
)</strong>
2、三个数组的比较：<strong><?php
$arr1 = array('a'=>'爱E族', 'b'=>"百度", 'c'=>"aiezu.com");
$arr2 = array('a'=>'爱E族', "aiezu.com");
$arr3 = array('b'=>'百度');
print_r(array_diff_assoc($arr1, $arr2, $arr3));
</strong>输出：<strong>Array
(
[c] => aiezu.com
)</strong>
3、array_diff_assoc是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。<strong><?php
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff_assoc($arr1, $arr2));</strong>输出：<strong>Array
(
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名/值对。此函数和array_diff不同的是键名也参与比较。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、两个数组的比较：
例中可以看出，第一个数组中的元素，只有键值对同时包含在第二个数组中，才不会出现在结果数组中。
2、三个数组的比较：
3、array_diff_assoc是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。
计算出第一个数组与其他数组的差集（考虑键名和键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名/值对。此函数和array_diff不同的是键名也参与比较。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff_assoc($array1, $array2 [, $...])
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
四、返回值：
返回带索引的比较第一个数组与其他数组的差集数组。
五、用法举例：
1、两个数组的比较：
例中可以看出，第一个数组中的元素，只有键值对同时包含在第二个数组中，才不会出现在结果数组中。
<?php输出：
$arr1 = array('a'=>'aaa', 'b'=>"bbb", 'c'=>"ccc");
$arr2 = array('a'=>'aaa', 'c'=>"cc", 'bb'=>'bbb');
print_r(array_diff_assoc($arr1, $arr2));
Array
(
<strong> => bbb
[c] => ccc
)</strong>
2、三个数组的比较：
<strong><?php输出：
$arr1 = array('a'=>'爱E族', 'b'=>"百度", 'c'=>"aiezu.com");
$arr2 = array('a'=>'爱E族', "aiezu.com");
$arr3 = array('b'=>'百度');
print_r(array_diff_assoc($arr1, $arr2, $arr3));
</strong>
<strong>Array
(
[c] => aiezu.com
)</strong>
3、array_diff_assoc是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。
<strong><?php输出：
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff_assoc($arr1, $arr2));</strong>
<strong>Array
(
)</strong>
PHP array_udiff 函数
PHP • llslx520 发表了文章 • 0 个评论 • 731 次浏览 • 2016-11-14 12:07
一、函数功能：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键值。数组的键名不参与比较，但返回数组中保留键名不变。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff ( $array1, $array2 [, $...], $user_value_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键值差集组成的数组。
五、用法举例：
1、PHP array_udiff 函数工作流程解析：<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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('aiezu', 'b'=>'bb', 'com');
$arr2 = array('a'=>'aa', 'bb', 'c');
$result = array_udiff($arr1, $arr2, "user_value_compare_func");
print_r($result);输出：debug: value bb aiezu 1 #$arr1的排序出重
debug: value com bb 1
debug: value bb aa 1 #$arr2的排序出重
debug: value c bb 1
debug: value aiezu aa 1 #不相等
debug: value aiezu bb -1 #不相等
debug: value aiezu bb -1
debug: value bb aa 1
debug: value bb bb 0 #键值相等，不会出现在返回数组中
debug: value bb com -1
debug: value com bb 1
debug: value com c 1
Array
(
[0] => aiezu
[1] => com
)
2、使用类函数作为键值比较函数找出三个数组的差集：<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>'aiezu.com', "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>1);
$result = array_udiff($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);输出：Array
(
<strong> => aiezu.com
)</strong> 查看全部
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键值。数组的键名不参与比较，但返回数组中保留键名不变。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff ( $array1, $array2 [, $...], $user_value_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键值差集组成的数组。
五、用法举例：
1、PHP array_udiff 函数工作流程解析：<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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('aiezu', 'b'=>'bb', 'com');
$arr2 = array('a'=>'aa', 'bb', 'c');
$result = array_udiff($arr1, $arr2, "user_value_compare_func");
print_r($result);输出：debug: value bb aiezu 1 #$arr1的排序出重
debug: value com bb 1
debug: value bb aa 1 #$arr2的排序出重
debug: value c bb 1
debug: value aiezu aa 1 #不相等
debug: value aiezu bb -1 #不相等
debug: value aiezu bb -1
debug: value bb aa 1
debug: value bb bb 0 #键值相等，不会出现在返回数组中
debug: value bb com -1
debug: value com bb 1
debug: value com c 1
Array
(
[0] => aiezu
[1] => com
)
2、使用类函数作为键值比较函数找出三个数组的差集：<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>'aiezu.com', "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>1);
$result = array_udiff($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);输出：Array
(
<strong> => aiezu.com
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键值。数组的键名不参与比较，但返回数组中保留键名不变。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、PHP array_udiff 函数工作流程解析：
2、使用类函数作为键值比较函数找出三个数组的差集：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键值。数组的键名不参与比较，但返回数组中保留键名不变。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_udiff ( $array1, $array2 [, $...], $user_value_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| $user_value_compare_func | 用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回第一个数组与其他数组的键值差集组成的数组。
五、用法举例：
1、PHP array_udiff 函数工作流程解析：
<?php输出：
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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('aiezu', 'b'=>'bb', 'com');
$arr2 = array('a'=>'aa', 'bb', 'c');
$result = array_udiff($arr1, $arr2, "user_value_compare_func");
print_r($result);
debug: value bb aiezu 1 #$arr1的排序出重
debug: value com bb 1
debug: value bb aa 1 #$arr2的排序出重
debug: value c bb 1
debug: value aiezu aa 1 #不相等
debug: value aiezu bb -1 #不相等
debug: value aiezu bb -1
debug: value bb aa 1
debug: value bb bb 0 #键值相等，不会出现在返回数组中
debug: value bb com -1
debug: value com bb 1
debug: value com c 1
Array
(
[0] => aiezu
[1] => com
)
2、使用类函数作为键值比较函数找出三个数组的差集：
<?php输出：
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>'aiezu.com', "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>1);
$result = array_udiff($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);
Array
(
<strong> => aiezu.com
)</strong>
PHP array_diff 函数
PHP • llslx520 发表了文章 • 0 个评论 • 855 次浏览 • 2016-11-14 11:31
一、函数功能：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名）。比较两到多个数组，找出第一个数组中不包含在其他数组中的键值。数组的键名不参与比较，返回数组中保留键名不变。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff ( $array1, $array2 [, $... ] )
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回一个数组，数组中包含所有第一个数组中不包含在其他任何数组中的键值和对应的键名。
五、用法举例：
1、两个数组的比较：
比较时忽视键名，返回结果中保留键名：<?php
$arr1 = array('aa', 'b'=>'bb', 'aiezu.com');
$arr2 = array('a'=>'aa', 'bb', 'c');
print_r(array_diff($arr1, $arr2));输出：Array
(
[1] => aiezu.com
)
2、三个数组的比较：<?php
$arr1 = array('aa', 'b'=>'爱E族', 'aiezu.com');
$arr2 = array('a'=>'aa');
$arr3 = array('爱E族');
print_r(array_diff($arr1, $arr2, $arr3));输出：Array
(
[1] => aiezu.com
)
3、array_diff()是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。<?php
//爱E族: aiezu.com
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff($arr1, $arr2));输出：Array
(
) 查看全部
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名）。比较两到多个数组，找出第一个数组中不包含在其他数组中的键值。数组的键名不参与比较，返回数组中保留键名不变。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff ( $array1, $array2 [, $... ] )
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回一个数组，数组中包含所有第一个数组中不包含在其他任何数组中的键值和对应的键名。
五、用法举例：
1、两个数组的比较：
比较时忽视键名，返回结果中保留键名：<?php
$arr1 = array('aa', 'b'=>'bb', 'aiezu.com');
$arr2 = array('a'=>'aa', 'bb', 'c');
print_r(array_diff($arr1, $arr2));输出：Array
(
[1] => aiezu.com
)
2、三个数组的比较：<?php
$arr1 = array('aa', 'b'=>'爱E族', 'aiezu.com');
$arr2 = array('a'=>'aa');
$arr3 = array('爱E族');
print_r(array_diff($arr1, $arr2, $arr3));输出：Array
(
[1] => aiezu.com
)
3、array_diff()是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。<?php
//爱E族: aiezu.com
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff($arr1, $arr2));输出：Array
(
) 查看全部
一、函数功能：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名）。比较两到多个数组，找出第一个数组中不包含在其他数组中的键值。数组的键名不参与比较，返回数组中保留键名不变。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、两个数组的比较：
比较时忽视键名，返回结果中保留键名：
2、三个数组的比较：
3、array_diff()是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名）。比较两到多个数组，找出第一个数组中不包含在其他数组中的键值。数组的键名不参与比较，返回数组中保留键名不变。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff ( $array1, $array2 [, $... ] )
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
四、返回值：
返回一个数组，数组中包含所有第一个数组中不包含在其他任何数组中的键值和对应的键名。
五、用法举例：
1、两个数组的比较：
比较时忽视键名，返回结果中保留键名：
<?php输出：
$arr1 = array('aa', 'b'=>'bb', 'aiezu.com');
$arr2 = array('a'=>'aa', 'bb', 'c');
print_r(array_diff($arr1, $arr2));
Array
(
[1] => aiezu.com
)
2、三个数组的比较：
<?php输出：
$arr1 = array('aa', 'b'=>'爱E族', 'aiezu.com');
$arr2 = array('a'=>'aa');
$arr3 = array('爱E族');
print_r(array_diff($arr1, $arr2, $arr3));
Array
(
[1] => aiezu.com
)
3、array_diff()是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。
<?php输出：
//爱E族: aiezu.com
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff($arr1, $arr2));
Array
(
)
PHP数组计算差集系列函数的区别
PHP • llslx520 发表了文章 • 0 个评论 • 1142 次浏览 • 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数组差集计算函数，用来计算一个数组与其他数组的差集。计算类型分为计算键名的差集、计算键值的差集、计算键名/值对的差集三类；计算方式分为系统默认函数计算和使用用户自定义函数计算两种。PHP数组差集计算函数共有8个。
数组差集比较函数功能差异表：
PHP数组计算交集系列函数的区别：http://aiezu.com/article/php_array_intersect_sets.html
二、参数中的自定义函数：
差集比较函数通过比较键名、键值是否想等，把完全相等的剔除掉，从而找出它与其它数组的差集。为了方便大家实现个性化的需求，PHP为部分函数提供了接口，可以使用自定义函数来比较键名、键值是否相等。PHP会传递两个键名给键名自定义比较函数、或者两个键值给自定义键值比较函数，用户可以在自定义比较函数中根据自己的需求进行比较，只需给自定义函数一个整型返回值就行（返回0认为键名或键值相等）。
自定义比较函数举例：
1、使用基础函数方式：
2、使用类的函数方式：
三、用法举例：
1、使用基础自定义函数作为比较函数完整代码：
2、使用类函数作为比较函数完整代码：
3、差集比较函数的工作流程：
这里以array_udiff_uassoc()函数举例解析差集比较函数的工作流程，array_udiff_uassoc()函数是使用自定义函数计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值都使用自定义函数）。
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为部分函数提供了接口，可以使用自定义函数来比较键名、键值是否相等。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_udiff_uassoc 函数
PHP • llslx520 发表了文章 • 0 个评论 • 964 次浏览 • 2016-11-14 14:25
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值的比较都使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较和键名比较都使用用户自定义函数。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff_uassoc($array1 , $array2[, $...], $user_value_compare_func, $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。只有键名比较返回0，对应的键值才会传递给此自定义函数比较。$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_uassoc 函数工作流程解析：
大体分为3步：1、每个数组key的排序去重；2、判断第一个数组的key是否与其他数组的key相等，如果相等返回0，然后执行第3步；3、判断第2步相等的key对应的值是否相等，相等返回0，此key和对应的值不会再出现在返回数组中，执行第1步比较下一对key。<?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('爱E族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, "user_value_compare_func", "user_key_compare_func");
print_r($result);输出：debug key: 1 vs 0 1 #$arr1的key排序去重
debug key: b vs 1 -1
debug key: 0 vs b -1 #$arr2的key排序去重
debug key: b vs name -1
debug key: 0 vs b -1 #key不相等
debug key: 0 vs 0 0 #key相等，下步比较key对应的键值
debug value: 爱E族 vs aiezu 1 #key对应的键值不相等，key:0，value:爱E族会出现在返回数组中
debug key: b vs 0 -1
debug key: b vs b 0 #key相等，下步比较key对应的键值
debug value: bb vs bb 0 #key对应的键值也相等，$arr1中键b和对应的键值bb不会出现在返回数组中
debug key: 1 vs 0 1
debug key: 1 vs b 1
debug key: 1 vs name 1
Array
(
[0] => 爱E族
[1] => aiezu
)
２、使用类函数作为键值和键名比较函数，找出三个数组的差集：<?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');
$arr3 = array('1'=>'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, $arr3, array("user", "value_compare"), array("user", "key_compare"));
print_r($result);输出：Array
(
[0] => 爱E族
) 查看全部
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值的比较都使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较和键名比较都使用用户自定义函数。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff_uassoc($array1 , $array2[, $...], $user_value_compare_func, $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。只有键名比较返回0，对应的键值才会传递给此自定义函数比较。$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_uassoc 函数工作流程解析：
大体分为3步：1、每个数组key的排序去重；2、判断第一个数组的key是否与其他数组的key相等，如果相等返回0，然后执行第3步；3、判断第2步相等的key对应的值是否相等，相等返回0，此key和对应的值不会再出现在返回数组中，执行第1步比较下一对key。<?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('爱E族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, "user_value_compare_func", "user_key_compare_func");
print_r($result);输出：debug key: 1 vs 0 1 #$arr1的key排序去重
debug key: b vs 1 -1
debug key: 0 vs b -1 #$arr2的key排序去重
debug key: b vs name -1
debug key: 0 vs b -1 #key不相等
debug key: 0 vs 0 0 #key相等，下步比较key对应的键值
debug value: 爱E族 vs aiezu 1 #key对应的键值不相等，key:0，value:爱E族会出现在返回数组中
debug key: b vs 0 -1
debug key: b vs b 0 #key相等，下步比较key对应的键值
debug value: bb vs bb 0 #key对应的键值也相等，$arr1中键b和对应的键值bb不会出现在返回数组中
debug key: 1 vs 0 1
debug key: 1 vs b 1
debug key: 1 vs name 1
Array
(
[0] => 爱E族
[1] => aiezu
)
２、使用类函数作为键值和键名比较函数，找出三个数组的差集：<?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');
$arr3 = array('1'=>'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, $arr3, array("user", "value_compare"), array("user", "key_compare"));
print_r($result);输出：Array
(
[0] => 爱E族
) 查看全部
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值的比较都使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较和键名比较都使用用户自定义函数。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、array_udiff_uassoc 函数工作流程解析：
大体分为3步：1、每个数组key的排序去重；2、判断第一个数组的key是否与其他数组的key相等，如果相等返回0，然后执行第3步；3、判断第2步相等的key对应的值是否相等，相等返回0，此key和对应的值不会再出现在返回数组中，执行第1步比较下一对key。
２、使用类函数作为键值和键名比较函数，找出三个数组的差集：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值的比较都使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较和键名比较都使用用户自定义函数。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_udiff_uassoc($array1 , $array2[, $...], $user_value_compare_func, $user_key_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| $user_value_compare_func | 用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。只有键名比较返回0，对应的键值才会传递给此自定义函数比较。 |
| $user_key_compare_func | 用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_uassoc 函数工作流程解析：
大体分为3步：1、每个数组key的排序去重；2、判断第一个数组的key是否与其他数组的key相等，如果相等返回0，然后执行第3步；3、判断第2步相等的key对应的值是否相等，相等返回0，此key和对应的值不会再出现在返回数组中，执行第1步比较下一对key。
<?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('爱E族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, "user_value_compare_func", "user_key_compare_func");
print_r($result);
debug key: 1 vs 0 1 #$arr1的key排序去重
debug key: b vs 1 -1
debug key: 0 vs b -1 #$arr2的key排序去重
debug key: b vs name -1
debug key: 0 vs b -1 #key不相等
debug key: 0 vs 0 0 #key相等，下步比较key对应的键值
debug value: 爱E族 vs aiezu 1 #key对应的键值不相等，key:0，value:爱E族会出现在返回数组中
debug key: b vs 0 -1
debug key: b vs b 0 #key相等，下步比较key对应的键值
debug value: bb vs bb 0 #key对应的键值也相等，$arr1中键b和对应的键值bb不会出现在返回数组中
debug key: 1 vs 0 1
debug key: 1 vs b 1
debug key: 1 vs name 1
Array
(
[0] => 爱E族
[1] => aiezu
)
２、使用类函数作为键值和键名比较函数，找出三个数组的差集：
<?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');
$arr3 = array('1'=>'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, $arr3, array("user", "value_compare"), array("user", "key_compare"));
print_r($result);
Array
(
[0] => 爱E族
)
PHP array_udiff_assoc 函数
PHP • llslx520 发表了文章 • 0 个评论 • 920 次浏览 • 2016-11-14 14:18
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较使用用户自定义函数，键名比较使用系统默认。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff_assoc($array1, $array2[, $... ], $user_value_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_assoc 的自定义函数工作流程：<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_assoc($arr1, $arr2, "user_value_compare_func");
print_r($result);输出：debug: value 爱E族 aiezu 1 #键名相等但键值不相等，“爱E族”会出现在返回结果中。
debug: value bb bb 0 #键名相等且键值也相等，，“bb”不会出现在返回结果中。
Array
(
[0] => 爱E族
[1] => aiezu #键名不相等，不会提交给user_value_compare_func函数比较键值
)
2、使用类函数作为键值比较函数，找出三个数组的差集：<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array('usage', 'aiezu', '爱E族', 'com');
$arr2 = array('com', '2'=>'爱E族');
$arr3 = array('usage');
$result = array_udiff_assoc($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);输出：Array
(
[1] => aiezu
[3] => com
) 查看全部
计算出第一个数组与其他数组的差集（考虑键名和键值，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较使用用户自定义函数，键名比较使用系统默认。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff_assoc($array1, $array2[, $... ], $user_value_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_assoc 的自定义函数工作流程：<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_assoc($arr1, $arr2, "user_value_compare_func");
print_r($result);输出：debug: value 爱E族 aiezu 1 #键名相等但键值不相等，“爱E族”会出现在返回结果中。
debug: value bb bb 0 #键名相等且键值也相等，，“bb”不会出现在返回结果中。
Array
(
[0] => 爱E族
[1] => aiezu #键名不相等，不会提交给user_value_compare_func函数比较键值
)
2、使用类函数作为键值比较函数，找出三个数组的差集：<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array('usage', 'aiezu', '爱E族', 'com');
$arr2 = array('com', '2'=>'爱E族');
$arr3 = array('usage');
$result = array_udiff_assoc($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);输出：Array
(
[1] => aiezu
[3] => com
) 查看全部
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较使用用户自定义函数，键名比较使用系统默认。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、array_udiff_assoc 的自定义函数工作流程：
2、使用类函数作为键值比较函数，找出三个数组的差集：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较使用用户自定义函数，键名比较使用系统默认。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_udiff_assoc($array1, $array2[, $... ], $user_value_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| user_value_compare_func | 用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_assoc 的自定义函数工作流程：
<?php输出：
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_assoc($arr1, $arr2, "user_value_compare_func");
print_r($result);
debug: value 爱E族 aiezu 1 #键名相等但键值不相等，“爱E族”会出现在返回结果中。
debug: value bb bb 0 #键名相等且键值也相等，，“bb”不会出现在返回结果中。
Array
(
[0] => 爱E族
[1] => aiezu #键名不相等，不会提交给user_value_compare_func函数比较键值
)
2、使用类函数作为键值比较函数，找出三个数组的差集：
<?php输出：
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array('usage', 'aiezu', '爱E族', 'com');
$arr2 = array('com', '2'=>'爱E族');
$arr3 = array('usage');
$result = array_udiff_assoc($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);
Array
(
[1] => aiezu
[3] => com
)
PHP array_diff_ukey 函数
PHP • llslx520 发表了文章 • 0 个评论 • 866 次浏览 • 2016-11-14 13:59
一、函数功能：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值，对键名的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_ukey ( $array1, $array2 [, $...], $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、array_diff_ukey 函数工作流程解析：<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_ukey($arr1, $arr2, "user_key_compare_func");
print_r($result);输出：b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，不会在出现在返回数组中
b a 1
b b 0 #键名相等，不会在出现在返回数组中
c a 1
c b 1
c d -1
Array
(
[c] => 3
)
2、使用类中的自定义函数比较三个数组。<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_ukey($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);输出：Array
(
<strong> => 2
)</strong> 查看全部
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值，对键名的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_ukey ( $array1, $array2 [, $...], $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、array_diff_ukey 函数工作流程解析：<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_ukey($arr1, $arr2, "user_key_compare_func");
print_r($result);输出：b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，不会在出现在返回数组中
b a 1
b b 0 #键名相等，不会在出现在返回数组中
c a 1
c b 1
c d -1
Array
(
[c] => 3
)
2、使用类中的自定义函数比较三个数组。<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_ukey($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);输出：Array
(
<strong> => 2
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值，对键名的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、array_diff_ukey 函数工作流程解析：
2、使用类中的自定义函数比较三个数组。
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值，对键名的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff_ukey ( $array1, $array2 [, $...], $user_key_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| $user_key_compare_func | 用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、array_diff_ukey 函数工作流程解析：
<?php输出：
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_ukey($arr1, $arr2, "user_key_compare_func");
print_r($result);
b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，不会在出现在返回数组中
b a 1
b b 0 #键名相等，不会在出现在返回数组中
c a 1
c b 1
c d -1
Array
(
[c] => 3
)
2、使用类中的自定义函数比较三个数组。
<?php输出：
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_ukey($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);
Array
(
<strong> => 2
)</strong>
PHP array_diff_key 函数
PHP • llslx520 发表了文章 • 0 个评论 • 913 次浏览 • 2016-11-14 13:54
一、函数功能：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_key ( $array1 , $array2 [, $...] )
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、两个数组的比较：
只要第一个数组中的key出现在后续数组key中，不管值是不是一样，都不会出现在返回数组中。<?php
$arr1 = array("a"=>"aa", "b"=>"aiezu.com", "c"=>"cc");
$arr2 = array("a"=>false, "aiezu.com", "c"=>"cc");
print_r(array_diff_key($arr1, $arr2));输出：Array
(
<strong> => bb
)</strong>
2、三个数组的比较：<strong><?php
$arr1 = array("a"=>"aa", "b"=>"bb", "c"=>"cc");
$arr2 = array("a"=>false);
$arr3 = array("b"=>'bb');
print_r(array_diff_key($arr1, $arr2, $arr3));</strong>输出：<strong>Array
(
[c] => cc
)</strong>
3、array_diff_key是将数组键强制转换为"string"后进行"==="(全等于)比较：<strong><?php
$arr1 = array(false=>"aa"); #false做为数组键时会自动转换为0
$arr2 = array("0"=>false);
print_r($arr1);
print_r(array_diff_key($arr1, $arr2));</strong>输出：<strong>Array
(
[0] => aa
)
Array
(
)</strong> 查看全部
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_key ( $array1 , $array2 [, $...] )
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、两个数组的比较：
只要第一个数组中的key出现在后续数组key中，不管值是不是一样，都不会出现在返回数组中。<?php
$arr1 = array("a"=>"aa", "b"=>"aiezu.com", "c"=>"cc");
$arr2 = array("a"=>false, "aiezu.com", "c"=>"cc");
print_r(array_diff_key($arr1, $arr2));输出：Array
(
<strong> => bb
)</strong>
2、三个数组的比较：<strong><?php
$arr1 = array("a"=>"aa", "b"=>"bb", "c"=>"cc");
$arr2 = array("a"=>false);
$arr3 = array("b"=>'bb');
print_r(array_diff_key($arr1, $arr2, $arr3));</strong>输出：<strong>Array
(
[c] => cc
)</strong>
3、array_diff_key是将数组键强制转换为"string"后进行"==="(全等于)比较：<strong><?php
$arr1 = array(false=>"aa"); #false做为数组键时会自动转换为0
$arr2 = array("0"=>false);
print_r($arr1);
print_r(array_diff_key($arr1, $arr2));</strong>输出：<strong>Array
(
[0] => aa
)
Array
(
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、两个数组的比较：
只要第一个数组中的key出现在后续数组key中，不管值是不是一样，都不会出现在返回数组中。
2、三个数组的比较：
3、array_diff_key是将数组键强制转换为"string"后进行"==="(全等于)比较：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff_key ( $array1 , $array2 [, $...] )
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
四、返回值：
返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、两个数组的比较：
只要第一个数组中的key出现在后续数组key中，不管值是不是一样，都不会出现在返回数组中。
<?php输出：
$arr1 = array("a"=>"aa", "b"=>"aiezu.com", "c"=>"cc");
$arr2 = array("a"=>false, "aiezu.com", "c"=>"cc");
print_r(array_diff_key($arr1, $arr2));
Array
(
<strong> => bb
)</strong>
2、三个数组的比较：
<strong><?php输出：
$arr1 = array("a"=>"aa", "b"=>"bb", "c"=>"cc");
$arr2 = array("a"=>false);
$arr3 = array("b"=>'bb');
print_r(array_diff_key($arr1, $arr2, $arr3));</strong>
<strong>Array
(
[c] => cc
)</strong>
3、array_diff_key是将数组键强制转换为"string"后进行"==="(全等于)比较：
<strong><?php输出：
$arr1 = array(false=>"aa"); #false做为数组键时会自动转换为0
$arr2 = array("0"=>false);
print_r($arr1);
print_r(array_diff_key($arr1, $arr2));</strong>
<strong>Array
(
[0] => aa
)
Array
(
)</strong>
PHP array_diff_uassoc 函数
PHP • llslx520 发表了文章 • 0 个评论 • 948 次浏览 • 2016-11-14 13:39
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名的比较使用自定义函数）。比较两到多个数组，返回第一个数组中不包含在其他任何数组中的键名/值对组成的数组。PHP 5才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_uassoc ( $array1 , $array2 [, $...], $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回在第一个数组但不在其他数组的键/值对组成数组。
五、用法举例：
1、array_diff_uassoc 函数工作流程解析：<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_uassoc($arr1, $arr2, "user_key_compare_func");
print_r($result);输出：b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，键值不相等（系统函数去比较），会出现在返回结果中
b a 1
b b 0 #键名相等，键值也相等（系统函数去比较），不会出现在返回结果中
c a 1
c b 1
c d -1
Array
(
[a] => 1
[c] => 3
)
2、使用类中的自定义函数比较三个数组：<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_uassoc($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);输出：Array
(
[a] => 1
<strong> => 2
)</strong> 查看全部
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名的比较使用自定义函数）。比较两到多个数组，返回第一个数组中不包含在其他任何数组中的键名/值对组成的数组。PHP 5才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_uassoc ( $array1 , $array2 [, $...], $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回在第一个数组但不在其他数组的键/值对组成数组。
五、用法举例：
1、array_diff_uassoc 函数工作流程解析：<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_uassoc($arr1, $arr2, "user_key_compare_func");
print_r($result);输出：b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，键值不相等（系统函数去比较），会出现在返回结果中
b a 1
b b 0 #键名相等，键值也相等（系统函数去比较），不会出现在返回结果中
c a 1
c b 1
c d -1
Array
(
[a] => 1
[c] => 3
)
2、使用类中的自定义函数比较三个数组：<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_uassoc($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);输出：Array
(
[a] => 1
<strong> => 2
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名的比较使用自定义函数）。比较两到多个数组，返回第一个数组中不包含在其他任何数组中的键名/值对组成的数组。PHP 5才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、array_diff_uassoc 函数工作流程解析：
2、使用类中的自定义函数比较三个数组：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名的比较使用自定义函数）。比较两到多个数组，返回第一个数组中不包含在其他任何数组中的键名/值对组成的数组。PHP 5才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff_uassoc ( $array1 , $array2 [, $...], $user_key_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| $user_key_compare_func | 用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回在第一个数组但不在其他数组的键/值对组成数组。
五、用法举例：
1、array_diff_uassoc 函数工作流程解析：
<?php输出：
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_uassoc($arr1, $arr2, "user_key_compare_func");
print_r($result);
b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，键值不相等（系统函数去比较），会出现在返回结果中
b a 1
b b 0 #键名相等，键值也相等（系统函数去比较），不会出现在返回结果中
c a 1
c b 1
c d -1
Array
(
[a] => 1
[c] => 3
)
2、使用类中的自定义函数比较三个数组：
<?php输出：
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_uassoc($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);
Array
(
[a] => 1
<strong> => 2
)</strong>
PHP array_diff_assoc 函数
PHP • llslx520 发表了文章 • 0 个评论 • 852 次浏览 • 2016-11-14 13:30
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名/值对。此函数和array_diff不同的是键名也参与比较。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_assoc($array1, $array2 [, $...])
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回带索引的比较第一个数组与其他数组的差集数组。
五、用法举例：
1、两个数组的比较：
例中可以看出，第一个数组中的元素，只有键值对同时包含在第二个数组中，才不会出现在结果数组中。<?php
$arr1 = array('a'=>'aaa', 'b'=>"bbb", 'c'=>"ccc");
$arr2 = array('a'=>'aaa', 'c'=>"cc", 'bb'=>'bbb');
print_r(array_diff_assoc($arr1, $arr2));输出：Array
(
<strong> => bbb
[c] => ccc
)</strong>
2、三个数组的比较：<strong><?php
$arr1 = array('a'=>'爱E族', 'b'=>"百度", 'c'=>"aiezu.com");
$arr2 = array('a'=>'爱E族', "aiezu.com");
$arr3 = array('b'=>'百度');
print_r(array_diff_assoc($arr1, $arr2, $arr3));
</strong>输出：<strong>Array
(
[c] => aiezu.com
)</strong>
3、array_diff_assoc是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。<strong><?php
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff_assoc($arr1, $arr2));</strong>输出：<strong>Array
(
)</strong> 查看全部
计算出第一个数组与其他数组的差集（考虑键名和键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名/值对。此函数和array_diff不同的是键名也参与比较。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_assoc($array1, $array2 [, $...])
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回带索引的比较第一个数组与其他数组的差集数组。
五、用法举例：
1、两个数组的比较：
例中可以看出，第一个数组中的元素，只有键值对同时包含在第二个数组中，才不会出现在结果数组中。<?php
$arr1 = array('a'=>'aaa', 'b'=>"bbb", 'c'=>"ccc");
$arr2 = array('a'=>'aaa', 'c'=>"cc", 'bb'=>'bbb');
print_r(array_diff_assoc($arr1, $arr2));输出：Array
(
<strong> => bbb
[c] => ccc
)</strong>
2、三个数组的比较：<strong><?php
$arr1 = array('a'=>'爱E族', 'b'=>"百度", 'c'=>"aiezu.com");
$arr2 = array('a'=>'爱E族', "aiezu.com");
$arr3 = array('b'=>'百度');
print_r(array_diff_assoc($arr1, $arr2, $arr3));
</strong>输出：<strong>Array
(
[c] => aiezu.com
)</strong>
3、array_diff_assoc是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。<strong><?php
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff_assoc($arr1, $arr2));</strong>输出：<strong>Array
(
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名/值对。此函数和array_diff不同的是键名也参与比较。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、两个数组的比较：
例中可以看出，第一个数组中的元素，只有键值对同时包含在第二个数组中，才不会出现在结果数组中。
2、三个数组的比较：
3、array_diff_assoc是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。
计算出第一个数组与其他数组的差集（考虑键名和键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名/值对。此函数和array_diff不同的是键名也参与比较。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff_assoc($array1, $array2 [, $...])
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
四、返回值：
返回带索引的比较第一个数组与其他数组的差集数组。
五、用法举例：
1、两个数组的比较：
例中可以看出，第一个数组中的元素，只有键值对同时包含在第二个数组中，才不会出现在结果数组中。
<?php输出：
$arr1 = array('a'=>'aaa', 'b'=>"bbb", 'c'=>"ccc");
$arr2 = array('a'=>'aaa', 'c'=>"cc", 'bb'=>'bbb');
print_r(array_diff_assoc($arr1, $arr2));
Array
(
<strong> => bbb
[c] => ccc
)</strong>
2、三个数组的比较：
<strong><?php输出：
$arr1 = array('a'=>'爱E族', 'b'=>"百度", 'c'=>"aiezu.com");
$arr2 = array('a'=>'爱E族', "aiezu.com");
$arr3 = array('b'=>'百度');
print_r(array_diff_assoc($arr1, $arr2, $arr3));
</strong>
<strong>Array
(
[c] => aiezu.com
)</strong>
3、array_diff_assoc是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。
<strong><?php输出：
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff_assoc($arr1, $arr2));</strong>
<strong>Array
(
)</strong>
PHP array_udiff 函数
PHP • llslx520 发表了文章 • 0 个评论 • 731 次浏览 • 2016-11-14 12:07
一、函数功能：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键值。数组的键名不参与比较，但返回数组中保留键名不变。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff ( $array1, $array2 [, $...], $user_value_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键值差集组成的数组。
五、用法举例：
1、PHP array_udiff 函数工作流程解析：<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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('aiezu', 'b'=>'bb', 'com');
$arr2 = array('a'=>'aa', 'bb', 'c');
$result = array_udiff($arr1, $arr2, "user_value_compare_func");
print_r($result);输出：debug: value bb aiezu 1 #$arr1的排序出重
debug: value com bb 1
debug: value bb aa 1 #$arr2的排序出重
debug: value c bb 1
debug: value aiezu aa 1 #不相等
debug: value aiezu bb -1 #不相等
debug: value aiezu bb -1
debug: value bb aa 1
debug: value bb bb 0 #键值相等，不会出现在返回数组中
debug: value bb com -1
debug: value com bb 1
debug: value com c 1
Array
(
[0] => aiezu
[1] => com
)
2、使用类函数作为键值比较函数找出三个数组的差集：<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>'aiezu.com', "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>1);
$result = array_udiff($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);输出：Array
(
<strong> => aiezu.com
)</strong> 查看全部
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键值。数组的键名不参与比较，但返回数组中保留键名不变。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff ( $array1, $array2 [, $...], $user_value_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键值差集组成的数组。
五、用法举例：
1、PHP array_udiff 函数工作流程解析：<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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('aiezu', 'b'=>'bb', 'com');
$arr2 = array('a'=>'aa', 'bb', 'c');
$result = array_udiff($arr1, $arr2, "user_value_compare_func");
print_r($result);输出：debug: value bb aiezu 1 #$arr1的排序出重
debug: value com bb 1
debug: value bb aa 1 #$arr2的排序出重
debug: value c bb 1
debug: value aiezu aa 1 #不相等
debug: value aiezu bb -1 #不相等
debug: value aiezu bb -1
debug: value bb aa 1
debug: value bb bb 0 #键值相等，不会出现在返回数组中
debug: value bb com -1
debug: value com bb 1
debug: value com c 1
Array
(
[0] => aiezu
[1] => com
)
2、使用类函数作为键值比较函数找出三个数组的差集：<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>'aiezu.com', "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>1);
$result = array_udiff($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);输出：Array
(
<strong> => aiezu.com
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键值。数组的键名不参与比较，但返回数组中保留键名不变。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、PHP array_udiff 函数工作流程解析：
2、使用类函数作为键值比较函数找出三个数组的差集：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键值。数组的键名不参与比较，但返回数组中保留键名不变。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_udiff ( $array1, $array2 [, $...], $user_value_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| $user_value_compare_func | 用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回第一个数组与其他数组的键值差集组成的数组。
五、用法举例：
1、PHP array_udiff 函数工作流程解析：
<?php输出：
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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('aiezu', 'b'=>'bb', 'com');
$arr2 = array('a'=>'aa', 'bb', 'c');
$result = array_udiff($arr1, $arr2, "user_value_compare_func");
print_r($result);
debug: value bb aiezu 1 #$arr1的排序出重
debug: value com bb 1
debug: value bb aa 1 #$arr2的排序出重
debug: value c bb 1
debug: value aiezu aa 1 #不相等
debug: value aiezu bb -1 #不相等
debug: value aiezu bb -1
debug: value bb aa 1
debug: value bb bb 0 #键值相等，不会出现在返回数组中
debug: value bb com -1
debug: value com bb 1
debug: value com c 1
Array
(
[0] => aiezu
[1] => com
)
2、使用类函数作为键值比较函数找出三个数组的差集：
<?php输出：
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>'aiezu.com', "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>1);
$result = array_udiff($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);
Array
(
<strong> => aiezu.com
)</strong>
PHP array_diff 函数
PHP • llslx520 发表了文章 • 0 个评论 • 855 次浏览 • 2016-11-14 11:31
一、函数功能：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名）。比较两到多个数组，找出第一个数组中不包含在其他数组中的键值。数组的键名不参与比较，返回数组中保留键名不变。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff ( $array1, $array2 [, $... ] )
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回一个数组，数组中包含所有第一个数组中不包含在其他任何数组中的键值和对应的键名。
五、用法举例：
1、两个数组的比较：
比较时忽视键名，返回结果中保留键名：<?php
$arr1 = array('aa', 'b'=>'bb', 'aiezu.com');
$arr2 = array('a'=>'aa', 'bb', 'c');
print_r(array_diff($arr1, $arr2));输出：Array
(
[1] => aiezu.com
)
2、三个数组的比较：<?php
$arr1 = array('aa', 'b'=>'爱E族', 'aiezu.com');
$arr2 = array('a'=>'aa');
$arr3 = array('爱E族');
print_r(array_diff($arr1, $arr2, $arr3));输出：Array
(
[1] => aiezu.com
)
3、array_diff()是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。<?php
//爱E族: aiezu.com
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff($arr1, $arr2));输出：Array
(
) 查看全部
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名）。比较两到多个数组，找出第一个数组中不包含在其他数组中的键值。数组的键名不参与比较，返回数组中保留键名不变。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff ( $array1, $array2 [, $... ] )
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回一个数组，数组中包含所有第一个数组中不包含在其他任何数组中的键值和对应的键名。
五、用法举例：
1、两个数组的比较：
比较时忽视键名，返回结果中保留键名：<?php
$arr1 = array('aa', 'b'=>'bb', 'aiezu.com');
$arr2 = array('a'=>'aa', 'bb', 'c');
print_r(array_diff($arr1, $arr2));输出：Array
(
[1] => aiezu.com
)
2、三个数组的比较：<?php
$arr1 = array('aa', 'b'=>'爱E族', 'aiezu.com');
$arr2 = array('a'=>'aa');
$arr3 = array('爱E族');
print_r(array_diff($arr1, $arr2, $arr3));输出：Array
(
[1] => aiezu.com
)
3、array_diff()是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。<?php
//爱E族: aiezu.com
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff($arr1, $arr2));输出：Array
(
) 查看全部
一、函数功能：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名）。比较两到多个数组，找出第一个数组中不包含在其他数组中的键值。数组的键名不参与比较，返回数组中保留键名不变。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、两个数组的比较：
比较时忽视键名，返回结果中保留键名：
2、三个数组的比较：
3、array_diff()是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名）。比较两到多个数组，找出第一个数组中不包含在其他数组中的键值。数组的键名不参与比较，返回数组中保留键名不变。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff ( $array1, $array2 [, $... ] )
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
四、返回值：
返回一个数组，数组中包含所有第一个数组中不包含在其他任何数组中的键值和对应的键名。
五、用法举例：
1、两个数组的比较：
比较时忽视键名，返回结果中保留键名：
<?php输出：
$arr1 = array('aa', 'b'=>'bb', 'aiezu.com');
$arr2 = array('a'=>'aa', 'bb', 'c');
print_r(array_diff($arr1, $arr2));
Array
(
[1] => aiezu.com
)
2、三个数组的比较：
<?php输出：
$arr1 = array('aa', 'b'=>'爱E族', 'aiezu.com');
$arr2 = array('a'=>'aa');
$arr3 = array('爱E族');
print_r(array_diff($arr1, $arr2, $arr3));
Array
(
[1] => aiezu.com
)
3、array_diff()是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。
<?php输出：
//爱E族: aiezu.com
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff($arr1, $arr2));
Array
(
)
PHP数组计算差集系列函数的区别
PHP • llslx520 发表了文章 • 0 个评论 • 1142 次浏览 • 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数组差集计算函数，用来计算一个数组与其他数组的差集。计算类型分为计算键名的差集、计算键值的差集、计算键名/值对的差集三类；计算方式分为系统默认函数计算和使用用户自定义函数计算两种。PHP数组差集计算函数共有8个。
数组差集比较函数功能差异表：
PHP数组计算交集系列函数的区别：http://aiezu.com/article/php_array_intersect_sets.html
二、参数中的自定义函数：
差集比较函数通过比较键名、键值是否想等，把完全相等的剔除掉，从而找出它与其它数组的差集。为了方便大家实现个性化的需求，PHP为部分函数提供了接口，可以使用自定义函数来比较键名、键值是否相等。PHP会传递两个键名给键名自定义比较函数、或者两个键值给自定义键值比较函数，用户可以在自定义比较函数中根据自己的需求进行比较，只需给自定义函数一个整型返回值就行（返回0认为键名或键值相等）。
自定义比较函数举例：
1、使用基础函数方式：
2、使用类的函数方式：
三、用法举例：
1、使用基础自定义函数作为比较函数完整代码：
2、使用类函数作为比较函数完整代码：
3、差集比较函数的工作流程：
这里以array_udiff_uassoc()函数举例解析差集比较函数的工作流程，array_udiff_uassoc()函数是使用自定义函数计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值都使用自定义函数）。
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为部分函数提供了接口，可以使用自定义函数来比较键名、键值是否相等。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 函数
PHP • llslx520 发表了文章 • 0 个评论 • 676 次浏览 • 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 5.0起才支持此函数。关于计算数组交集系列函数的区别请参考：PHP数组计算交集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、两个数组的键名/键值对的交集：
键名和键值的比较都使用自定义函数。
2、比较三个数组中共同的键名/键值对：
找出三个数组的共同的键名/键值对，键名和键值的比较都使用自定义函数。
计算多个数组共同的键名/键值交集（同时考虑键名和键值，键名、键值的比较都使用自定义函数）。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_udiff_uassoc 函数
PHP • llslx520 发表了文章 • 0 个评论 • 964 次浏览 • 2016-11-14 14:25
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值的比较都使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较和键名比较都使用用户自定义函数。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff_uassoc($array1 , $array2[, $...], $user_value_compare_func, $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。只有键名比较返回0，对应的键值才会传递给此自定义函数比较。$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_uassoc 函数工作流程解析：
大体分为3步：1、每个数组key的排序去重；2、判断第一个数组的key是否与其他数组的key相等，如果相等返回0，然后执行第3步；3、判断第2步相等的key对应的值是否相等，相等返回0，此key和对应的值不会再出现在返回数组中，执行第1步比较下一对key。<?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('爱E族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, "user_value_compare_func", "user_key_compare_func");
print_r($result);输出：debug key: 1 vs 0 1 #$arr1的key排序去重
debug key: b vs 1 -1
debug key: 0 vs b -1 #$arr2的key排序去重
debug key: b vs name -1
debug key: 0 vs b -1 #key不相等
debug key: 0 vs 0 0 #key相等，下步比较key对应的键值
debug value: 爱E族 vs aiezu 1 #key对应的键值不相等，key:0，value:爱E族会出现在返回数组中
debug key: b vs 0 -1
debug key: b vs b 0 #key相等，下步比较key对应的键值
debug value: bb vs bb 0 #key对应的键值也相等，$arr1中键b和对应的键值bb不会出现在返回数组中
debug key: 1 vs 0 1
debug key: 1 vs b 1
debug key: 1 vs name 1
Array
(
[0] => 爱E族
[1] => aiezu
)
２、使用类函数作为键值和键名比较函数，找出三个数组的差集：<?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');
$arr3 = array('1'=>'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, $arr3, array("user", "value_compare"), array("user", "key_compare"));
print_r($result);输出：Array
(
[0] => 爱E族
) 查看全部
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值的比较都使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较和键名比较都使用用户自定义函数。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff_uassoc($array1 , $array2[, $...], $user_value_compare_func, $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。只有键名比较返回0，对应的键值才会传递给此自定义函数比较。$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_uassoc 函数工作流程解析：
大体分为3步：1、每个数组key的排序去重；2、判断第一个数组的key是否与其他数组的key相等，如果相等返回0，然后执行第3步；3、判断第2步相等的key对应的值是否相等，相等返回0，此key和对应的值不会再出现在返回数组中，执行第1步比较下一对key。<?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('爱E族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, "user_value_compare_func", "user_key_compare_func");
print_r($result);输出：debug key: 1 vs 0 1 #$arr1的key排序去重
debug key: b vs 1 -1
debug key: 0 vs b -1 #$arr2的key排序去重
debug key: b vs name -1
debug key: 0 vs b -1 #key不相等
debug key: 0 vs 0 0 #key相等，下步比较key对应的键值
debug value: 爱E族 vs aiezu 1 #key对应的键值不相等，key:0，value:爱E族会出现在返回数组中
debug key: b vs 0 -1
debug key: b vs b 0 #key相等，下步比较key对应的键值
debug value: bb vs bb 0 #key对应的键值也相等，$arr1中键b和对应的键值bb不会出现在返回数组中
debug key: 1 vs 0 1
debug key: 1 vs b 1
debug key: 1 vs name 1
Array
(
[0] => 爱E族
[1] => aiezu
)
２、使用类函数作为键值和键名比较函数，找出三个数组的差集：<?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');
$arr3 = array('1'=>'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, $arr3, array("user", "value_compare"), array("user", "key_compare"));
print_r($result);输出：Array
(
[0] => 爱E族
) 查看全部
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值的比较都使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较和键名比较都使用用户自定义函数。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、array_udiff_uassoc 函数工作流程解析：
大体分为3步：1、每个数组key的排序去重；2、判断第一个数组的key是否与其他数组的key相等，如果相等返回0，然后执行第3步；3、判断第2步相等的key对应的值是否相等，相等返回0，此key和对应的值不会再出现在返回数组中，执行第1步比较下一对key。
２、使用类函数作为键值和键名比较函数，找出三个数组的差集：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值的比较都使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较和键名比较都使用用户自定义函数。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_udiff_uassoc($array1 , $array2[, $...], $user_value_compare_func, $user_key_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| $user_value_compare_func | 用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。只有键名比较返回0，对应的键值才会传递给此自定义函数比较。 |
| $user_key_compare_func | 用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_uassoc 函数工作流程解析：
大体分为3步：1、每个数组key的排序去重；2、判断第一个数组的key是否与其他数组的key相等，如果相等返回0，然后执行第3步；3、判断第2步相等的key对应的值是否相等，相等返回0，此key和对应的值不会再出现在返回数组中，执行第1步比较下一对key。
<?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('爱E族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, "user_value_compare_func", "user_key_compare_func");
print_r($result);
debug key: 1 vs 0 1 #$arr1的key排序去重
debug key: b vs 1 -1
debug key: 0 vs b -1 #$arr2的key排序去重
debug key: b vs name -1
debug key: 0 vs b -1 #key不相等
debug key: 0 vs 0 0 #key相等，下步比较key对应的键值
debug value: 爱E族 vs aiezu 1 #key对应的键值不相等，key:0，value:爱E族会出现在返回数组中
debug key: b vs 0 -1
debug key: b vs b 0 #key相等，下步比较key对应的键值
debug value: bb vs bb 0 #key对应的键值也相等，$arr1中键b和对应的键值bb不会出现在返回数组中
debug key: 1 vs 0 1
debug key: 1 vs b 1
debug key: 1 vs name 1
Array
(
[0] => 爱E族
[1] => aiezu
)
２、使用类函数作为键值和键名比较函数，找出三个数组的差集：
<?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');
$arr3 = array('1'=>'aiezu');
$result = array_udiff_uassoc($arr1, $arr2, $arr3, array("user", "value_compare"), array("user", "key_compare"));
print_r($result);
Array
(
[0] => 爱E族
)
PHP array_udiff_assoc 函数
PHP • llslx520 发表了文章 • 0 个评论 • 920 次浏览 • 2016-11-14 14:18
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较使用用户自定义函数，键名比较使用系统默认。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff_assoc($array1, $array2[, $... ], $user_value_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_assoc 的自定义函数工作流程：<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_assoc($arr1, $arr2, "user_value_compare_func");
print_r($result);输出：debug: value 爱E族 aiezu 1 #键名相等但键值不相等，“爱E族”会出现在返回结果中。
debug: value bb bb 0 #键名相等且键值也相等，，“bb”不会出现在返回结果中。
Array
(
[0] => 爱E族
[1] => aiezu #键名不相等，不会提交给user_value_compare_func函数比较键值
)
2、使用类函数作为键值比较函数，找出三个数组的差集：<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array('usage', 'aiezu', '爱E族', 'com');
$arr2 = array('com', '2'=>'爱E族');
$arr3 = array('usage');
$result = array_udiff_assoc($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);输出：Array
(
[1] => aiezu
[3] => com
) 查看全部
计算出第一个数组与其他数组的差集（考虑键名和键值，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较使用用户自定义函数，键名比较使用系统默认。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff_assoc($array1, $array2[, $... ], $user_value_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_assoc 的自定义函数工作流程：<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_assoc($arr1, $arr2, "user_value_compare_func");
print_r($result);输出：debug: value 爱E族 aiezu 1 #键名相等但键值不相等，“爱E族”会出现在返回结果中。
debug: value bb bb 0 #键名相等且键值也相等，，“bb”不会出现在返回结果中。
Array
(
[0] => 爱E族
[1] => aiezu #键名不相等，不会提交给user_value_compare_func函数比较键值
)
2、使用类函数作为键值比较函数，找出三个数组的差集：<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array('usage', 'aiezu', '爱E族', 'com');
$arr2 = array('com', '2'=>'爱E族');
$arr3 = array('usage');
$result = array_udiff_assoc($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);输出：Array
(
[1] => aiezu
[3] => com
) 查看全部
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较使用用户自定义函数，键名比较使用系统默认。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、array_udiff_assoc 的自定义函数工作流程：
2、使用类函数作为键值比较函数，找出三个数组的差集：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键/值对。此函数键值比较使用用户自定义函数，键名比较使用系统默认。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_udiff_assoc($array1, $array2[, $... ], $user_value_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| user_value_compare_func | 用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回第一个数组与其他数组的键名/键值对差集组成的数组。
五、用法举例：
1、array_udiff_assoc 的自定义函数工作流程：
<?php输出：
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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族', 'aiezu', 'b'=>'bb',);
$arr2 = array('name'=>'爱E族', 'b'=>'bb', 'aiezu');
$result = array_udiff_assoc($arr1, $arr2, "user_value_compare_func");
print_r($result);
debug: value 爱E族 aiezu 1 #键名相等但键值不相等，“爱E族”会出现在返回结果中。
debug: value bb bb 0 #键名相等且键值也相等，，“bb”不会出现在返回结果中。
Array
(
[0] => 爱E族
[1] => aiezu #键名不相等，不会提交给user_value_compare_func函数比较键值
)
2、使用类函数作为键值比较函数，找出三个数组的差集：
<?php输出：
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array('usage', 'aiezu', '爱E族', 'com');
$arr2 = array('com', '2'=>'爱E族');
$arr3 = array('usage');
$result = array_udiff_assoc($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);
Array
(
[1] => aiezu
[3] => com
)
PHP array_diff_ukey 函数
PHP • llslx520 发表了文章 • 0 个评论 • 866 次浏览 • 2016-11-14 13:59
一、函数功能：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值，对键名的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_ukey ( $array1, $array2 [, $...], $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、array_diff_ukey 函数工作流程解析：<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_ukey($arr1, $arr2, "user_key_compare_func");
print_r($result);输出：b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，不会在出现在返回数组中
b a 1
b b 0 #键名相等，不会在出现在返回数组中
c a 1
c b 1
c d -1
Array
(
[c] => 3
)
2、使用类中的自定义函数比较三个数组。<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_ukey($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);输出：Array
(
<strong> => 2
)</strong> 查看全部
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值，对键名的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_ukey ( $array1, $array2 [, $...], $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、array_diff_ukey 函数工作流程解析：<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_ukey($arr1, $arr2, "user_key_compare_func");
print_r($result);输出：b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，不会在出现在返回数组中
b a 1
b b 0 #键名相等，不会在出现在返回数组中
c a 1
c b 1
c d -1
Array
(
[c] => 3
)
2、使用类中的自定义函数比较三个数组。<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_ukey($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);输出：Array
(
<strong> => 2
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值，对键名的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、array_diff_ukey 函数工作流程解析：
2、使用类中的自定义函数比较三个数组。
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值，对键名的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff_ukey ( $array1, $array2 [, $...], $user_key_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| $user_key_compare_func | 用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、array_diff_ukey 函数工作流程解析：
<?php输出：
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_ukey($arr1, $arr2, "user_key_compare_func");
print_r($result);
b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，不会在出现在返回数组中
b a 1
b b 0 #键名相等，不会在出现在返回数组中
c a 1
c b 1
c d -1
Array
(
[c] => 3
)
2、使用类中的自定义函数比较三个数组。
<?php输出：
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_ukey($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);
Array
(
<strong> => 2
)</strong>
PHP array_diff_key 函数
PHP • llslx520 发表了文章 • 0 个评论 • 913 次浏览 • 2016-11-14 13:54
一、函数功能：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_key ( $array1 , $array2 [, $...] )
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、两个数组的比较：
只要第一个数组中的key出现在后续数组key中，不管值是不是一样，都不会出现在返回数组中。<?php
$arr1 = array("a"=>"aa", "b"=>"aiezu.com", "c"=>"cc");
$arr2 = array("a"=>false, "aiezu.com", "c"=>"cc");
print_r(array_diff_key($arr1, $arr2));输出：Array
(
<strong> => bb
)</strong>
2、三个数组的比较：<strong><?php
$arr1 = array("a"=>"aa", "b"=>"bb", "c"=>"cc");
$arr2 = array("a"=>false);
$arr3 = array("b"=>'bb');
print_r(array_diff_key($arr1, $arr2, $arr3));</strong>输出：<strong>Array
(
[c] => cc
)</strong>
3、array_diff_key是将数组键强制转换为"string"后进行"==="(全等于)比较：<strong><?php
$arr1 = array(false=>"aa"); #false做为数组键时会自动转换为0
$arr2 = array("0"=>false);
print_r($arr1);
print_r(array_diff_key($arr1, $arr2));</strong>输出：<strong>Array
(
[0] => aa
)
Array
(
)</strong> 查看全部
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_key ( $array1 , $array2 [, $...] )
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、两个数组的比较：
只要第一个数组中的key出现在后续数组key中，不管值是不是一样，都不会出现在返回数组中。<?php
$arr1 = array("a"=>"aa", "b"=>"aiezu.com", "c"=>"cc");
$arr2 = array("a"=>false, "aiezu.com", "c"=>"cc");
print_r(array_diff_key($arr1, $arr2));输出：Array
(
<strong> => bb
)</strong>
2、三个数组的比较：<strong><?php
$arr1 = array("a"=>"aa", "b"=>"bb", "c"=>"cc");
$arr2 = array("a"=>false);
$arr3 = array("b"=>'bb');
print_r(array_diff_key($arr1, $arr2, $arr3));</strong>输出：<strong>Array
(
[c] => cc
)</strong>
3、array_diff_key是将数组键强制转换为"string"后进行"==="(全等于)比较：<strong><?php
$arr1 = array(false=>"aa"); #false做为数组键时会自动转换为0
$arr2 = array("0"=>false);
print_r($arr1);
print_r(array_diff_key($arr1, $arr2));</strong>输出：<strong>Array
(
[0] => aa
)
Array
(
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、两个数组的比较：
只要第一个数组中的key出现在后续数组key中，不管值是不是一样，都不会出现在返回数组中。
2、三个数组的比较：
3、array_diff_key是将数组键强制转换为"string"后进行"==="(全等于)比较：
计算出第一个数组与其他数组的键名差集（只考虑键名，不考虑键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名，返回键名及其对应的值组成的数组。PHP 5.1开始才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff_key ( $array1 , $array2 [, $...] )
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
四、返回值：
返回第一个数组中不包含在其他任何数组中的键名及其对应的值组成的数组。
五、用法举例：
1、两个数组的比较：
只要第一个数组中的key出现在后续数组key中，不管值是不是一样，都不会出现在返回数组中。
<?php输出：
$arr1 = array("a"=>"aa", "b"=>"aiezu.com", "c"=>"cc");
$arr2 = array("a"=>false, "aiezu.com", "c"=>"cc");
print_r(array_diff_key($arr1, $arr2));
Array
(
<strong> => bb
)</strong>
2、三个数组的比较：
<strong><?php输出：
$arr1 = array("a"=>"aa", "b"=>"bb", "c"=>"cc");
$arr2 = array("a"=>false);
$arr3 = array("b"=>'bb');
print_r(array_diff_key($arr1, $arr2, $arr3));</strong>
<strong>Array
(
[c] => cc
)</strong>
3、array_diff_key是将数组键强制转换为"string"后进行"==="(全等于)比较：
<strong><?php输出：
$arr1 = array(false=>"aa"); #false做为数组键时会自动转换为0
$arr2 = array("0"=>false);
print_r($arr1);
print_r(array_diff_key($arr1, $arr2));</strong>
<strong>Array
(
[0] => aa
)
Array
(
)</strong>
PHP array_diff_uassoc 函数
PHP • llslx520 发表了文章 • 0 个评论 • 948 次浏览 • 2016-11-14 13:39
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名的比较使用自定义函数）。比较两到多个数组，返回第一个数组中不包含在其他任何数组中的键名/值对组成的数组。PHP 5才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_uassoc ( $array1 , $array2 [, $...], $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回在第一个数组但不在其他数组的键/值对组成数组。
五、用法举例：
1、array_diff_uassoc 函数工作流程解析：<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_uassoc($arr1, $arr2, "user_key_compare_func");
print_r($result);输出：b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，键值不相等（系统函数去比较），会出现在返回结果中
b a 1
b b 0 #键名相等，键值也相等（系统函数去比较），不会出现在返回结果中
c a 1
c b 1
c d -1
Array
(
[a] => 1
[c] => 3
)
2、使用类中的自定义函数比较三个数组：<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_uassoc($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);输出：Array
(
[a] => 1
<strong> => 2
)</strong> 查看全部
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名的比较使用自定义函数）。比较两到多个数组，返回第一个数组中不包含在其他任何数组中的键名/值对组成的数组。PHP 5才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_uassoc ( $array1 , $array2 [, $...], $user_key_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_key_compare_func用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回在第一个数组但不在其他数组的键/值对组成数组。
五、用法举例：
1、array_diff_uassoc 函数工作流程解析：<?php
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_uassoc($arr1, $arr2, "user_key_compare_func");
print_r($result);输出：b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，键值不相等（系统函数去比较），会出现在返回结果中
b a 1
b b 0 #键名相等，键值也相等（系统函数去比较），不会出现在返回结果中
c a 1
c b 1
c d -1
Array
(
[a] => 1
[c] => 3
)
2、使用类中的自定义函数比较三个数组：<?php
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_uassoc($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);输出：Array
(
[a] => 1
<strong> => 2
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名的比较使用自定义函数）。比较两到多个数组，返回第一个数组中不包含在其他任何数组中的键名/值对组成的数组。PHP 5才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、array_diff_uassoc 函数工作流程解析：
2、使用类中的自定义函数比较三个数组：
计算出第一个数组与其他数组的差集（考虑键名和键值，对键名的比较使用自定义函数）。比较两到多个数组，返回第一个数组中不包含在其他任何数组中的键名/值对组成的数组。PHP 5才支持此函数。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff_uassoc ( $array1 , $array2 [, $...], $user_key_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| $user_key_compare_func | 用户自定义回调函数，用来比较键名。如果认为第一个键名小于，等于，或大于第二个键名时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回在第一个数组但不在其他数组的键/值对组成数组。
五、用法举例：
1、array_diff_uassoc 函数工作流程解析：
<?php输出：
function user_key_compare_func($k1, $k2) {
echo sprintf("%s %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("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "b"=>2, "d"=>3);
$result = array_diff_uassoc($arr1, $arr2, "user_key_compare_func");
print_r($result);
b a 1 #数组$arr1键名排序去重
c b 1
b a 1 #数组$arr2键名排序去重
d b 1
a a 0 #键名相等，键值不相等（系统函数去比较），会出现在返回结果中
b a 1
b b 0 #键名相等，键值也相等（系统函数去比较），不会出现在返回结果中
c a 1
c b 1
c d -1
Array
(
[a] => 1
[c] => 3
)
2、使用类中的自定义函数比较三个数组：
<?php输出：
class user {
function key_compare($k1, $k2) {
if ( $k1 === $k2 ) {
return 0;
}
return $k1 > $k2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>2, "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>3);
$result = array_diff_uassoc($arr1, $arr2, $arr3, array("user", "key_compare"));
print_r($result);
Array
(
[a] => 1
<strong> => 2
)</strong>
PHP array_diff_assoc 函数
PHP • llslx520 发表了文章 • 0 个评论 • 852 次浏览 • 2016-11-14 13:30
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名/值对。此函数和array_diff不同的是键名也参与比较。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_assoc($array1, $array2 [, $...])
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回带索引的比较第一个数组与其他数组的差集数组。
五、用法举例：
1、两个数组的比较：
例中可以看出，第一个数组中的元素，只有键值对同时包含在第二个数组中，才不会出现在结果数组中。<?php
$arr1 = array('a'=>'aaa', 'b'=>"bbb", 'c'=>"ccc");
$arr2 = array('a'=>'aaa', 'c'=>"cc", 'bb'=>'bbb');
print_r(array_diff_assoc($arr1, $arr2));输出：Array
(
<strong> => bbb
[c] => ccc
)</strong>
2、三个数组的比较：<strong><?php
$arr1 = array('a'=>'爱E族', 'b'=>"百度", 'c'=>"aiezu.com");
$arr2 = array('a'=>'爱E族', "aiezu.com");
$arr3 = array('b'=>'百度');
print_r(array_diff_assoc($arr1, $arr2, $arr3));
</strong>输出：<strong>Array
(
[c] => aiezu.com
)</strong>
3、array_diff_assoc是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。<strong><?php
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff_assoc($arr1, $arr2));</strong>输出：<strong>Array
(
)</strong> 查看全部
计算出第一个数组与其他数组的差集（考虑键名和键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名/值对。此函数和array_diff不同的是键名也参与比较。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff_assoc($array1, $array2 [, $...])
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回带索引的比较第一个数组与其他数组的差集数组。
五、用法举例：
1、两个数组的比较：
例中可以看出，第一个数组中的元素，只有键值对同时包含在第二个数组中，才不会出现在结果数组中。<?php
$arr1 = array('a'=>'aaa', 'b'=>"bbb", 'c'=>"ccc");
$arr2 = array('a'=>'aaa', 'c'=>"cc", 'bb'=>'bbb');
print_r(array_diff_assoc($arr1, $arr2));输出：Array
(
<strong> => bbb
[c] => ccc
)</strong>
2、三个数组的比较：<strong><?php
$arr1 = array('a'=>'爱E族', 'b'=>"百度", 'c'=>"aiezu.com");
$arr2 = array('a'=>'爱E族', "aiezu.com");
$arr3 = array('b'=>'百度');
print_r(array_diff_assoc($arr1, $arr2, $arr3));
</strong>输出：<strong>Array
(
[c] => aiezu.com
)</strong>
3、array_diff_assoc是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。<strong><?php
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff_assoc($arr1, $arr2));</strong>输出：<strong>Array
(
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的差集（考虑键名和键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名/值对。此函数和array_diff不同的是键名也参与比较。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、两个数组的比较：
例中可以看出，第一个数组中的元素，只有键值对同时包含在第二个数组中，才不会出现在结果数组中。
2、三个数组的比较：
3、array_diff_assoc是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。
计算出第一个数组与其他数组的差集（考虑键名和键值）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键名/值对。此函数和array_diff不同的是键名也参与比较。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff_assoc($array1, $array2 [, $...])
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
四、返回值：
返回带索引的比较第一个数组与其他数组的差集数组。
五、用法举例：
1、两个数组的比较：
例中可以看出，第一个数组中的元素，只有键值对同时包含在第二个数组中，才不会出现在结果数组中。
<?php输出：
$arr1 = array('a'=>'aaa', 'b'=>"bbb", 'c'=>"ccc");
$arr2 = array('a'=>'aaa', 'c'=>"cc", 'bb'=>'bbb');
print_r(array_diff_assoc($arr1, $arr2));
Array
(
<strong> => bbb
[c] => ccc
)</strong>
2、三个数组的比较：
<strong><?php输出：
$arr1 = array('a'=>'爱E族', 'b'=>"百度", 'c'=>"aiezu.com");
$arr2 = array('a'=>'爱E族', "aiezu.com");
$arr3 = array('b'=>'百度');
print_r(array_diff_assoc($arr1, $arr2, $arr3));
</strong>
<strong>Array
(
[c] => aiezu.com
)</strong>
3、array_diff_assoc是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。
<strong><?php输出：
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff_assoc($arr1, $arr2));</strong>
<strong>Array
(
)</strong>
PHP array_udiff 函数
PHP • llslx520 发表了文章 • 0 个评论 • 731 次浏览 • 2016-11-14 12:07
一、函数功能：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键值。数组的键名不参与比较，但返回数组中保留键名不变。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff ( $array1, $array2 [, $...], $user_value_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键值差集组成的数组。
五、用法举例：
1、PHP array_udiff 函数工作流程解析：<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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('aiezu', 'b'=>'bb', 'com');
$arr2 = array('a'=>'aa', 'bb', 'c');
$result = array_udiff($arr1, $arr2, "user_value_compare_func");
print_r($result);输出：debug: value bb aiezu 1 #$arr1的排序出重
debug: value com bb 1
debug: value bb aa 1 #$arr2的排序出重
debug: value c bb 1
debug: value aiezu aa 1 #不相等
debug: value aiezu bb -1 #不相等
debug: value aiezu bb -1
debug: value bb aa 1
debug: value bb bb 0 #键值相等，不会出现在返回数组中
debug: value bb com -1
debug: value com bb 1
debug: value com c 1
Array
(
[0] => aiezu
[1] => com
)
2、使用类函数作为键值比较函数找出三个数组的差集：<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>'aiezu.com', "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>1);
$result = array_udiff($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);输出：Array
(
<strong> => aiezu.com
)</strong> 查看全部
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键值。数组的键名不参与比较，但返回数组中保留键名不变。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：array array_udiff ( $array1, $array2 [, $...], $user_value_compare_func)
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；$user_value_compare_func用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。
四、返回值：返回第一个数组与其他数组的键值差集组成的数组。
五、用法举例：
1、PHP array_udiff 函数工作流程解析：<?php
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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('aiezu', 'b'=>'bb', 'com');
$arr2 = array('a'=>'aa', 'bb', 'c');
$result = array_udiff($arr1, $arr2, "user_value_compare_func");
print_r($result);输出：debug: value bb aiezu 1 #$arr1的排序出重
debug: value com bb 1
debug: value bb aa 1 #$arr2的排序出重
debug: value c bb 1
debug: value aiezu aa 1 #不相等
debug: value aiezu bb -1 #不相等
debug: value aiezu bb -1
debug: value bb aa 1
debug: value bb bb 0 #键值相等，不会出现在返回数组中
debug: value bb com -1
debug: value com bb 1
debug: value com c 1
Array
(
[0] => aiezu
[1] => com
)
2、使用类函数作为键值比较函数找出三个数组的差集：<?php
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>'aiezu.com', "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>1);
$result = array_udiff($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);输出：Array
(
<strong> => aiezu.com
)</strong> 查看全部
一、函数功能：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键值。数组的键名不参与比较，但返回数组中保留键名不变。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、PHP array_udiff 函数工作流程解析：
2、使用类函数作为键值比较函数找出三个数组的差集：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名，对键值的比较使用自定义函数）。比较两到多个数组，找出第一个数组中不包含在其他任何数组中的键值。数组的键名不参与比较，但返回数组中保留键名不变。关于计算差集系列函数的区别请参考：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_udiff ( $array1, $array2 [, $...], $user_value_compare_func)
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
| $user_value_compare_func | 用户自定义回调函数，用来比较键值。如果认为第一个键值小于，等于，或大于第二个键值时必须分别返回一个小于零，等于零，或大于零的整数。 |
四、返回值：
返回第一个数组与其他数组的键值差集组成的数组。
五、用法举例：
1、PHP array_udiff 函数工作流程解析：
<?php输出：
function user_value_compare_func($v1, $v2) {
echo sprintf("debug: value %s %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('aiezu', 'b'=>'bb', 'com');
$arr2 = array('a'=>'aa', 'bb', 'c');
$result = array_udiff($arr1, $arr2, "user_value_compare_func");
print_r($result);
debug: value bb aiezu 1 #$arr1的排序出重
debug: value com bb 1
debug: value bb aa 1 #$arr2的排序出重
debug: value c bb 1
debug: value aiezu aa 1 #不相等
debug: value aiezu bb -1 #不相等
debug: value aiezu bb -1
debug: value bb aa 1
debug: value bb bb 0 #键值相等，不会出现在返回数组中
debug: value bb com -1
debug: value com bb 1
debug: value com c 1
Array
(
[0] => aiezu
[1] => com
)
2、使用类函数作为键值比较函数找出三个数组的差集：
<?php输出：
class user {
function value_compare($v1, $v2) {
if ( $v1 === $v2 ) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
}
}
$arr1 = array("a"=>1, "b"=>'aiezu.com', "c"=>3);
$arr2 = array("a" =>'aa', "d"=>3);
$arr3 = array('c'=>1);
$result = array_udiff($arr1, $arr2, $arr3, array("user", "value_compare"));
print_r($result);
Array
(
<strong> => aiezu.com
)</strong>
PHP array_diff 函数
PHP • llslx520 发表了文章 • 0 个评论 • 855 次浏览 • 2016-11-14 11:31
一、函数功能：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名）。比较两到多个数组，找出第一个数组中不包含在其他数组中的键值。数组的键名不参与比较，返回数组中保留键名不变。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff ( $array1, $array2 [, $... ] )
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回一个数组，数组中包含所有第一个数组中不包含在其他任何数组中的键值和对应的键名。
五、用法举例：
1、两个数组的比较：
比较时忽视键名，返回结果中保留键名：<?php
$arr1 = array('aa', 'b'=>'bb', 'aiezu.com');
$arr2 = array('a'=>'aa', 'bb', 'c');
print_r(array_diff($arr1, $arr2));输出：Array
(
[1] => aiezu.com
)
2、三个数组的比较：<?php
$arr1 = array('aa', 'b'=>'爱E族', 'aiezu.com');
$arr2 = array('a'=>'aa');
$arr3 = array('爱E族');
print_r(array_diff($arr1, $arr2, $arr3));输出：Array
(
[1] => aiezu.com
)
3、array_diff()是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。<?php
//爱E族: aiezu.com
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff($arr1, $arr2));输出：Array
(
) 查看全部
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名）。比较两到多个数组，找出第一个数组中不包含在其他数组中的键值。数组的键名不参与比较，返回数组中保留键名不变。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：array array_diff ( $array1, $array2 [, $... ] )
三、函数参数：参数名描述$array1参与比较的第一个数组；$array2参与比较的第二个数组；...参与比较的更多数组；
四、返回值：返回一个数组，数组中包含所有第一个数组中不包含在其他任何数组中的键值和对应的键名。
五、用法举例：
1、两个数组的比较：
比较时忽视键名，返回结果中保留键名：<?php
$arr1 = array('aa', 'b'=>'bb', 'aiezu.com');
$arr2 = array('a'=>'aa', 'bb', 'c');
print_r(array_diff($arr1, $arr2));输出：Array
(
[1] => aiezu.com
)
2、三个数组的比较：<?php
$arr1 = array('aa', 'b'=>'爱E族', 'aiezu.com');
$arr2 = array('a'=>'aa');
$arr3 = array('爱E族');
print_r(array_diff($arr1, $arr2, $arr3));输出：Array
(
[1] => aiezu.com
)
3、array_diff()是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。<?php
//爱E族: aiezu.com
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff($arr1, $arr2));输出：Array
(
) 查看全部
一、函数功能：
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名）。比较两到多个数组，找出第一个数组中不包含在其他数组中的键值。数组的键名不参与比较，返回数组中保留键名不变。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、两个数组的比较：
比较时忽视键名，返回结果中保留键名：
2、三个数组的比较：
3、array_diff()是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。
计算出第一个数组与其他数组的键值差集（只考虑键值，不考虑键名）。比较两到多个数组，找出第一个数组中不包含在其他数组中的键值。数组的键名不参与比较，返回数组中保留键名不变。关于计算数组差集系列函数的区别请参考页面：PHP数组计算差集系列函数的区别。
二、函数语法：
array array_diff ( $array1, $array2 [, $... ] )
三、函数参数：
| 参数名 | 描述 |
|---|---|
| $array1 | 参与比较的第一个数组； |
| $array2 | 参与比较的第二个数组； |
| ... | 参与比较的更多数组； |
四、返回值：
返回一个数组，数组中包含所有第一个数组中不包含在其他任何数组中的键值和对应的键名。
五、用法举例：
1、两个数组的比较：
比较时忽视键名，返回结果中保留键名：
<?php输出：
$arr1 = array('aa', 'b'=>'bb', 'aiezu.com');
$arr2 = array('a'=>'aa', 'bb', 'c');
print_r(array_diff($arr1, $arr2));
Array
(
[1] => aiezu.com
)
2、三个数组的比较：
<?php输出：
$arr1 = array('aa', 'b'=>'爱E族', 'aiezu.com');
$arr2 = array('a'=>'aa');
$arr3 = array('爱E族');
print_r(array_diff($arr1, $arr2, $arr3));
Array
(
[1] => aiezu.com
)
3、array_diff()是将数组值强制转换为"string"后进行"==="(全等于)比较：
由于false强制转换为string后为""，数组强制转换为string后为"Array"，所以下面例子运行结果为一个空数组。
<?php输出：
//爱E族: aiezu.com
$arr1 = array("", array(1));
$arr2 = array(false, array(2));
print_r(array_diff($arr1, $arr2));
Array
(
)
PHP数组计算差集系列函数的区别
PHP • llslx520 发表了文章 • 0 个评论 • 1142 次浏览 • 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数组差集计算函数，用来计算一个数组与其他数组的差集。计算类型分为计算键名的差集、计算键值的差集、计算键名/值对的差集三类；计算方式分为系统默认函数计算和使用用户自定义函数计算两种。PHP数组差集计算函数共有8个。
数组差集比较函数功能差异表：
PHP数组计算交集系列函数的区别：http://aiezu.com/article/php_array_intersect_sets.html
二、参数中的自定义函数：
差集比较函数通过比较键名、键值是否想等，把完全相等的剔除掉，从而找出它与其它数组的差集。为了方便大家实现个性化的需求，PHP为部分函数提供了接口，可以使用自定义函数来比较键名、键值是否相等。PHP会传递两个键名给键名自定义比较函数、或者两个键值给自定义键值比较函数，用户可以在自定义比较函数中根据自己的需求进行比较，只需给自定义函数一个整型返回值就行（返回0认为键名或键值相等）。
自定义比较函数举例：
1、使用基础函数方式：
2、使用类的函数方式：
三、用法举例：
1、使用基础自定义函数作为比较函数完整代码：
2、使用类函数作为比较函数完整代码：
3、差集比较函数的工作流程：
这里以array_udiff_uassoc()函数举例解析差集比较函数的工作流程，array_udiff_uassoc()函数是使用自定义函数计算出第一个数组与其他数组的差集（考虑键名和键值，对键名和键值都使用自定义函数）。
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为部分函数提供了接口，可以使用自定义函数来比较键名、键值是否相等。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 函数
PHP • llslx520 发表了文章 • 0 个评论 • 676 次浏览 • 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 5.0起才支持此函数。关于计算数组交集系列函数的区别请参考：PHP数组计算交集系列函数的区别。
二、函数语法：
三、函数参数：
四、返回值：
五、用法举例：
1、两个数组的键名/键值对的交集：
键名和键值的比较都使用自定义函数。
2、比较三个数组中共同的键名/键值对：
找出三个数组的共同的键名/键值对，键名和键值的比较都使用自定义函数。
计算多个数组共同的键名/键值交集（同时考虑键名和键值，键名、键值的比较都使用自定义函数）。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族
)