Gegenteil von array_unique()

[Efchen]

Moin Jungs und Mädels,

ich steh gerade auf dem Schlauch. Ich suche das Gegenteil von array_unique(), also eine Funktion, die mir alle doppelt vorkommenden Values in einem Array ausgibt. Mein erster, intuitiver Versuch war das:

array_diff(array_values($myArray), array_unique($myArray));

Aber das klappt nicht, weil das diff alle Vorkommen eines Values in $myArray löscht, auch wenn diese Value im unique Array dann nur einmal vorkommt.
Oder mit Beispiel: Wenn ich ("Eins", "Zwei", "Zwei") habe, macht array_unique daraus ("Eins", "Zwei") und wenn ich diff darauf anwende, bekomme ich ("Eins"), weil "Zwei" jedesmal schon im unique Array vorkommt.

Gibts da nichts? Übersehe ich grad was? Ich möchte jetzt eigentlich nicht eine Schleife über alle Elemente des Arrays machen, in der dann wieder eine Schleife über alle Elemente des unique Arrays steht. Das muss doch eleganter gehen!?

Danke,
-Efchen

 

[skizZ]

Nimms mir nicht übel aber von dir habe ich eigentlich erwartet, dass du google kennst :-)

PHP: Doppelte Eintr

 

[Loon3y]

Nimms mir nicht übel aber von dir habe ich eigentlich erwartet, dass du google kennst

google liefert nicht immer das, was man will ;) zumal dein Lösungslink irgendwas mit Schleifen ist, was ja nicht sein soll.

@topic
Also rein theoretisch müsst es doch funktionieren, wenn du es so machst:

EDIT:

<?
$myArray = array(
	1 => "test"
	,2 => "test2"
	,3 => "test"
	,4 => "test3"
	,5 => "test2"
);

echo "<pre>";
print_r(array_diff_key($myArray, array_unique($myArray)));
echo "</pre>"; 


/*AUSGABE*/
Array
(
    [3] => test
    [5] => test2
)

?>

---> array_diff_key($myArray, array_unique($myArray))

Aber das array_diff_key steht wies aussieht nur ab PHP 5 zur verfügung.

 

[skizZ]

Falsch, da steht auch eine Methode drin wie man es macht .. neues Array in die die Uniques kommen und dann das neue vom alten abziehen :-)

 

[Efchen]

Nimms mir nicht übel aber von dir habe ich eigentlich erwartet, dass du google kennst

Ach nee, was isn das?
Wenn Du das von mir erwartet hast, dann kannst Du Dir sicher denken, dass ich da auch schon gesucht habe. Ich habe meine Antwort aber nicht gefunden.

Also rein theoretisch müsst es doch funktionieren, wenn du es so machst:

Mal abgesehen davon, dass Du array_diff_key() verwendest, und ich aber die Values suche, nicht die Keys, machst Du exakt das selbe, wie ich oben geschrieben habe.

Das diff reagiert aber nicht so wie ein diff üblicherweise (z.B. das Kommando "diff" unter Unix), das beim Vergleich von ("Zwei", "Zwei") mit ("Zwei") wiederum("Zwei") zurückgeben würde, nicht wie das PHP-diff ein leeres Array.

Falsch, da steht auch eine Methode drin wie man es macht .. neues Array in die die Uniques kommen und dann das neue vom alten abziehen :-)

Arrays kann man nicht abziehen.
Aber wo bitte steht da die Lösung? Mit zwei Schleifen kann ich das auch, das hatte ich ja schon gesagt, aber das erscheint mir nicht schön! Da muss es doch auch was anderes geben. Wenn derjenige, der sich array_diff ausgedacht hat, schon das diff anders umsetzt, als alle anderen diffs, die ich bisher kennengelernt habe, dann gibts sicher ne andere Funktion, die ein richtiges diff macht, oder ne Option oder irgendwas anderes.

Der Artikel, den Du verlinkt hast, bringt mich leider nicht weiter.

 

[Gilles]

Weiss nicht genau ob es dir ein bisschen hilft. Aber du kannst dir mal das anschauen
PHP: array_count_values - Manual
Damit kriegst du ja die Anzahl, wie oft eine Value vorkommt.
Vielelicht kommst du damit etwas weiter. Wüsste jetzt leider auch keinen schönen Lösungsweg

 

[Efchen]

Ja, ich glaube, das hilft mir weiter...danke!

Ich habs eben versucht, auf die komplizierte Art mit Schleifen zu lösen, da macht PHP grad überhaupt nicht, was ich will. Der behauptet zum Beispiel, dass eine Variable, die auf "0" gesetzt ist =="" ist. Der macht mich gerade wahnsinnig :-)

Hier meine Lösung:

$values=array_values($_POST);
$unique=array_unique($values);
if (sizeof($values)!=sizeof($unique))
{
  print "Doppelte Felder:\n";
  $notUnique=array_count_values($values);
  foreach (array_keys($notUnique) as $key)
    if ($notUnique[$key]>1)
      print "Feld '$key'\n";
}

Danke an alle!

 

[mermshaus]

Loon3ys Lösung funktioniert eigentlich ganz prima. Sie liefert genau das Gegenteil von array_unique. Das diff klappt an der Stelle, da jeder Key natürlich einmalig vorkommt und die Rückgabe von array_unique die Zuordnung Key=>Value beibehält.

Oder übersehe ich was?

Edit: Verdeutlichung:

<?php

header('Content-Type: text/plain');

$myArray = array(1,
                 2, 2, 2,
                 3, 3,
                 4,
                 5, 5,
                 6);

echo "\n\n\n\$myArray:\n\n";
print_r($myArray);

echo "\n\n\narray_unique:\n\n";
print_r(array_unique($myArray));

echo "\n\n\narray_diff_key:\n\n";
print_r(array_diff_key($myArray, array_unique($myArray)));

$myArray:               array_unique:           array_diff_key:

Array                   Array                   Array
(                       (                       (
    [0] => 1                [0] => 1            
    [1] => 2                [1] => 2
    [2] => 2                                        [2] => 2
    [3] => 2                                        [3] => 2
    [4] => 3                [4] => 3
    [5] => 3                                        [5] => 3
    [6] => 4                [6] => 4
    [7] => 5                [7] => 5
    [8] => 5                                        [8] => 5
    [9] => 6                [9] => 6
)                       )                       )

 

[Efchen]

*seufz*
Stimmt.

Ich hab mir unter array_diff_key wohl irgendwas anderes vorgestellt. *kopfkratz*

Punkt für Dich Loon3y! Danke!

 

[Loon3y]

Oder übersehe ich was?

Efchen wollte nur die values rausbekommen am Ende, kein neues Array mit keys und values.. ^^ EDIT: hab ich das so richtig verstanden?

@Efchen
In deinem Beispiel ist aber dennoch eine Schleife enthalten.. :-)

EDIT: hehe..stehts wohl 2:1000, führst immernoch knapp ;)


Kleine "Fummellösung" von mir, dass nochmalige array_uniqe auf das $aNew ist, weil er, wenn eine value mehr als 2x vorkommt, diese dann bei array_diff_key wieder reinschreibt:

<?

$aOld = array(
    1 => "test"
    ,2 => "test2"
    ,3 => "test"
    ,4 => "test3"
    ,5 => "test2"
    ,6 => "test2"
    ,7 => "test2"
    ,8 => "test2"
);

$aNew = array_diff_key($aOld, array_unique($aOld));
$aNew = array_unique($aNew);
$size = count($aNew);


function showValues($i = 0, $j = 0){
	global $aNew, $size;

	if(array_key_exists($i, $aNew)){
		echo " => value \"" . $aNew[$i] . "\"\n";
		$j++;		
	}
	
	$i++;
	if($j == $size)
		return;
	else
		showValues($i, $j);
}

echo "<h1>Doppelte Values im Array:</h1>\n";
echo "<pre>";
showValues();
echo "</pre>";

?>

Gruß nach 30x Edit (doofes Telefon, doofe Wellis die sich hier streiten *Grmpf)
Loon3y

so letzter Edit.. : ist das wirklich perfomanter wie eine Schleife? Ich denke du wolltest keine Schleife, da du eine perfomante Lösung gesucht hast, oder?!

 

[mermshaus]

Habe gerade nach nem Weg gesucht, ein Array neu ab 0 zu "indexieren". $array = array_slice($array, 0); scheint eine Möglichkeit zu sein.

print_r(
    array_slice(
        array_unique(
            array_diff_key(
                $myArray,
                array_unique(
                    $myArray
                )
            )
        ),
        0
    )
);

Hübsch hässlich.

Edit: Loon3y, da hätte es aber eine foreach-Schleife auch getan. ;)