Why does array_flip() lose data? Problems caused by duplicate parsing values

M66 2025-05-14

In PHP programming, array_flip() is a commonly used function that can pair keys and values of an array. However, many developers may encounter the problem of "data loss" during use, especially when there are duplicate values in the array. So, what's going on? This article will explain the behavior of array_flip() in detail and use examples to help you understand the principles behind it.

1. What is array_flip()?

array_flip() is a built-in array function in PHP, used to swap keys and values in an array. The basic syntax is as follows:

 array_flip(array $array): array

Its function is to compare each key and value in the input array, the original value becomes the new key, and the original key becomes the new value.

Example:

 $input = [
    'a' => 'apple',
    'b' => 'banana',
    'c' => 'cherry'
];

$result = array_flip($input);

print_r($result);

The output is:

 Array
(
    [apple] => a
    [banana] => b
    [cherry] => c
)

It can be seen that the keys and values were successfully reciprocated without any problems.

2. Where the problem occurs: duplicate values

What happens to array_flip() when there are duplicate values in the original array?

Let’s take a look at an example:

 $input = [
    'a' => 'apple',
    'b' => 'banana',
    'c' => 'apple'
];

$result = array_flip($input);

print_r($result);

Output:

 Array
(
    [banana] => b
    [apple] => c
)

There is an important detail here: it turns out that apple is the values of a and c , but in the end it only retains the pair of c => apple . This means a => apple is discarded.

3. Why is this happening?

In PHP, the keys of the array are unique. When array_flip() turns the value into a key, if multiple values are the same, a "key conflict" will occur. PHP will overwrite the previous value with the subsequent value , which will lead to data loss.

Continuing with the example just now, the process of executing array_flip() is as follows:

a => apple → apple => a
b => banana → banana => b
c => apple → apple => c ( overwrite previous apple => a )

So only apple => c is retained in the final result, and the original apple => a is overwritten.

4. How to avoid data loss?

If you need to "key-value swap" the array but cannot accept data loss, you can consider the following solutions:

Method 1: Manually process duplicate values

Use the value as the key in the array, and the value becomes an array, retaining all the original keys.

 $input = [
    'a' => 'apple',
    'b' => 'banana',
    'c' => 'apple'
];

$result = [];

foreach ($input as $key => $value) {
    if (!isset($result[$value])) {
        $result[$value] = [];
    }
    $result[$value][] = $key;
}

print_r($result);

Output:

 Array
(
    [apple] => Array
        (
            [0] => a
            [1] => c
        )

    [banana] => Array
        (
            [0] => b
        )
)

This not only avoids data loss, but also allows you to clearly see which keys correspond to the same value.

5. Things to note in real scenes

For example, when processing a configuration table, map the database field to the front-end field:

 $mapping = [
    'username' => 'user',
    'email' => 'user',
    'address' => 'location'
];

$flipped = array_flip($mapping);

print_r($flipped);

Output:

 Array
(
    [user] => email
    [location] => address
)

You might have hoped that both user => username and user => email are reserved, but in fact only user => email is left, and the others are covered. In this case, it is recommended to use the aforementioned "value to array" practice to avoid logical errors.

6. Summary

array_flip() will pair keys and values;
If there are duplicate values in the original array, a "key conflict" will occur;
The array keys in PHP must be unique, so the latter one will overwrite the previous one, resulting in data loss;
The value can be converted to a key manually and the original key is saved in an array to preserve all information.

array_flip