function a()
{
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_uassoc($array1, $array2, "comp_func");
var_dump($result);
}
function x()
{
}
array_filter($a, 'x');
array_filter($a, 'Y::x');
array_filter($a, 'X::x');
array_filter($a, array($a, 'x2'));
class Y
{
static function x()
{
}
static function x2()
{
}
static function x3()
{
}
function z()
{
array_filter($a, array($this, 'x'));
}
}
$result = array_diff_uassoc($array1, $array2, $array3, $array4, 'Y2::x2');
$result = array_diff_uassoc($array1, $array2, $array3, $array4, 'X2::x2');
class Y2
{
static function x2()
{
}
}
* Description: Computes the difference of arrays with additional index check which is performed by a
* user supplied callback function
* Source code: ext/standard/array.c
*/
echo "*** Testing array_diff_uassoc() : error conditions ***\n";
//Initialize array
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$array3 = array("a" => "green", "red");
$array4 = array();
$extra_arg = array(1, 2, 3, 4);
function key_compare_func($a, $b)
{
if ($a === $b) {
return 0;
}
return $a > $b ? 1 : -1;
}
//Test array_diff_uassoc with one more than the expected number of arguments
echo "\n-- Testing array_diff_uassoc() function with more than expected no. of arguments --\n";
var_dump(array_diff_uassoc($array1, $array2, "key_compare_func", $extra_arg));
var_dump(array_diff_uassoc($array1, $array2, $array3, $array4, "key_compare_func", $extra_arg));
// Testing array_diff_uassoc with one less than the expected number of arguments
echo "\n-- Testing array_diff_uassoc() function with less than expected no. of arguments --\n";
var_dump(array_diff_uassoc($array1, $array2));
// Testing array_diff_uassoc with no arguments
echo "\n-- Testing array_diff_uassoc() function with no arguments --\n";
var_dump(array_diff_uassoc());
?>
===DONE===
<?php
/* Prototype : array array_diff_uassoc(array arr1, array arr2 [, array ...], callback key_comp_func)
* Description: Computes the difference of arrays with additional index check which is performed by a
* user supplied callback function
* Source code: ext/standard/array.c
*/
echo "*** Testing array_diff_uassoc() : usage variation ***\n";
//Initialize variables
$arr_float = array(0 => 1.0, 1.0 => 2.0);
$arr_string_int = array('1', '2');
$arr_string_float = array('0' => '1.00', '1.00' => '2.00');
function key_compare_func($key1, $key2)
{
if ($key1 === $key2) {
return 0;
}
return $key1 > $key2 ? 1 : -1;
}
echo "\n-- Result of comparing floating points and strings containing integers --\n";
var_dump(array_diff_uassoc($arr_float, $arr_string_int, "key_compare_func"));
var_dump(array_diff_uassoc($arr_string_int, $arr_float, "key_compare_func"));
echo "\n-- Result of comparing floating points and strings containing floating point --\n";
var_dump(array_diff_uassoc($arr_float, $arr_string_float, "key_compare_func"));
var_dump(array_diff_uassoc($arr_string_float, $arr_float, "key_compare_func"));
?>
===DONE===
{
function x()
{
$a++;
}
}
class Yparent
{
static function x()
{
}
}
$result = array_diff_uassoc($array1, $array2, $array3, $array4, array('Y2', "parent::{$x4}"));
$result = array_diff_uassoc($array1, $array2, $array3, $array4, array('X2', "parent::{$x4}"));
$result = array_diff_uassoc($array1, $array2, $array3, $array4, array('Z2', "parent::{$x4}"));
$result = array_diff_uassoc($array1, $array2, $array3, $array4, array('Y2', 'x3'));
array_walk($array, array('X2', "parent::{$x4}"));
array_walk($array, array('Y2', "parent::{$x4}"));
array_walk($array, array('Z2', "parent::{$x4}"));
class Y2 extends Y2parent
{
static function x2()
{
}
}
class Y2parent
{
static function x3()
{
}
}
/**
* Perform a recursive array diff
*
* Necessary starting in PHP 5.4; see https://bugs.php.net/bug.php?id=60278
*
* @param mixed $a
* @param mixed $b
* @return int
*/
public static function arrayDiffRecursive($a, $b)
{
if (is_array($a) && is_array($b)) {
return array_diff_uassoc($a, $b, sprintf('%s::arrayDiffRecursive', __CLASS__));
}
if ($a === $b) {
return 0;
}
return $a > $b ? 1 : -1;
}
<?php
$names = file(realpath($argv[1]), FILE_IGNORE_NEW_LINES);
echo "And the WINNER is... " . array_rand(array_flip(array_filter(array_reverse(array_column(array_chunk(array_intersect($names, array_replace($names, array_change_key_case(array_fill_keys($names, 'Rick Astley')))), (int) @array_pop(array_fill(array_reduce(array_keys($names), function ($c, $a) {
return $a;
}), array_unshift($names, 'Rick Astley'), '1 true love'))), array_sum(array_diff_ukey(array_intersect_key(array_diff_assoc(array_uintersect($names, array_intersect_assoc(array_uintersect_assoc($names, array_values($names), function ($a, $b) {
return $b > $a;
}), $names), function ($a, $b) use($names) {
return array_shift($names) > $b;
}), array()), array_uintersect_uassoc($names, array_udiff($names, array_diff($names, array_slice(array_merge(array_diff_uassoc(array_udiff_uassoc($names, $names, function ($a, $b) {
return $b > $a;
}, function ($a, $b) {
return $b > $a;
}), $names, function ($a, $b) {
return $a > $b;
}), array_combine($names, $names)), array_product($names), array_search(array_unique(array_count_values(array_merge_recursive($names, array_pad(array_replace_recursive($names, array_intersect_uassoc($names, $names, function ($a, $b) {
return $a > $b;
})), array_key_exists((int) array_walk($names, function ($v, $k) {
return $k;
}), $names), array_walk_recursive($names, function ($v, $k) {
return $k;
}))))), $names))), function ($a, $b) {
return $a > $b;
}), function ($a, $b) {
return $b > $a;
}, function ($a, $b) {
return $b > $a;
})), array_splice($names, array_multisort(array_map(function ($v) {
return $v;
}, array_intersect_ukey(array_diff_key($names, array_udiff_assoc($names, $names, function ($a, $b) {
return $a > $b;
/**
* (PHP 5)<br/>
* Computes the difference of arrays with additional index check which is performed by a user supplied callback function
* @link http://php.net/manual/en/function.array-diff-uassoc.php
* @param array $array2 <p>
* An array to compare against
* </p>
* @param array $_ [optional] <p>
* More arrays to compare against
* </p>
* @param callable $key_compare_func <p>
* The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.
* </p>
* int<b>callback</b><b>mixed<i>a</i></b><b>mixed<i>b</i></b>
* @return array an array containing all the entries from
* <i>array1</i> that are not present in any of the other arrays.
*/
public function diff_uassoc(array $array2, array $_ = null, callable $key_compare_func)
{
// TODO: use func_get_args() for multiple arguments, like Arr($array)->function($v1, $v2, $v3)
return array_diff_uassoc($this->array, $array2, $key_compare_func);
}
/**
* Get key-value pairs which exist in one array but not in another,
* where both keys and values determine uniqueness.
*
* Returns an associative array containing all key-value pairs which
* exist in the first array but not in the second. Optionally provide
* comparison functions for the keys and values. String comparison is
* used by default.
*
* @param array $array1
* @param array $array2
* @param callable|null $key_cmp
* @param callable|null $value_cmp
* @return array
*/
public static function pairDifference($array1, $array2, $key_cmp = null, $value_cmp = null)
{
// Seriously, PHP? seriously?
if ($key_cmp === null) {
if ($value_cmp === null) {
return array_diff_assoc($array1, $array2);
} else {
return array_udiff_assoc($array1, $array2, $value_cmp);
}
} else {
if ($value_cmp === null) {
return array_diff_uassoc($array1, $array2, $key_cmp);
} else {
return array_udiff_uassoc($array1, $array2, $value_cmp, $key_cmp);
}
}
}
<?php /* Prototype : array array_diff_uassoc(array arr1, array arr2 [, array ...], callback key_comp_func) * Description: Computes the difference of arrays with additional index check which is performed by a * user supplied callback function * Source code: ext/standard/array.c */ echo "*** Testing array_diff_uassoc() : usage variation ***\n"; // Initialise function arguments not being substituted (if any) $input_array = array(0 => '0', 1 => '1', -10 => '-10', 'true' => 1, 'false' => 0); $boolean_indx_array = array(true => 'boolt', false => 'boolf', TRUE => 'boolT', FALSE => 'boolF'); echo "\n-- Testing array_diff_key() function with float indexed array --\n"; var_dump(array_diff_uassoc($input_array, $boolean_indx_array, "strcasecmp")); var_dump(array_diff_uassoc($boolean_indx_array, $input_array, "strcasecmp")); ?> ===DONE===
<?php
function cmpUsed($a, $b)
{
return true;
}
function cmpUsedFullnspath($a, $b)
{
return true;
}
function cmpNotUsed($a, $b)
{
return true;
}
array_diff_uassoc(range(1, 10), range(1, 10), range(1, 10), range(1, 10), range(1, 10), 'cmpUsed');
array_uintersect(range(1, 10), range(1, 10), range(1, 10), range(1, 10), range(1, 10), '\\cmpUsedFullnspath');
array_udiff_assoc(range(1, 10), range(1, 10), range(1, 10), range(1, 10), range(1, 10), '\\cmp\\b');
/*
function callableArguments ($a, Callable $b) { var_dump($b); }
Notuasort(range(1,10), 'cmpNot');
callableArguments(1, 'cmp3');
*/
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4, 18);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8, 9, 8);
var_dump(array_diff_key($array1, $array2));
?>
</div>
<h3><code>array</code> array_diff_uassoc(<code>array $array1, $array2 [, array $...], callable $key_compare_func</code>) <span class="badge">5+</span></h3>
<div><?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
var_dump(array_diff_uassoc($array1, $array2, function ($a, $b) {
echo "/ {$a} {$b} /";
if ($a === $b) {
return 0;
}
return $a > $b ? 1 : -1;
}));
?>
</div>
<h3><code>array</code> array_diff_ukey(<code>array $array1, $array2 [, array $...], callable $key_compare_func</code>) <span class="badge">5.1+</span></h3>
<div><?php
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
var_dump(array_diff_ukey($array1, $array2, function ($k1, $k2) {
echo "/ {$k1} {$k2} /";
if ($k1 == $k2) {
/**
* @param HTArray $array2
* @param $key_compare_func
* @return $this
* @desc 通过用户提供的回调函数做索引检查来计算数组的差集。
*/
public function array_diff_uassoc(HTArray $array2, $key_compare_func)
{
$this->current = array_diff_uassoc($this->current, (array) $array2, $key_compare_func);
return $this;
}
<?php
set_exception_handler(function ($a1) {
});
array_filter($a, function ($a2) {
});
$result = array_diff_uassoc($array1, $array2, $array3, $array4, function ($a3) {
});
$result = array_diff_uassoc($array1, $array2, $array3, function ($a4) {
});
$result = array_diff_uassoc($array1, $array2, $array3, $array4, $array5, function ($a5) {
});
array_walk($array, function ($a6) {
});
print function ($a7) {
};
{
$this->priv_member = $val;
}
function comp_func_cr($a, $b)
{
if ($a->priv_member === $b->priv_member) {
return 0;
}
return $a->priv_member > $b->priv_member ? 1 : -1;
}
function comp_func_key($a, $b)
{
if ($a === $b) {
return 0;
}
return $a > $b ? 1 : -1;
}
}
$a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1 => new cr(4), 2 => new cr(-15));
$b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1 => new cr(4), 2 => new cr(-15));
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
print_r(array_udiff($a, $b, array("cr", "comp_func_cr")));
print_r(array_udiff_assoc($a, $b, array("cr", "comp_func_cr")));
print_r(array_udiff_uassoc($a, $b, array("cr", "comp_func_cr"), array("cr", "comp_func_key")));
print_r(array_diff_uassoc($array1, $array2, "key_compare_func"));
print "------------------------------------\n";
print_r(array_uintersect($a, $b, array("cr", "comp_func_cr")));
print_r(array_uintersect_assoc($a, $b, array("cr", "comp_func_cr")));
print_r(array_uintersect_uassoc($a, $b, array("cr", "comp_func_cr"), array("cr", "comp_func_key")));
print_r(array_intersect_uassoc($array1, $array2, "key_compare_func"));
<?php
// array_diff_uassoc.php
$week = ["Monday" => "Rāhina", "Tuesday" => "Rātū", "Wednesday" => "Rāapa", "Thursday" => "Rāpare", "Friday" => "Rāmere", "Saturday" => "Rāhoroi", "Sunday" => "Rātapu"];
$weekend = ["Saturday" => "Rāhoroi", "Sunday" => "Rātapu"];
$weekdays = array_diff_uassoc($week, $weekend, function ($v1, $v2) {
echo "{$v1}:{$v2}<br>";
if ($v1 == $v2) {
return 0;
}
return $v1 > $v2 ? 1 : -1;
});
echo "<pre>";
var_dump($weekdays);
echo "</pre>";
<?php
/* Prototype : array array_diff_uassoc(array arr1, array arr2 [, array ...], callback key_comp_func)
* Description: Computes the difference of arrays with additional index check which is performed by a
* user supplied callback function
* Source code: ext/standard/array.c
*/
echo "*** Testing array_diff_uassoc() : usage variation ***\n";
//Initialize array
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
class classWithoutToString
{
}
// Define error handler
function test_error_handler($err_no, $err_msg, $filename, $linenum, $vars)
{
if (error_reporting() != 0) {
// report non-silenced errors
echo "Error: {$err_no} - {$err_msg}, {$filename}({$linenum})\n";
}
}
set_error_handler('test_error_handler');
$value = new classWithoutToString();
var_dump(array_diff_uassoc($array1, $array2, $value));
?>
===DONE===
public function diff_using_keys_values_and_callback($aArray, $callback)
{
if ($aArray instanceof MF_PHP_Array) {
$aArray =& $aArray->to_array();
}
$oReturn = new MF_PHP_Array(array_diff_uassoc($this->__data, $aArray, $callback));
return $oReturn;
}
//resource variable
$fp = fopen(__FILE__, "r");
// define some classes
class classWithToString
{
public function __toString()
{
return "Class A object";
}
}
class classWithoutToString
{
}
// heredoc string
$heredoc = <<<EOT
hello world
EOT;
// add arrays
$index_array = array(1, 2, 3);
$assoc_array = array('one' => 1, 'two' => 2);
//array of values to iterate over
$inputs = array('int 0' => 0, 'int 1' => 1, 'int 12345' => 12345, 'int -12345' => -12345, 'float 10.5' => 10.5, 'float -10.5' => -10.5, 'float 12.3456789000e10' => 123456789000.0, 'float -12.3456789000e10' => -123456789000.0, 'float .5' => 0.5, 'uppercase NULL' => NULL, 'lowercase null' => null, 'lowercase true' => true, 'lowercase false' => false, 'uppercase TRUE' => TRUE, 'uppercase FALSE' => FALSE, 'empty string DQ' => "", 'empty string SQ' => '', 'string DQ' => "string", 'string SQ' => 'string', 'mixed case string' => "sTrInG", 'heredoc' => $heredoc, 'instance of classWithToString' => new classWithToString(), 'instance of classWithoutToString' => new classWithoutToString(), 'undefined var' => @$undefined_var, 'unset var' => @$unset_var, 'resource' => $fp);
// loop through each element of the array for arr2
foreach ($inputs as $key => $value) {
echo "\n--{$key}--\n";
var_dump(array_diff_uassoc($array1, $array2, $value, "key_compare_func"));
}
fclose($fp);
?>
===DONE===
<?php /* Prototype : array array_diff_uassoc(array arr1, array arr2 [, array ...], callback key_comp_func) * Description: Computes the difference of arrays with additional index check which is performed by a * user supplied callback function * Source code: ext/standard/array.c */ echo "*** Testing array_diff_uassoc() : usage variation ***\n"; // Initialise function arguments not being substituted (if any) $input_array = array(0 => '0', 10 => '10', -10 => '-10', 20 => '20', -20 => '-20'); $float_indx_array = array(0.0 => '0.0', 10.5 => '10.5', -10.5 => '-10.5', 0.5 => '0.5'); echo "\n-- Testing array_diff_key() function with float indexed array --\n"; var_dump(array_diff_uassoc($input_array, $float_indx_array, "strcasecmp")); var_dump(array_diff_uassoc($float_indx_array, $input_array, "strcasecmp")); ?> ===DONE===
<?php
//Comparing both keys and values
$serviceList1 = array('10001' => 'Hair Cutting', '10002' => 'Facial');
$serviceList2 = array(10001 => 'Hair Cutting', '10002' => 'Facial New');
$newArr = array_diff_assoc($serviceList1, $serviceList2);
//var_dump($newArr);
/*
* array (size=1)
10002 => string 'Facial' (length=6)
*/
function myfunction($a, $b)
{
if ($a === $b) {
return 0;
}
return $a > $b ? 1 : -1;
}
$result = array_diff_uassoc($serviceList1, $serviceList2, "myfunction");
print_r($result);
public function diffKeyValue($diffarray, $funcName = null)
{
if ($funcName == null) {
$this->__invar = array_diff_assoc($this->__invar, $diffarray);
} else {
$this->__invar = array_diff_uassoc($this->__invar, $diffarray, $funcName);
}
return $this;
}
<?php
function key_compare_func($a, $b)
{
if ($a === $b) {
return 0;
}
return $a > $b ? 1 : -1;
}
$array1 = array("a" => "green", "b" => "Brown", 'c' => 'blue', 0 => 'red');
$array2 = array("a" => "green", "b" => "Brown", 'c' => 'blue', 0 => 'red');
$result = array_diff_uassoc($array1, $array2, "key_compare_func");
print_r($result);
<?php
/* Prototype : array array_diff_uassoc(array arr1, array arr2 [, array ...], callback key_comp_func)
* Description: Computes the difference of arrays with additional index check which is performed by a
* user supplied callback function
* Source code: ext/standard/array.c
*/
echo "*** Testing array_diff_uassoc() : usage variation ***\n";
//Initialize variables
$arr_default_int = array(1, 2, 3, 4);
$arr_float = array(0 => 1.0, 1.0 => 2.0, 2.0 => 3.0, 3.0 => 4.0);
function key_compare_func($key1, $key2)
{
if ($key1 === $key2) {
return 0;
}
return $key1 > $key2 ? 1 : -1;
}
echo "\n-- Result of comparing integers and floating point numbers --\n";
var_dump(array_diff_uassoc($arr_default_int, $arr_float, "key_compare_func"));
var_dump(array_diff_uassoc($arr_float, $arr_default_int, "key_compare_func"));
?>
===DONE===
<?php
/* Prototype : array array_diff_uassoc(array arr1, array arr2 [, array ...], callback key_comp_func)
* Description: Computes the difference of arrays with additional index check which is performed by a
* user supplied callback function
* Source code: ext/standard/array.c
*/
echo "*** Testing array_diff_uassoc() : usage variation ***\n";
// Initialise function arguments not being substituted (if any)
$input_array = array(10 => '10', "" => '');
//get an unset variable
$unset_var = 10;
unset($unset_var);
$input_arrays = array('null indexed' => array(NULL => NULL, null => null), 'undefined indexed' => array(@$undefined_var => @$undefined_var), 'unset indexed' => array(@$unset_var => @$unset_var));
foreach ($input_arrays as $key => $value) {
echo "\n--{$key}--\n";
var_dump(array_diff_uassoc($input_array, $value, "strcasecmp"));
var_dump(array_diff_uassoc($value, $input_array, "strcasecmp"));
}
?>
===DONE===
<?php
/* Prototype : array array_diff_uassoc(array arr1, array arr2 [, array ...], callback key_comp_func)
* Description: Computes the difference of arrays with additional index check which is performed by a
* user supplied callback function
* Source code: ext/standard/array.c
*/
echo "*** Testing array_diff_uassoc() : usage variation ***\n";
//Initialize variables
$ref_var = 'a';
$array1 = array('a', $ref_var);
$array2 = array('a' => 1, &$ref_var);
echo "\n-- Testing array_diff_uassoc() function with referenced variable \$ref_var has value '{$ref_var}' --\n";
var_dump(array_diff_uassoc($array1, $array2, "strcasecmp"));
var_dump(array_diff_uassoc($array2, $array1, "strcasecmp"));
// re-assign reference variable to different value
$ref_var = 10.0;
echo "\n-- Testing array_diff_uassoc() function with referenced variable \$ref_var value changed to {$ref_var} --\n";
var_dump(array_diff_uassoc($array1, $array2, "strcasecmp"));
var_dump(array_diff_uassoc($array2, $array1, "strcasecmp"));
//When array are refenced
$array2 =& $array1;
echo "\n-- Testing array_diff_uassoc() function when \$array2 is referenced to \$array1 --\n";
var_dump(array_diff_uassoc($array1, $array2, "strcasecmp"));
var_dump(array_diff_uassoc($array2, $array1, "strcasecmp"));
?>
===DONE===
