как устранить повторяющиеся значения [duplicate]

Просто используйте параметр SORT_REGULAR в качестве второго параметра.

  $ uniqueArray = array_unique ($ array, SORT_REGULAR);   

Как говорят люди array_unique () очень медленно, вот фрагмент, который я использую для одномерного многомерного массива.

  $ serialized_array = array_map ("сериализовать  ", $ input);  foreach ($ serialized_array как $ key = & gt; $ val) {$ result [$ val] = true;  } $ output = array_map ("unserialize", (array_keys ($ result)));   

Ссылка, сделанная первым пользователем, посвященная array_unique () странице функции в php.net

Если «удалить дубликаты» означает «удалить дубликаты, но пусть один там», решение может заключаться в том, чтобы сначала применить array_unique (...) в столбце «идентификатор», а затем удалить в исходном массиве все ключи, которые были удалены из массива столбцов:

  $ array = [['id' = & gt;  '123', 'foo' = & gt;  'aaa', 'bar' = & gt;  'bbb'], ['id' = & gt;  '123', 'foo' = & gt;  'ccc', 'bar' = & gt;  'ddd'], ['id' = & gt;  '567', 'foo' = & gt;  'eee', 'bar' = & gt;  'fff']];  $ ids = array_column ($ array, 'id');  $ ids = array_unique ($ ids);  $ array = array_filter ($ array, function ($ key, $ value) use ($ ids) {return in_array ($ value, array_keys ($ ids));}, ARRAY_FILTER_USE_BOTH);   

Результат:

  Массив ([0] = & gt; Массив ([id] = & gt; 123 [foo] = & gt; aaa [  bar] = & gt; bbb) [2] = & gt; Массив ([id] = & gt; 567 [foo] = & gt; eee [bar] = & gt; fff))  

Альтернатива сериализации и уникальности

  $ test = [['abc', 'def'], ['ghi', 'jkl'],  ['mno', 'pql'], ['abc', 'def'], ['ghi', 'jkl'], ['mno', 'pql'],];  $ result = array_reduce ($ test, function ($ carry, $ item) {if (! in_array ($ item, $ carry)) {array_push ($ carry, $ item);} return $ carry;}, []);  var_dump ($ результат);  / * php unique.php array (3) {[0] = & gt;  array (2) {[0] = & gt;  строка (3) "abc" [1] = & gt;  string (3) "def"} [1] = & gt;  array (2) {[0] = & gt;  строка (3) "ghi" [1] = & gt;  string (3) "jkl"} [2] = & gt;  array (2) {[0] = & gt;  string (3) "mno" [1] = & gt;  string (3) "pql"}}  

* /

Легко читаемое решение, возможно, не самое эффективное:

  function arrayUnique ($ myArray) {if (! is_array ($ myArray)) возвращает $ myArray;  foreach ($ myArray as & amp; $ myvalue) {$ myvalue = serialize ($ myvalue);  } $ myArray = array_unique ($ myArray);  foreach ($ myArray as & amp; $ myvalue) {$ myvalue = unserialize ($ myvalue);  } return $ myArray;  }  

Начиная с 5.2.9 вы можете использовать array_unique () , если вы используете флаг SORT_REGULAR следующим образом:

  array_unique ($ array  , SORT_REGULAR);   

Это делает функцию сравнения элементов для равенства, как если бы использовались $ a == $ b , что идеально подходит для вашего случая.

Выход

  Массив ([0] = & gt; Массив ([0] = & gt; abc [1] = & gt; def) [1] = & gt; Массив ([0] =  & gt; ghi [1] = & gt; jkl) [2] = & gt; Массив ([0] = & gt; mno [1] = & gt; pql))  

Имейте в виду, хотя заявляет в документации :

array_unique () не предназначен для работы с многомерными массивами.

, если у вас есть такой массив:

(пользователи - это имя массива)

  Array = & gt;  [0] = & gt;  (массив) 'user' = & gt;  'john' 'age' = & gt;  '23' [1] = & gt;  (массив) 'user' = & gt;  'jane' 'age' = & gt;  '20' [2] = & gt;  (массив) 'user' = & gt;  'john' 'age' = & gt;  '23'  

и вы хотите удалить дубликаты ... then:

  $ serialized = array ();  for ($ i = 0; $ i & lt; sizeof ($ users); $ i ++) {$ test = in_array ($ users ['user'], $ serialized);  if ($ test == false) {$ serialized [] = $ users ['user'];  }}  

может быть решением: P

Многие спрашивали меня, как сделать уникальный многомерный массив. Я взял ссылку с вашего комментария, и мне это помогает.

Прежде всего, спасибо @jeromegamez @daveilers для вашего решения. Но каждый раз, когда я давал ответ, они спрашивали меня, как это «сериализовать» и «неэриализовать». Вот почему я хочу поделиться с вами причиной этого, чтобы он помог большему количеству людей понять концепцию, стоящую за этим.

Я объясняю, почему мы используем «serialize» и «unserialize» в шагах:

Шаг 1: Преобразование многомерного массива в одномерный массив

To преобразовать многомерный массив в одномерный массив, сначала сгенерировать представление потока байтов всех элементов (включая вложенные массивы) внутри массива. Функция serialize () может генерировать представление байтового потока значения. Чтобы генерировать представление байтов по всем элементам, вызовите функцию serialize () внутри функции array_map () как функцию обратного вызова. Результат будет одномерным массивом независимо от того, сколько уровней имеет многомерный массив.

Шаг 2: Сделайте уникальные значения

Чтобы сделать этот одномерный массив уникальным, используйте array_unique ( ).

Шаг 3: Верните его в многомерный массив

. Хотя массив теперь уникален, значения выглядят как представление потока байтов. Чтобы вернуть его обратно к многомерному массиву, используйте функцию unserialize ().

  $ input = array_map («unserialize», array_unique (array_map («serialize», $ input)));   

Еще раз спасибо за все это.

Пользовательские комментарии к документации array_unique () имеют много решений. Вот один из них:

kenrbnsn at rbnsn dot com 27-Sep-2005 12:09

Еще один массив Array_Unique для многоразмерных массивов. Я тестировал это только на двухэтапных массивах, но, возможно, это было бы обобщено для большего количества или было бы использовано для рекурсии.

Эта функция использует функции serialize, array_unique и unserialize для выполнения этой работы.

  function multi_unique ($ array) {foreach ($ array as $ k => $ na) $ new [$ k] = serialize ($ na);  $ uniq = array_unique ($ new);  foreach ($ uniq as $ k => $ ser) $ new1 [$ k] = unserialize ($ ser);  return ($ new1);  }  

Это из http://ca3.php.net/manual/en/function.array-unique.php#57202 .

У меня была аналогичная проблема, но я нашел для нее 100% -ное рабочее решение.

  & lt;? php function super_unique ($ array, $ key) {$ temp_array = [];  foreach ($ array as & amp; $ v) {if (! isset ($ temp_array [$ v [$ key]])) $ temp_array [$ v [$ key]] = & amp;  $ V;  } $ array = array_values ​​($ temp_array);  return $ array;  } $ arr = "";  $ Обр [0] [ 'ID'] = 0;  $ Обр [0] [ 'TITEL'] = "ABC";  $ Обр [1] [ 'ID'] = 1;  $ Обр [1] [ 'TITEL'] = "DEF";  $ Обр [2] [ 'ID'] = 2;  $ Обр [2] [ 'TITEL'] = "ABC";  $ Обр [3] [ 'ID'] = 3;  $ Обр [3] [ 'Titel'] = "XYZ";  echo "& lt; pre & gt;";  print_r ($ обр);  echo "unique ********************* & lt; br / & gt;";  print_r (super_unique ($ обр 'Titel'));  ? & GT;   

  Массив ([0] = & gt; Массив ([id] = & gt; 1 [name] = & gt; john) [1] = & gt; Массив ([id] = & gt; 2 [name] =  & quot; smith) [2] = & gt; Array ([id] = & gt; 3 [name] = & gt; john) [3] = & gt; Array ([id] = & gt; 4 [name] = & gt; robert)  ) $ temp = array_unique (array_column ($ array, 'name'));  $ unique_arr = array_intersect_key ($ array, $ temp);   

Это приведет к удалению дубликатов имен из массива. уникальный ключ

Если у вас есть такой массив

  data = array ([0] = & gt; array ([subject] = & gt; a [object] = & gt; c), [1  ] = & gt; array ([subject] = & gt; b [object] = & gt; d), [2] = & gt; array ([subject] = & gt; d [object] = & gt; b), [3] =  & gt; массив ([subject] = & gt; d [object] = & gt; c), [4] = & gt; array ([subject] = & gt; c [object] = & gt; a), [5] = & gt;  array [[subject] = & gt; c [object] = & gt; d))  

, и вы хотите получить такие массивы:

  data =  array ([0] = & gt; array ([subject] = & gt; a [object] = & gt; c), [1] = & gt; array ([subject] = & gt; b [object] = & gt; d),  [2] = & gt; array ([subject] = & gt; d [object] = & gt; c))  

или

  data = array (  [0] = & gt; array ([subject] = & gt; d [object] = & gt; b), [1] = & gt; array ([subject] = & gt; c [object] = & gt; a), [2  ] = & gt; ([subject] = & gt; c [object] = & gt; d))  

следующий код может помочь

  $ data1  = array ();  $ data1 = $ data;  for ($ q = 0; $ q & lt; count ($ data); $ q ++) {for ($ p = 0; $ p & lt; count ($ data1); $ p ++) {if (($ data [$ q] [  "subject"] == $ data1 [$ p] ["object"]) & amp; & amp; ($ data [$ q] ["object"] == $ data1 [$ p] ["subject"])) {  $ data1 [$ p] ["subject"] = $ data [$ q] ["subject"];  $ data1 [$ p] ["object"] = $ data [$ q] ["object"];  }}} $ data1 = array_values ​​(array_map ("unserialize", array_unique (array_map ("serialize", $ data1))));  $ data = $ data1;   

Другой способ. Также сохранит ключи.

  function array_unique_multidimensional ($ input) {$ serialized = array_map ('serialize', $ input);  $ unique = array_unique ($ serialized);  return array_intersect_key ($ input, $ unique);  }  

Я много думал об этой проблеме и определил, что оптимальное решение должно соответствовать двум правилам.

1. Для масштабируемости измените массив на месте; никакое копирование в новый массив
2. Для производительности каждое сравнение должно выполняться только один раз

Учитывая это и учитывая все причуды PHP, ниже приведено решение I придумал. В отличие от некоторых других ответов, он имеет возможность удалять элементы на основе любого ключа (ов), который вы хотите. Ожидается, что входной массив будет числовым.

  $ count_array = count ($ input);  for ($ i = 0; $ i & lt; $ count_array; $ i ++) {if (isset ($ input [$ i])) {для ($ j = $ i + 1; $ j & lt; $ count_array; $ j ++  ) {if (isset ($ input [$ j])) {// это то, где вы делаете свое сравнение для обманов, если ($ input [$ i] ['checksum'] == $ input [$ j] ['checksum  ']) {unset ($ input [$ j]);  }}}}}  

Единственный недостаток заключается в том, что ключи не в порядке, когда итерация завершается. Это не проблема, если впоследствии вы используете только петли foreach, но если вам нужно использовать цикл for, вы можете поместить $ input = array_values ​​($ input); после этого изменить нумерацию ключи.

, если вам нужно устранить дубликаты на определенных ключах, таких как id mysqli, вот простая функция

  search_array_compact ($ data, $ key) {$ compact = [];  foreach ($ data as $ row) {if (! in_array ($ row [$ key], $ compact)) {$ compact [] = $ row;  }} return $ compact;  }  

Бонусные баллы Вы можете передать массив ключей и добавить внешний foreach, но он будет 2x медленнее за дополнительный ключ.