The array_unique() function can be used to get unique values ??in a PHP array, using loose comparisons by default and retaining the first occurrence of key names. 1. Use array_unique($array) to deduplicate directly, but do not distinguish types by default, such as "1" and 1 are considered the same; 2. Adding the second parameter SORT_REGULAR can enable strict comparison; 3. The function retains the original key name by default and only removes duplicate values; 4. Deduplication logic can be implemented manually to support more complex scenarios, such as by traversing the array and using in_array($value, $seen, true) to make strict judgments.

When you want to get unique values ??from PHP arrays, there is actually a very direct way - use PHP's built-in array_unique() function. It can help you quickly remove duplicates in the array and return a new array containing only unique values. However, you may not pay much attention to some details, such as how it handles different types of data, whether key names are retained, etc.

How to use array_unique Basic usage

array_unique() is the most commonly used method, and the syntax is as follows:

 array_unique($array);

It will iterate over each element in the array. If the value is found to be repeated, only the first occurrence will be retained, and the subsequent ones will be removed. By default, comparisons are loose (that is, they do not strictly compare types), so "1" and 1 will be considered the same.

For example:

 $values ??= [1, '1', 2, 3, 2];
$unique = array_unique($values);

// Output: [0 => 1, 2 => 2, 3 => 3]
print_r($unique);

You can see that although 1 and '1' types are different, they are considered the same because of the default comparison method. If you want to distinguish types, you can add a second parameter:

 array_unique($values, SORT_REGULAR);

This will make strict comparisons to avoid unexpected results caused by type conversion.

What should I do if I want to keep the key value corresponding?

Sometimes you not only want unique values, but also want to keep the original key. The good news is: array_unique() is the key reserved by default. That is to say, the key names in the returned array will not be reordered, but the duplicate values ??are removed.

for example:

 $data = ['a' => 10, 'b' => 10, 'c' => 20];
$result = array_unique($data);

// Output: ['a' => 10, 'c' => 20]
print_r($result);

As can be seen, although the value of 'b' is the same as 'a' , 'a' is retained and 'b' is removed. Note this: the first key-value pair that appears is retained .

Other methods? It can also be implemented manually

Of course, if you want to write logic yourself to control more granular behavior, you can also do deduplication by traversing the array:

 function getUniqueValues($array) {
    $seen = [];
    $result = [];

    foreach ($array as $key => $value) {
        if (!in_array($value, $seen, true)) {
            $seen[] = $value;
            $result[$key] = $value;
        }
    }

    return $result;
}

This function uses an intermediate array $seen to record the values ??that have appeared, and enables strict comparison by setting the third parameter of in_array() to true . This method is very useful when you need to customize the deduplication logic, such as deduplication based on a certain property of the object.

Let's summarize

• Use array_unique() to be the simplest and most efficient
• The default is loose comparison, and you can switch to strict mode if needed.
• The key name will be retained, and the duplicate value will only retain the first one
• It is not difficult to implement by yourself, and it is suitable for situations with special needs.

Basically all is it. Although the function is simple, it is easy to get stuck if you use it incorrectly.

The above is the detailed content of how to get unique values from a php array. For more information, please follow other related articles on the PHP Chinese website!