How to remove values from an array if occurring more than one time?

Question

I need to remove values from an array that occur more than one time in the array.

For example:

$value = array(10,10,5,8);

I need this result:

$value = array(5,8);

Is there any in-built function in php?

I tried this, but this will not return my expected result:

$unique = array_unique($value);
$dupes = array_diff_key($value, $unique);

Answer 1

You can use array functions and ditch the foreach loops if you wish:

Here is a one-liner:

Code:

$value = [10, 10, 5, 8];
var_export(array_keys(array_intersect(array_count_values($value),[1])));

As multi-line:

var_export(
    array_keys(
        array_intersect(
            array_count_values($value),
            [1]
        )
    )
);

Output:

array (
  0 => 5,
  1 => 8,
)

This gets the value counts as an array, then uses array_intersect() to only retain values that occur once, then turns the keys into the values of a zero-index array.

The above snippet works identically to @modsfabio's and @axiac's answers. The ONLY advantage in my snippet is brevity. It is possible that their solutions may outperform mine, but judging speed on relatively small data sets may be a waste of dev time. For anyone processing relatively large data sets, do your own benchmarking to find the technique that works best.

---

For lowest computational/time complexity, use a single loop and as you iterate conditionally populate a lookup array and unset() as needed.

Code: (Demo) (Crosslink to my CodeReview answer)

$values = [10, 10, 5, 8];

$found = [];
foreach ($values as $index => $value) {
    if (!isset($found[$value])) {
        $found[$value] = $index;
    } else {
        unset($values[$index], $values[$found[$value]]);
    }
}
var_export($values);
// [2 => 5, 3 => 8]

A couple of notes:

1. If processing float values, using a technique that stores the values as keys (as all of my snippets do), then the results may be incorrect because php will change floats to integers when used as keys.
2. PHP is consistently much faster at searching for keys than it is at searching for values.