Как найти одинаковые строки в php

Code :

My array is like this,

<?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"),

);

?>



You can make it unique for any field like id, name or num.

I have develop this function for same :

<?php

function unique_multidim_array($array, $key) {

    $temp_array = array();

    $i = 0;

    $key_array = array();

   
    foreach(

$array as $val) {

        if (!in_array($val[$key], $key_array)) {

            $key_array[$i] = $val[$key];

            $temp_array[$i] = $val;

        }

        $i++;

    }

    return $temp_array;

}

?>



Now, call this function anywhere from your code,

something like this,

<?php

$details = unique_multidim_array($details,'id');

?>



Output will be like this :

<?php

$details = array(

    0 => array("id"=>"1","name"=>"Mike","num"=>"9876543210"),

    1 => array("id"=>"2","name"=>"Carissa","num"=>"08548596258"),

);

?>

1. In php 7.4 counter $i breaks the function. Removed completely (imo was waste of keystrokes anyway).
2. I added second return value - array of duplicates. So you can take both and compare them (I had to).

Example array (copy-paste from original post):
<?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"),
);
?>

Function:
<?php
function unique_multidim_array($array, $key) : array {
    $uniq_array = array();
    $dup_array = array();
    $key_array = array();

    foreach(

$array as $val) {
        if (!in_array($val[$key], $key_array)) {
            $key_array[] = $val[$key];
            $uniq_array[] = $val;
/*
            # 1st list to check:
            # echo "ID or sth: " . $val['building_id'] . "; Something else: " . $val['nodes_name'] . (...) "n";
*/
        } else {
            $dup_array[] = $val;
/*
            # 2nd list to check:
            # echo "ID or sth: " . $val['building_id'] . "; Something else: " . $val['nodes_name'] . (...) "n";
*/
        }
    }
    return array($uniq_array, $dup_array, /* $key_array */);
}
?>

Usage:
<?php
list($unique_addresses, $duplicates, /* $unique_keys */) = unique_multidim_array($details,'id');
?>

Then:
var_dump($unique_addresses);
or
var_dump($duplicates);
or foreach or whatever. Personally I just echo-ed 1st and then 2nd (both DOUBLE COMMENTED) list in function itself (then copied both to notepad++ and compared them - just to be 100% sure), but in case you want to do something else with it - enjoy :)
Plus - as a bonus - you also get an array of UNIQUE keys you searched for (just uncomment >$key_array< in both: function return and function call code).

From example array code returns:
var_dump($unique_addresses);
array(2) {
  [0]=>
  array(3) {
    ["id"]=>
    string(1) "1"
    ["name"]=>
    string(4) "Mike"
    ["num"]=>
    string(10) "9876543210"
  }
  [1]=>
  array(3) {
    ["id"]=>
    string(1) "2"
    ["name"]=>
    string(7) "Carissa"
    ["num"]=>
    string(11) "08548596258"
  }
}

var_dump($duplicates);
array(1) {
  [0]=>
  array(3) {
    ["id"]=>
    string(1) "1"
    ["name"]=>
    string(6) "Mathew"
    ["num"]=>
    string(9) "784581254"
  }
}

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

$unique_array;
}
?>

And here is a test code:

<?php
class Foo {

    public

$a;

    public function

__construct(int $a) {
        $this->a = $a;
    }
}$array_of_objects = [new Foo(2), new Foo(1), new Foo(3), new Foo(2), new Foo(2), new Foo(1)];$comparator = function (Foo $foo1, Foo $foo2): int {
    return $foo1->a <=> $foo2->a;
};var_dump(array_uunique($array_of_objects, $comparator)); // should output [Foo(2), Foo(1), Foo(3)]
?>

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;
http://sandbox.onlinephpfunctions.com/code/2a9e986690ef8505490489581c1c0e70f20d26d1

$max = 770000; //large enough number within memory allocation
$arr = range(1,$max,3);
$arr2 = range(1,$max,2);
$arr = array_merge($arr,$arr2);

$time = -microtime(true);
$res1 = array_unique($arr);
$time += microtime(true);
echo "deduped to ".count($res1)." in ".$time;
// deduped to 513333 in 1.0876770019531

$time = -microtime(true);
$res2 = array();
foreach($arr as $key=>$val) {   
    $res2[$val] = true;
}
$res2 = array_keys($res2);
$time += microtime(true);
echo "<br />deduped to ".count($res2)." in ".$time;
// deduped to 513333 in 0.054931879043579

    <?php

    $max

= 1000000;

    $arr = range(1,$max,3);

    $arr2 = range(1,$max,2);

    $arr = array_merge($arr,$arr2);
$time = -microtime(true);

    $res1 = array_unique($arr);

    $time += microtime(true);

    echo "deduped to ".count($res1)." in ".$time;

    // deduped to 666667 in 32.300781965256
$time = -microtime(true);

    $res2 = array();

    foreach($arr as $key=>$val) {   

        $res2[$val] = true;

    }

    $res2 = array_keys($res2);

    $time += microtime(true);

    echo "<br />deduped to ".count($res2)." in ".$time;

    // deduped to 666667 in 0.84372591972351
?>

<?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'; // Duplicate$common_stuff    = array_not_unique($raw_array);
var_dump($common_stuff);
?>

<?php
function array_iunique($array) {

    $lowered = array_map('strtolower', $array);

    return array_intersect_key($array, array_unique($lowered));

}
?>

<?php

$max

= 1000000;
$arr = range(1,$max,3);
$arr2 = range(1,$max,2);
$arr = array_merge($arr,$arr2);$time = -microtime(true);
$res1 = array_unique($arr);
$time += microtime(true);

echo

"<br>deduped to ".count($res1)." in ".$time;
// deduped to 666667 in 0.78185796737671
// memory used: 33558528$time = -microtime(true);
$res2 = array_flip(array_flip($arr));
$time += microtime(true);

echo

"<br><br>deduped to ".count($res2)." in ".$time;
// deduped to 666667 in 0.072191953659058
// memory used: 3774873$time = -microtime(true);
$res3 = array();
foreach($arr as $key=>$val) {
    $res3[$val] = true;
}
$res3 = array_keys($res3);
$time += microtime(true);

echo

"<br /><br>deduped to ".count($res3)." in ".$time;
// deduped to 666667 in 0.095494985580444
// memory used: 33558528$time = -microtime(true);
$res4 = array_keys(array_flip($arr));
$time += microtime(true);

echo

"<br /><br>deduped to ".count($res4)." in ".$time;
// deduped to 666667 in 0.05807900428772
// memory used: 33558528

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
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

"<pre>".print_r(array_unique_kempty($myArray),true)."</pre>";/*
Array
(
    [test1] => aaa
    [test2] =>
    [test3] =>
    [test4] => bbb
    [test5] =>
    [test6] => ccc
    [test7] => ddd
    [test8] =>
)
*/
?>

<?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');
        }
    }
?>

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

  foreach (

$result as $key => $value)
  {
    if ( is_array($value) )
    {
      $result[$key] = super_unique($value);
    }
  }

  return

$result;
}
?>

<?php

$array

= array("hello", "fine", "good", "fine", "hello", "bye");
$get_sorted_unique_array = array_values(array_unique($array));
?>



The above code returns an array which is both unique and sorted from zero.

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

    foreach(

$obj as $n => $f ) {
        if( !array_key_exists( $n, $objArray ) ) unset( $obj->$n );
    }

    return

$obj;
}
?>

And these code:

<?php
class Test{
    public $pr0 = 'string';
    public $pr1 = 'string1';
    public $pr2 = 'string';
    public $pr3 = 'string2';
}$obj = new Test;var_dump( object_unique( $obj ) );
?>

returns:
object(Test)[1]
  public 'pr0' => string 'string' (length=6)
  public 'pr1' => string 'string1' (length=7)
  public 'pr3' => string 'string2' (length=7)

<?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]);

       
    }

    return

$entrega;

}

?>

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));

}

?>



This works faster for small and big arrays.

<?php

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

?>



Output:

Array ( [0] => a [1] => b [2] => c [3] => d [4] => e [5] => f )

<?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"]); }

      }
?>



Array $attribs is an array contaning arrays. Each array in the $attrib array consists in multiple fields (ex: name, lenght, price, etc.) to be more simpler in speech think that $attrib is the array resulted by a search sql query done by a visitator on your online shoopping website ... (so ... each array in the $attrib is a product :P) if you want to sort only the uniq results use the above or use this:

<?php
/* Our Array of products */

   $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",

                        );
/* The nice stuff */
$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); // $new is our sorted array
?>



Have fun tweaking this ;)) i know you will ;))

From Romania With Love

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

Example:
<?php
/* example object */
class myObj {
  public $id;
  public $value;
  function __construct( $id, $value ) {
    $this->id = $id;
    $this->value = $value;
  }
}/* callback function */
function uniquecol( $obj ) {
  static $idlist = array();

  if (

in_array( $obj->id, $idlist ) )
    return false;$idlist[] = $obj->id;
  return true;   
}/* a couple of arrays with second array having an element with same id as the first */
$list  = array( new myObj( 1, 1  ), new myObj( 2, 100 ) );
$list2 = array( new myObj( 1, 10 ), new myObj( 3, 100 ) );
$list3 = array_merge( $list, $list2 );$unique = array_filter( $list3, 'uniquecol' );
print_r( $list3 );
print_r( $unique );?>

In addition, use array_merge( $unique ) to reindex.

<?php

$array

= array(
    'a' => array(1, 2),
    'b' => array(1, 2),
    'c' => array(2, 2),
    'd' => array(2, 1),
    'e' => array(1, 1),
);$array = array_map('json_encode', $array);
$array = array_unique($array);
$array = array_map('json_decode', $array);print_r($array);?>

As you can see "b" will be removed without any errors or notices.

<?php

function arrayUniqueElements($array)

{

return array_unique(array_diff_assoc($array1,array_unique($array1)));

};

?>



Example:

<?php

$arr1 = array('foo', 'bar', 'xyzzy', '&', 'xyzzy',

'baz', 'bat', '|', 'xyzzy', 'plugh',

'xyzzy', 'foobar', '|', 'plonk', 'xyzzy',

'apples', '&', 'xyzzy', 'oranges', 'xyzzy',

'pears','foobar');
$result=arrayUniqueElements($arr1);

print_r($result);exit;

?>



Output:

Array

(

[4] => xyzzy

[12] => |

[16] => &

[21] => foobar

)

<?php

function array_unique2(&$aray) {

    $aHash = array();

    foreach ($aray as $key => &$val) if (@$aHash[$val]++) unset ($aray[$key]);

}

?>



It is also adaptable to multi dimensional arrays.  For example, if your array is a sequence of (multidimensional) points, then in place of @$aHash[$val]++ you could use @$aHash[implode("X",$val)]++

If you want to not have holes in your array, you can do an array_merge($aray) at the end.

Csaba Gabor

<?php

$a

= [true, false, null, '', '0', '123', 0, 123];
foreach (['SORT_REGULAR', 'SORT_NUMERIC', 'SORT_STRING', 'SORT_LOCALE_STRING'] as $flag) {
    $a_new = array_unique($a, constant($flag));
    echo "{$flag} ==> ";
    var_dump($a_new);
}/*

Gives :

SORT_REGULAR ==> array(2) {
  [0]=> bool(true)
  [1]=> bool(false)
}
SORT_NUMERIC ==> array(3) {
  [0]=> bool(true)
  [1]=> bool(false)
  [5]=> string(3) "123"
}
SORT_STRING ==> array(4) {
  [0]=> bool(true)
  [1]=> bool(false)
  [4]=> string(1) "0"
  [5]=> string(3) "123"
}
SORT_LOCALE_STRING ==> array(4) {
  [0]=> bool(true)
  [1]=> bool(false)
  [4]=> string(1) "0"
  [5]=> string(3) "123"
}

*/

    public static function

dedupe_array_of_objets(array $array, string $property) : array
    {
        $i = 0;
        $filteredArray = array();
        $keyArray = array();

        foreach(

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);
}?>

var_dump(array_unique([$a, $b, $b, $a], SORT_REGULAR));
//array(1) {
//  [0]=>
//    object(stdClass)#1 (0) {
//  }
//}

$a->name = 'One';
$b->name = 'Two';

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

//array(2) {
//  [0]=>
//  object(stdClass)#1 (1) {
//    ["name"]=>
//    string(3) "One"
//  }
//  [1]=>
//  object(stdClass)#2 (1) {
//    ["name"]=>
//    string(3) "Two"
//  }
//}

<?php

function arrayUnique($myArray)

{

    if(!is_array($myArray))

           return $myArray;

    foreach (

$myArray as &$myvalue){

        $myvalue=serialize($myvalue);

    }
$myArray=array_unique($myArray);

    foreach (

$myArray as &$myvalue){

        $myvalue=unserialize($myvalue);

    }

    return

$myArray;

}

?>

<?php
function in_iarray($str, $a) {

    foreach ($a as $v) {

        if (strcasecmp($str, $v) == 0) {

            return true;

        }

    }

    return false;

}

function

array_iunique($a) {

    $n = array();

    foreach ($a as $k => $v) {

        if (!in_iarray($v, $n)) {

            $n[$k]=$v;

        }

    }

    return $n;

}
$input = array("aAa","bBb","cCc","AaA","ccC","ccc","CCC","bBB","AAA","XXX");

$result = array_iunique($input);

print_r($result);
/*

Array

(

    [0] => aAa

    [1] => bBb

    [2] => cCc

    [9] => XXX

)

*/

?>

<?php
// Fruits, vegetables, and other food:

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

?>

I would like to find a way to contactenate the two

fields, and then return only unique values for the

array.  For example, if the database query returns

three instances of a record with the FirstName John

and the LastName Smith in two distinct fields, I would

like to build a new array that would contain all the

original fields, but with John Smith in it only once.

Thanks for: Colin Campbell

Solution:

<?php

/**

* The same thing than implode function, but return the keys so

*

* <code>

* $_GET = array('id' => '4587','with' => 'key');

* ...

* echo shared::implode_with_key('&',$_GET,'='); // Resultado: id=4587&with=key

* ...

* </code>

*

* @param string $glue Oque colocar entre as chave => valor

* @param array $pieces Valores

* @param string $hifen Separar chave da array do valor

* @return string

* @author memandeemail at gmail dot com

*/

function implode_with_key($glue = null, $pieces, $hifen = ',') {

  $return = null;

  foreach ($pieces as $tk => $tv) $return .= $glue.$tk.$hifen.$tv;

  return substr($return,1);

}
/**

* Return unique values from a tree of values

*

* @param array $array_tree

* @return array

* @author memandeemail at gmail dot com

*/

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));

?>