So entfernen Sie doppelte Werte aus einem mehrdimensionalen Array in PHP
https://stackoverflow.com/questions/307674
-
08-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Wie kann ich doppelte Werte aus einem mehrdimensionalen Array in PHP entfernen?
Beispielarray:
Array
(
[0] => Array
(
[0] => abc
[1] => def
)
[1] => Array
(
[0] => ghi
[1] => jkl
)
[2] => Array
(
[0] => mno
[1] => pql
)
[3] => Array
(
[0] => abc
[1] => def
)
[4] => Array
(
[0] => ghi
[1] => jkl
)
[5] => Array
(
[0] => mno
[1] => pql
)
)
Lösung
Hier ist eine andere Art und Weise. Keine Zwischenvariablen werden gespeichert.
Wir haben dieses de-Duplikat ergibt sich aus einer Vielzahl von Anfragen überlappen.
$input = array_map("unserialize", array_unique(array_map("serialize", $input)));
Andere Tipps
Da 5.2.9 können Sie mit array_unique() , wenn Sie verwenden Sie die SORT_REGULAR Flagge etwa so:
array_unique($array, SORT_REGULAR);
Das macht die Funktionselemente für die Gleichstellung vergleichen, als ob $a == $b verwendet wurden, die für Ihren Fall perfekt ist.
Output
Array
(
[0] => Array
(
[0] => abc
[1] => def
)
[1] => Array
(
[0] => ghi
[1] => jkl
)
[2] => Array
(
[0] => mno
[1] => pql
)
)
Beachten Sie aber, dass a href = "https://secure.php.net/manual/en/function.array-unique.php#refsect1-function.array-unique-notes" rel <=“ noreferrer "> die Dokumentation heißt es:
array_unique()soll nicht auf mehrdimensionale Arrays arbeiten.
Ich hatte ein ähnliches Problem, aber ich fand eine 100% Arbeitslösung für sie.
<?php
function super_unique($array,$key)
{
$temp_array = [];
foreach ($array as &$v) {
if (!isset($temp_array[$v[$key]]))
$temp_array[$v[$key]] =& $v;
}
$array = array_values($temp_array);
return $array;
}
$arr="";
$arr[0]['id']=0;
$arr[0]['titel']="ABC";
$arr[1]['id']=1;
$arr[1]['titel']="DEF";
$arr[2]['id']=2;
$arr[2]['titel']="ABC";
$arr[3]['id']=3;
$arr[3]['titel']="XYZ";
echo "<pre>";
print_r($arr);
echo "unique*********************<br/>";
print_r(super_unique($arr,'titel'));
?>
Eine andere Art und Weise. Wird auch Schlüssel erhalten.
function array_unique_multidimensional($input)
{
$serialized = array_map('serialize', $input);
$unique = array_unique($serialized);
return array_intersect_key($input, $unique);
}
Die Benutzer Kommentare auf der array_unique () Dokumentation haben viele Lösungen für diese. Hier ist einer von ihnen:
kenrbnsn bei rbnsn dot com
27-Sep-2005 0.09Noch ein weiterer array_unique für Multi-demensioned Arrays. Ich habe nur getestet dies auf zwei demensioned Arrays, aber es könnte wahrscheinlich für mehr verallgemeinert werden, oder aus Rekursion zu verwenden.
Diese Funktion verwendet die serialize, array_unique und unserialize Funktionen, um die Arbeit zu tun.
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); }
Dies ist von http: //ca3.php. net / manual / en / function.array-unique.php # 57202 .
Wenn „Duplikate entfernen“ bedeutet „Duplikate entfernen, aber sie man dort“, könnte eine Lösung sein, den array_unique(...) auf der „ID-Spalte“ zuerst und dann gilt, in dem ursprünglichen Array all Schlüssel zu entfernen, die entfernt wurden von der Spaltenanordnung:
$array = [
[
'id' => '123',
'foo' => 'aaa',
'bar' => 'bbb'
],
[
'id' => '123',
'foo' => 'ccc',
'bar' => 'ddd'
],
[
'id' => '567',
'foo' => 'eee',
'bar' => '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);
Das Ergebnis ist:
Array
(
[0] => Array
(
[id] => 123
[foo] => aaa
[bar] => bbb
)
[2] => Array
(
[id] => 567
[foo] => eee
[bar] => fff
)
)
Array
(
[0] => Array
(
[id] => 1
[name] => john
)
[1] => Array
(
[id] => 2
[name] => smith
)
[2] => Array
(
[id] => 3
[name] => john
)
[3] => Array
(
[id] => 4
[name] => robert
)
)
$temp = array_unique(array_column($array, 'name'));
$unique_arr = array_intersect_key($array, $temp);
Das wird den doppelten Namen von Array entfernen. einzigartig durch die Taste
Just SORT_REGULAR Option als zweiter Parameter verwendet werden.
$uniqueArray = array_unique($array, SORT_REGULAR);
wenn Sie Duplikate auf bestimmte Tasten zu beseitigen, wie ein Mysqli id, hier ist eine einfache funciton
function search_array_compact($data,$key){
$compact = [];
foreach($data as $row){
if(!in_array($row[$key],$compact)){
$compact[] = $row;
}
}
return $compact;
}
Bonuspunkte Sie können eine Reihe von Tasten passieren und eine äußere foreach hinzufügen, aber es wird langsamer pro zusätzliche Taste 2x werden.
Wenn Sie ein Array wie folgt:
(Benutzer ist der Name des Arrays)
Array=>
[0] => (array)
'user' => 'john'
'age' => '23'
[1] => (array)
'user' => 'jane'
'age' => '20'
[2]=> (array)
'user' => 'john'
'age' => '23'
und Sie wollen Duplikate löschen ... dann:
$serialized = array();
for ($i=0; $i < sizeof($users); $i++) {
$test = in_array($users['user'], $serialized);
if ($test == false) {
$serialized[] = $users['user'];
}
}
kann eine Lösung: P
Eine einfache Lösung zu lesen, wahrscheinlich nicht die effizienteste:
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;
}
Viele Menschen fragten mich, wie Einzigartiges mehrdimensionales Array zu machen. Ich habe Bezug von Ihrem Kommentar aufgenommen und es hilft mir.
Zu allererst Dank @daveilers für Ihre Lösung @jeromegamez. Aber jedes Mal, wenn ich die Antwort gab, fragten sie mich, wie diese ‚serialize‘ und ‚unserialize‘ arbeitet. Deshalb habe ich den Grund dafür mit Ihnen teilen möchten, so dass es mehr Menschen helfen, das Konzept dahinter zu verstehen.
Ich bin zu erklären, warum wir 'serialize' und 'unserialize' in Schritten verwenden:
1. Schritt: Konvertieren des mehrdimensionalen Arrays eindimensionales Array
die mehrdimensionale Array ein eindimensionales Array zu konvertieren, erster Bytestrom Darstellung aller Elemente (einschließlich verschachtelten Arrays) innerhalb des Arrays erzeugen. Serialisieren () Funktion kann Bytestrom Darstellung eines Wertes erzeugen. Um Bytestrom Darstellung aller Elemente zu erzeugen, rufen Serialisieren () Funktion in array_map () Funktion als Callback-Funktion. Das Ergebnis wird eine eindimensionale Matrix sein, egal, wie viele Ebenen der mehrdimensionales Array hat.
Schritt 2: Nehmen Sie die Werte eindeutig
Um diese eindimensionales Array einzigartig, Verwendung array_unique () Funktion zu machen.
Schritt 3: Revert es den mehrdimensionalen Array
Obwohl das Array nun eindeutig zuzuordnen ist, sehen die Werte wie Byte-Stream-Darstellung. So kehren sie zurück zu dem mehrdimensionalen Array verwenden unserialize () Funktion.
$input = array_map("unserialize", array_unique(array_map("serialize", $input)));
Nochmals vielen Dank für alles.
Eine sehr einfache und logische Weise zu Einzigartige eines Multi Dimension Array ist wie folgt,
Wenn Sie Array wie folgt aussehen:
Array
(
[Key1] => Array
(
[0] => Value1
[1] => Value2
[2] => Value1
[3] => Value3
[4] => Value1
)
[Key2] => Array
(
[0] => Value1
[1] => Value2
[2] => Value1
[3] => Value3
[4] => Value4
)
)
Verwendung foreach zu lösen diese:
foreach($array as $k=>$v){
$unique=array_unique($v);
$array[$k]=$unique;
}
es wird Ihnen folgendes Ergebnis:
Array
(
[Key1] => Array
(
[0] => Value1
[1] => Value2
[3] => Value3
)
[Key2] => Array
(
[0] => Value1
[1] => Value2
[3] => Value3
[4] => Value4
)
)
und wenn Sie die Reihenfolge des Schlüssels neu zu ordnen,
foreach($array as $k=>$v){
$unique= array_values(array_unique($v));
$array[$k]=$unique;
}
Diese Operation wird Ihnen Schlüsselwerte wie folgt angeordnet:
Array
(
[Key1] => Array
(
[0] => Value1
[1] => Value2
[2] => Value3
)
[Key2] => Array
(
[0] => Value1
[1] => Value2
[2] => Value3
[3] => Value4
)
)
Ich hoffe, dies alles wird klar.
Eine Alternative zur Serialisierung und einzigartige
$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($result);
/*
php unique.php
array(3) {
[0] =>
array(2) {
[0] =>
string(3) "abc"
[1] =>
string(3) "def"
}
[1] =>
array(2) {
[0] =>
string(3) "ghi"
[1] =>
string(3) "jkl"
}
[2] =>
array(2) {
[0] =>
string(3) "mno"
[1] =>
string(3) "pql"
}
}
* /
Wenn Sie ein Array wie folgt
data = array
(
[0] => array
(
[subject] => a
[object] => c
),
[1] => array
(
[subject] => b
[object] => d
),
[2] => array
(
[subject] => d
[object] => b
),
[3] => array
(
[subject] => d
[object] => c
),
[4] => array
(
[subject] => c
[object] => a
),
[5] => array
(
[subject] => c
[object] => d
)
)
und Sie wollen Arrays wie diese:
data = array
(
[0] => array
(
[subject] => a
[object] => c
),
[1] => array
(
[subject] => b
[object] => d
),
[2] => array
(
[subject] => d
[object] => c
)
)
oder
data = array
(
[0] => array
(
[subject] => d
[object] => b
),
[1] => array
(
[subject] => c
[object] => a
),
[2] => array
(
[subject] => c
[object] => d
)
)
a folgender Code kann helfen
$data1 = array();
$data1 = $data;
for($q=0;$q<count($data);$q++)
{
for($p=0;$p<count($data1);$p++)
{
if (($data[$q]["subject"] == $data1[$p]["object"]) && ($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;
Ich habe viel über dieses Problem nachgedacht und bin zu dem Schluss gekommen, dass die optimale Lösung zwei Regeln folgen sollte.
- Um die Skalierbarkeit zu gewährleisten, ändern Sie das Array an Ort und Stelle.Kein Kopieren in ein neues Array
- Aus Leistungsgründen sollte jeder Vergleich nur einmal durchgeführt werden
Vor diesem Hintergrund und unter Berücksichtigung aller Besonderheiten von PHP finden Sie unten die Lösung, die ich gefunden habe.Im Gegensatz zu einigen anderen Antworten besteht die Möglichkeit, Elemente basierend auf den gewünschten Schlüsseln zu entfernen.Es wird erwartet, dass das Eingabearray aus Zifferntasten besteht.
$count_array = count($input);
for ($i = 0; $i < $count_array; $i++) {
if (isset($input[$i])) {
for ($j = $i+1; $j < $count_array; $j++) {
if (isset($input[$j])) {
//this is where you do your comparison for dupes
if ($input[$i]['checksum'] == $input[$j]['checksum']) {
unset($input[$j]);
}
}
}
}
}
Der einzige Nachteil besteht darin, dass die Schlüssel nach Abschluss der Iteration nicht in Ordnung sind.Dies ist kein Problem, wenn Sie anschließend nur foreach-Schleifen verwenden. Wenn Sie jedoch eine for-Schleife verwenden müssen, können Sie diese verwenden $input = array_values($input); Anschließend können Sie die Tasten neu nummerieren.
Wie die Leute sagen array_unique() ist sehr langsam, hier ist ein Ausschnitt I für eine Ebene mehrdimensionales Array verwenden.
$serialized_array = array_map("serialize", $input);
foreach ($serialized_array as $key => $val) {
$result[$val] = true;
}
$output = array_map("unserialize", (array_keys($result)));
Das Bezugs erste Nutzer beigetragen zur Kenntnis array_unique() Funktion Seite in php.net
