How to deal with key name overwrite issues caused by array_change_key_case()?

M66 2025-04-28

In PHP, the array_change_key_case() function is used to convert the key names of an array to lowercase or uppercase. This is useful when dealing with inconsistent key names, especially in scenarios where data is fetched from external data sources such as APIs or forms.

But you may encounter a common problem: key names are duplicated when converting case, causing data to be overwritten . This brings the risk of data loss, especially when you are dealing with data sources with irregular key names such as user-submitted parameters, configuration files, or JSON data.

1. Problem recurs

Let's look at a simple example:

 $data = [
    'UserID' => 123,
    'userid' => 456
];

$result = array_change_key_case($data, CASE_LOWER);

print_r($result);

Output:

 Array
(
    [userid] => 456
)

As you can see, after the 'UserID' and 'userid' in the original array are uniformly lowercase, a key name conflict occurs, and the result is that only the latter value is retained, and the former is overwritten.

2. Solution

Method 1: Manually check the duplicate key (recommended)

One method is to detect possible conflicts before unifying the case of key names and make corresponding processing:

 function safe_change_key_case(array $array, int $case = CASE_LOWER): array {
    $seen = [];
    $result = [];

    foreach ($array as $key => $value) {
        $transformedKey = ($case === CASE_LOWER) ? strtolower($key) : strtoupper($key);

        if (isset($seen[$transformedKey])) {
            // Key name conflict，Processing strategies：jump over / merge / Throw exceptions, etc.
            echo "Warning: Key '{$key}' conflicts with '{$seen[$transformedKey]}'.\n";
            continue;
        }

        $seen[$transformedKey] = $key;
        $result[$transformedKey] = $value;
    }

    return $result;
}

// test
$data = [
    'UserID' => 123,
    'userid' => 456
];

$result = safe_change_key_case($data);

print_r($result);

You can decide on the handling strategies when conflicts are discovered based on specific business needs, such as logging, throwing exceptions, or merging data.

Method 2: Keep the original key name (as metadata)

If you can't tolerate losing any key value, you can save all the information in a more structured way:

 $data = [
    'UserID' => 123,
    'userid' => 456
];

$transformed = [];

foreach ($data as $key => $value) {
    $lowerKey = strtolower($key);
    if (!isset($transformed[$lowerKey])) {
        $transformed[$lowerKey] = [];
    }
    $transformed[$lowerKey][$key] = $value;
}

print_r($transformed);

Output:

 Array
(
    [userid] => Array
        (
            [UserID] => 123
            [userid] => 456
        )
)

This way you can keep all the original key values of conflict at the same time and handle them flexibly in subsequent use.

Method 3: Standardize the data source

The fundamental way to avoid problems is to normalize the key names before receiving data , such as using lowercase or underscore-style key names in front-end or API responses.

For example, if you control the data structure returned by the interface, you can set the parameters to force unified format on the server or front-end.

 $url = "https://m66.net/api/userinfo?userid=123";
// Returns the standardized key name data through the interface

3. Summary

array_change_key_case() is a very practical function, but you must be careful about the problem that case conversion may cause key name conflicts when using it. You can avoid data loss by manually processing, structured storage, or canonical data entry.

It is recommended to try to unify the data structure and naming style in large projects to avoid similar problems and improve the readability and stability of the code.

array_change_key_case