Code :

<?php
$details = array(
0 => array("id"=>"1", "name"=>"Mike", "num"=>"9876543210"),
1 => array("id"=>"2", "name"=>"Carissa", "num"=>"08548596258"),
2 => array("id"=>"1", "name"=>"Mathew", "num"=>"784581254"),
);
?>

I have develop this function for same :

something like this,

<?php

$a

1. In php 7.4 counter $i breaks the function. Removed completely (imo was waste of keystrokes anyway).

Example array (copy-paste from original post):

Function:

Usage:

From example array code returns:

var_dump($duplicates);

Plus keys, if you want.

P.S.: in my - practical - case of DB querying I got around 4k uniques and 15k dupes :)

<?php
function array_uunique(array $array, callable $comparator): array {
$unique_array = [];
do {
$element = array_shift($array);
$unique_array[] = $element;$array = array_udiff(
$array,
[$element],
$comparator
);
} while (count($array) > 0);

return

public function

<?php

$max

In PHP7 there were significant changes to Packed and Immutable arrays resulting in the performance difference to drop considerably. Here is the same test on php7.1 here;

$max = 770000; //large enough number within memory allocation

$time = -microtime(true);

$time = -microtime(true);

<?php
function obj_multi_unique($obj, $key = false)
{
$totalObjs = count($obj);
if (is_array($obj) && $totalObjs > 0 && is_object($obj[0]) && ($key && !is_numeric($key))) {
for ($i = 0; $i < $totalObjs; $i++) {
if (isset($obj[$i])) {
for ($j = $i + 1; $j < $totalObjs; $j++) {
if (isset($obj[$j]) && $obj[$i]->{$key} === $obj[$j]->{$key}) {
unset($obj[$j]);
}
}
}
}
return array_values($obj);
} else {
throw new Exception('Invalid argument or your array of objects is empty');
}
}
?>

<?phpfunction array_not_unique($raw_array) {
$dupes = array();
natcasesort($raw_array);
reset ($raw_array);$old_key = NULL;
$old_value = NULL;
foreach ($raw_array as $key => $value) {
if ($value === NULL) { continue; }
if ($old_value == $value) {
$dupes[$old_key] = $old_value;
$dupes[$key] = $value;
}
$old_value = $value;
$old_key = $key;
}
return $dupes;
}$raw_array = array();
$raw_array[1] = 'abc@xyz.com';
$raw_array[2] = 'def@xyz.com';
$raw_array[3] = 'ghi@xyz.com';
$raw_array[4] = 'abc@xyz.com'; $common_stuff = array_not_unique($raw_array);
var_dump($common_stuff);
?>

var_dump(array_unique([$a, $b, $b, $a], SORT_REGULAR));

$a->name = 'One';

var_dump(array_unique([$a, $b, $b, $a], SORT_REGULAR));

//array(2) {

<?php
function array_unique_kempty($array) {
$values = array_unique($array);
$return = array_combine(array_keys($array), array_fill(0,count($array),null));
return array_merge($return,$values);
}$myArray = [
"test1" => "aaa",
"test2" => null,
"test3" => "aaa",
"test4" => "bbb",
"test5" => null,
"test6" => "ccc",
"test7" => "ddd",
"test8" => "ccc"
];

echo

<?php function array_iunique($array) {
$lowered = array_map('strtolower', $array);
return array_intersect_key($array, array_unique($lowered));
} ?>

<?php function in_iarray($str, $a) {
foreach ($a as $v) {
if (strcasecmp($str, $v) == 0) {
return true;
}
}
return false;
}

function

<?php
function object_unique( $obj ){
$objArray = (array) $obj;$objArray = array_intersect_assoc( array_unique( $objArray ), $objArray );

foreach(

return

<?php

$array

<?php
function arrayUnique($myArray)
{
if(!is_array($myArray))
return $myArray;

foreach (

foreach (

return

}

<?php
function remove_dup($matriz) {
$aux_ini=array();
$entrega=array();
for($n=0;$n<count($matriz);$n++)
{
$aux_ini[]=serialize($matriz[$n]);
}
$mat=array_unique($aux_ini);
for($n=0;$n<count($matriz);$n++)
{ $entrega[]=unserialize($mat[$n]);

}

<?php
function super_unique($array)
{
$result = array_map("unserialize", array_unique(array_map("serialize", $array)));

foreach (

return

It simply compares the number of elements between the original array and the array_uniqued array.

<?php function array_has_duplicates(array $array)
{
$uniq = array_unique($array);
return count($uniq) != count($array);
} ?>

<?php
$alpha=array('a','b','c','a','b','d','e','f','f'); $alpha= array_keys(array_count_values($alpha)); print_r($alpha);
?>

<?php
$new = array();
$exclude = array("");
for ($i = 0; $i<=count($attribs)-1; $i++) {
if (!in_array(trim($attribs[$i]["price"]) ,$exclude)) { $new[] = $attribs[$i]; $exclude[] = trim($attribs[$i]["price"]); }
} ?>

<?php $attribs[] = array(
"name" => "Test Product 1",
"length" => "42 cm",
"weight" => "0,5 kg",
"price" => "10 $",
"stock" => "100",
); $attribs[] = array(
"name" => "Test Product 2",
"length" => "42 cm",
"weight" => "1,5 kg",
"price" => "10 $",
"stock" => "200",
); $new = array();
$exclude = array("");
for ($i = 0; $i<=count($attribs)-1; $i++) {
if (!in_array(trim($attribs[$i]["price"]) ,$exclude)) { $new[] = $attribs[$i]; $exclude[] = trim($attribs[$i]["price"]); }
} print_r($new); ?>

From Romania With Love

Example:

<?php

$max

echo

echo

echo

echo

<?php

$array

<?php
$multi_array = $multi_array [0];
$multi_array = array_unique($multi_array);
print_r($multi_array);
?>

<?php $var = array('apple','banana','carrot','cat','dog','egg','eggplant','fish'); $var = array_values(array_unique($var));
?>

<?php
function arrayUniqueElements($array)
{
return array_unique(array_diff_assoc($array1,array_unique($array1)));
};
?>

Array

You can do a super fast version of array_unique directly in PHP, even faster than the other solution posted in the comments!

Compared to the built in function it is 20x faster! (2x faster than the solution in the comments).

<?php
function superfast_array_unique($array) {
return array_keys(array_flip($array));
}
?>

I would like to find a way to contactenate the two

Solution:

<?php
function implode_with_key($glue = null, $pieces, $hifen = ',') {
$return = null;
foreach ($pieces as $tk => $tv) $return .= $glue.$tk.$hifen.$tv;
return substr($return,1);
} function array_unique_tree($array_tree) {
$will_return = array(); $vtemp = array();
foreach ($array_tree as $tkey => $tvalue) $vtemp[$tkey] = implode_with_key('&',$tvalue,'=');
foreach (array_keys(array_unique($vtemp)) as $tvalue) $will_return[$tvalue] = $array_tree[$tvalue];
return $will_return;
} $problem = array_fill(0,3,
array('FirstName' => 'John', 'LastName' => 'Smith')
); $problem[] = array('FirstName' => 'Davi', 'LastName' => 'S. Mesquita');
$problem[] = array('FirstName' => 'John', 'LastName' => 'Tom'); print_r($problem); print_r(array_unique_tree($problem));
?>

So I wrote this function that creates a string representation of the enums and use the array keys to remove duplicates:

<?phpfunction array_unique_81(array $values): array
{
$unique = [];
foreach ($values as $value) {
if ($value instanceof \UnitEnum) {
$key = 'e:' . \get_class($value) . ':' . $value->name;
} else {
$key = 's:' . (string)$value;
}
$unique[$key] = $value;
}
return \array_values($unique);
}?>

<?phpfunction array_unique_multi(array $array, string $key): array
{
$unique = [];
foreach ($array as $v) {
if (!array_key_exists($v[$key], $unique)) {
$unique[$v[$key]] = $v;
}
}
return array_values($unique);
}$unique = array_unique_multi($users, 'id');?>

<?phpfunction array_unique_amulti(array $array, string $key): array
{
$keys = [];
$unique = [];
foreach ($array as $k => $v) {
if (!isset($keys[$v[$key]])) {
$keys[$v[$key]] = true;
$unique[$k] = $v;
}
}
return $unique;
}?>

<?php
function array_unique2(&$aray) {
$aHash = array();
foreach ($aray as $key => &$val) if (@$aHash[$val]++) unset ($aray[$key]);
}
?>

Csaba Gabor