PHP-Merge-Arrays mit nur NICHT DUPLICATED-Werten

Ich muss zwei Arrays zu einem Array zusammenführen, aber ich muss sie entfernen, bevor die Hauptdaten, die sie beide gemeinsam haben (doppelte Werte, meine ich), beim Zusammenführen nur eindeutige Werte benötigen.

Wie kann ich das machen?

Dies ist das Array-Beispiel:

Erstes Array

array(3) { 
    [0]=> object(stdClass)#17 (1) { 
        ["email"]=> string(7) "gffggfg" 
    } 
    [1]=> object(stdClass)#18 (1) { 
        ["email"]=> string(6) "wefwef@test.it" 
    } 
    [2]=> object(stdClass)#19 (1) { 
        ["email"]=> string(6) "wefewf" 
    } 
} 

Zweites Array

array(3) { 
    [0]=> object(stdClass)#17 (1) { 
        ["email"]=> string(7) "gffggfg@test.it" 
    } 
    [1]=> object(stdClass)#18 (1) { 
        ["email"]=> string(6) "wefwef" 
    } 
    [2]=> object(stdClass)#19 (1) { 
        ["email"]=> string(6) "wefewf" 
    } 
} 

Sie können die array_merge()Funktion mit der array_unique()Funktion kombinieren (beide Titel sind ziemlich selbsterklärend).

$array = array_unique (array_merge ($array1, $array2));

Wenn ich die Frage richtig verstehe:

 $a1 = Array(1,2,3,4);
 $a2 = Array(4,5,6,7);
 $array =  array_diff(array_merge($a1,$a2),array_intersect($a1,$a2));
 print_r($array);

Rückkehr

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

Ich habe einige Benchmarks durchgeführt, wie ich mir das vorstellen kann. Ich habe Tests zum Stapeln vieler Arrays mit 10 bis 20 Zeichenfolgenelementen durchgeführt, was zu einem Array mit allen eindeutigen Zeichenfolgen führte. Dies sollte für das Stapeln von nur 2 Arrays ungefähr gleich sein.

Das schnellste, das ich gefunden habe, war das einfachste, was ich versucht habe.

$uniques = [];
foreach($manyArrays as $arr ) {
  $uniques = array_unique(array_merge($uniques, $arr));
}

Ich hatte dies als "zu naiv zum Arbeiten" eingestuft, da es das eindeutige Array bei jeder Iteration sortieren muss. Dies ist jedoch schneller als jede andere Methode. Testen mit 500.000 Elementen in vielen Arrays, die jeweils 10-20 Zeichenfolgen aus PHP 7.3 enthalten.

Eine knappe Sekunde ist diese Methode, die etwa 10% langsamer ist.

$uniques = [];
foreach($manyArrays as $arr ) {
  foreach($arr as $v) {
    if( !in_array($v, $uniques, false) ) {
      $uniques[] = $v;
    }
  }
}

Die zweite Methode könnte in einigen Fällen besser sein, da dies den Parameter 'strict' von in_array () für die strikte Typprüfung unterstützt. Wenn der Wert auf true gesetzt ist, wird die zweite Option erheblich langsamer als die erste (ca. 40%). Die erste Option unterstützt keine strikte Typprüfung.

Schnellere Lösung:

function concatArrays($arrays){
    $buf = [];
    foreach($arrays as $arr){
        foreach($arr as $v){
            $buf[$v] = true;
        }
    }
    return array_keys($buf);
}


$array = concatArrays([$array1, $array2]);

Eine etwas späte Antwort, aber ich habe gerade festgestellt, dass der Array Union-Operator +die Arbeit ziemlich gut erledigt ( hier im 3. Abschnitt).

$array1 + $array2 = $array //if duplicate found, the value in $array1 will be considered ($array2 value for array_merge, if keys clearly specified)