English
English
In PHP, array_intersect_uassoc() is a powerful but misunderstood function. It is used to compare keys and values of multiple arrays and compare keys through user-defined functions to return the intersection part. However, it is precisely because the way keys are compared can be customized, which raises a potential problem: how to ensure that the comparison is accurate when the key types are different (such as strings and integers)?
Let's quickly review the basic usage of array_intersect_uassoc() :
$result = array_intersect_uassoc(
['1' => 'apple', 2 => 'banana', 3 => 'cherry'],
[1 => 'apple', '2' => 'banana', 3 => 'berry'],
function ($a, $b) {
return strcmp((string)$a, (string)$b);
}
);
print_r($result);
In this example, we use strcmp() to compare keys, note that we explicitly convert the keys to strings. This is to avoid comparison failures caused by different types.
PHP's array keys can be integers or strings, and PHP automatically converts them in certain situations. For example, '1' will automatically be converted to an integer 1. This automatic conversion does not cause problems in most cases, but when using array_intersect_uassoc() , the problem may emerge:
'1' and 1 can be regarded as the same in normal arrays, but are different when compared with strcmp() .
The === operator of PHP requires that both types and values are equal, which makes many developers think that array_intersect_uassoc() does the same.
But in fact, array_intersect_uassoc() relies on the comparison function you pass in, so the result is highly dependent on whether you are aware of the problem of type conversion.
To avoid comparison errors due to different types, the following strategies are recommended:
The safest way is to manually convert the key to the same type (usually a string or an integer) in the comparison function:
function normalize_key_compare($a, $b) {
return strcmp((string)$a, (string)$b);
}
This ensures that '1' and 1 are processed as the same keys.
If you can control the input data, it is best to unify the key type when constructing the array. For example, if you are sure that all keys are numbers, you can write this:
$array1 = [
1 => 'apple',
2 => 'banana',
3 => 'cherry'
];
$array2 = [
1 => 'apple',
2 => 'banana',
3 => 'berry'
];
This way, even if the default strcmp() comparator is used, it will not cause type confusion.
PHP will automatically change '01' to an integer 1, if you want to preserve keys in string form, you must use quotes and make sure that no implicit conversion occurs:
$array = [
'01' => 'value'
];
But once you write:
$array = [
01 => 'value'
];
The key will become an integer 1.
Suppose you have two data sets from different sources, one decoded from JSON and the other from the database. Keys in JSON may be strings, while keys in databases are integers:
$jsonData = json_decode('{"1":"apple","2":"banana"}', true);
$dbData = [
1 => 'apple',
2 => 'banana',
3 => 'cherry'
];
You want to find the intersection of the two, you can handle it like this:
$result = array_intersect_uassoc(
$jsonData,
$dbData,
function ($a, $b) {
return strcmp((string)$a, (string)$b);
}
);
print_r($result);
At this point the output will be:
Array
(
[1] => apple
[2] => banana
)
When using array_intersect_uassoc() , make sure you understand the importance of key comparison mechanism and type consistency. Here are a few key suggestions:
Always be sure of your key type;
Unified types when using comparison functions;
If the results do not meet expectations, first check the type difference of the keys;
If possible, normalize the data structure in advance.
Correct handling of key types can not only avoid potential bugs, but also improve your control over the PHP type system. For more practical tips on PHP array functions, visit https://gitbox.net/php-array-utils .
