PHP array_unique(): Remove Duplicate Values

array_unique($array) returns the array with duplicate values removed. The first occurrence of each value stays, under its original key, and the later copies are dropped.

<?php
$tags = ["php", "arrays", "php", "tips", "arrays", "php"];

$unique = array_unique($tags);
print_r($unique);

print_r(array_values($unique)); // renumbered 0, 1, 2

The first result keeps the keys 0, 1, 3: the positions where each value first appeared. Wrap the call in array_values() when you want a clean list, for example before json_encode.

How array_unique decides two values are the same

By default each value is converted to a string and the strings are compared. So 1, "1" and 1.0 count as the same value, and the first one wins. The second argument changes the comparison.

<?php
$mixed = [1, "1", 1.0, true, "01", 2];

var_dump(array_unique($mixed));                // compared as strings
var_dump(array_unique($mixed, SORT_REGULAR));  // compared with ==
var_dump(array_unique(["10", "1e1", "010"], SORT_NUMERIC));

With the default, "01" survives because the string "01" is not the string "1". With SORT_REGULAR it is dropped, because "01" == 1 is true. Loose comparison also lets the boolean true match any non-empty value. Check the output before you rely on it with mixed types; the comparison operators page explains the rules.

Remove duplicates ignoring case

array_unique is case-sensitive: "PHP" and "php" are different. To treat them as duplicates but keep the original spelling of the first one, find the unique keys on a lowercased copy and keep those keys from the original.

<?php
$languages = ["PHP", "Python", "php", "Go", "python", "GO", "Rust"];

$keys = array_unique(array_map('strtolower', $languages));
$result = array_values(array_intersect_key($languages, $keys));

print_r($result);

array_map builds a lowercased copy with the same keys, array_unique keeps the keys of the first occurrences, and array_intersect_key picks those keys out of the original array. For accented or Japanese text, use mb_strtolower in place of strtolower.

array_unique on a multidimensional array

Without a flag, array_unique converts every row to the string "Array", so all rows look identical and only the first survives, with an "Array to string conversion" warning for every row. Pass SORT_REGULAR to compare whole rows. To keep one row per value of a single field, array_column with null and an index key is simpler.

<?php
$signups = [
    ["email" => "ada@example.com", "plan" => "free"],
    ["email" => "bob@example.com", "plan" => "pro"],
    ["email" => "ada@example.com", "plan" => "free"],
    ["email" => "ada@example.com", "plan" => "pro"],
];

// Exact duplicate rows removed
print_r(array_unique($signups, SORT_REGULAR));

// One row per email: the last row for each email wins
print_r(array_values(array_column($signups, null, 'email')));

The second approach keeps the last row for each email because each later row overwrites the earlier one under the same key. The array_column page explains the index key in detail.

Find and count duplicate values

array_count_values() returns how many times each value appears. Filter that for counts above one and you have the duplicates.

<?php
$votes = ["red", "blue", "red", "green", "blue", "red"];

$counts = array_count_values($votes);
print_r($counts);

$duplicates = array_keys(array_filter($counts, fn($n) => $n > 1));
echo "Duplicated: " . implode(", ", $duplicates) . "\n";

echo count($votes) === count(array_unique($votes))
    ? "No duplicates\n"
    : "Has duplicates\n";

The last check is a common one-liner to test whether an array has any duplicates at all.

Faster unique values for large arrays

array_unique converts every value to a string before comparing, which is fine for thousands of values. For a large list of integers or strings, flipping the array is faster: values become keys, and keys are unique by definition.

<?php
$ids = [];
for ($i = 0; $i < 200000; $i++) {
    $ids[] = $i % 1000;
}

$start = hrtime(true);
$a = array_unique($ids);
$t1 = (hrtime(true) - $start) / 1e6;

$start = hrtime(true);
$b = array_keys(array_flip($ids));
$t2 = (hrtime(true) - $start) / 1e6;

echo count($a), " unique values with array_unique\n";
echo count($b), " unique values with array_keys(array_flip())\n";
printf("array_unique: %.1f ms, array_flip: %.1f ms\n", $t1, $t2);

The timings change from run to run, but the flip version is usually several times faster. It only works for values that can be array keys (integers and strings), and numeric strings such as "5" come back as integers.