PHP kombiniert zwei assoziative Arrays zu einem Array

$array1 = array("$name1" => "$id1");

$array2 = array("$name2" => "$id2", "$name3" => "$id3");

Ich brauche ein neues Array, das alles miteinander kombiniert, dh es wäre

$array3 = array("$name1" => "$id1", "$name2" => "$id2", "$name3" => "$id3");

Was ist der beste Weg, dies zu tun?

Entschuldigung, ich habe vergessen, die IDs werden niemals miteinander übereinstimmen, aber technisch könnten die Namen, wären aber nicht wahrscheinlich, und sie müssen alle in einem Array aufgelistet werden. Ich habe mir array_merge angesehen, war mir aber nicht sicher, ob dies der beste Weg ist. Wie würden Sie dies testen?

array_merge() ist effizienter, aber es gibt einige Möglichkeiten:

$array1 = array("id1" => "value1");

$array2 = array("id2" => "value2", "id3" => "value3", "id4" => "value4");

$array3 = array_merge($array1, $array2/*, $arrayN, $arrayN*/);
$array4 = $array1 + $array2;

echo '<pre>';
var_dump($array3);
var_dump($array4);
echo '</pre>';


// Results:
    array(4) {
      ["id1"]=>
      string(6) "value1"
      ["id2"]=>
      string(6) "value2"
      ["id3"]=>
      string(6) "value3"
      ["id4"]=>
      string(6) "value4"
    }
    array(4) {
      ["id1"]=>
      string(6) "value1"
      ["id2"]=>
      string(6) "value2"
      ["id3"]=>
      string(6) "value3"
      ["id4"]=>
      string(6) "value4"
    }

Auschecken array_merge().

$array3 = array_merge($array1, $array2);

Es gibt auch array_replaceFälle, in denen ein ursprüngliches Array durch andere Arrays geändert wird, wobei die Zuordnung von Schlüssel => Wert beibehalten wird, ohne dass doppelte Schlüssel erstellt werden.

• Dieselben Schlüssel in anderen Arrays führen dazu, dass Werte das ursprüngliche Array überschreiben
• Neue Schlüssel auf anderen Arrays werden auf dem ursprünglichen Array erstellt

Ich benutze einen Wrapper um array_merge, um mit SeanWMs Kommentar zu Null-Arrays umzugehen. Ich möchte auch manchmal Duplikate loswerden. Ich möchte im Allgemeinen auch ein Array in ein anderes zusammenführen, anstatt ein neues Array zu erstellen. Dies endet als:

/**
 * Merge two arrays - but if one is blank or not an array, return the other.
 * @param $a array First array, into which the second array will be merged
 * @param $b array Second array, with the data to be merged
 * @param $unique boolean If true, remove duplicate values before returning
 */
function arrayMerge(&$a, $b, $unique = false) {
    if (empty($b)) {
        return;  // No changes to be made to $a
    }
    if (empty($a)) {
        $a = $b;
        return;
    }
    $a = array_merge($a, $b);
    if ($unique) {
        $a = array_unique($a);
    }
}

        $array = array(
            22 => true,
            25 => true,
            34 => true,
            35 => true,
        );

        print_r(
            array_replace($array, [
                22 => true,
                42 => true,
            ])
        );

        print_r(
            array_merge($array, [
                22 => true,
                42 => true,
            ])
        );

Wenn es sich um ein numerisches, aber kein sequentielles assoziatives Array handelt, müssen Sie es verwenden array_replace

Ich bin auf diese Frage gestoßen, als ich versucht habe, einen sauberen Weg zu finden, um zwei Assoc-Arrays zu verbinden.

Ich habe versucht, zwei verschiedene Tabellen zu verbinden, die keine Beziehung zueinander hatten.

Dies ist, was ich mir für PDO Query ausgedacht habe, um zwei Tabellen zu verbinden. Samuel Cook hat für mich eine Lösung mit der array_merge()+1 für ihn identifiziert .

        $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        $sql = "SELECT * FROM ".databaseTbl_Residential_Prospects."";
        $ResidentialData = $pdo->prepare($sql);
        $ResidentialData->execute(array($lapi));
        $ResidentialProspects = $ResidentialData->fetchAll(PDO::FETCH_ASSOC);

        $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        $sql = "SELECT * FROM ".databaseTbl_Commercial_Prospects."";
        $CommercialData = $pdo->prepare($sql);
        $CommercialData->execute(array($lapi));
        $CommercialProspects = $CommercialData->fetchAll(PDO::FETCH_ASSOC);

        $Prospects = array_merge($ResidentialProspects,$CommercialProspects);
        echo '<pre>';
        var_dump($Prospects);
        echo '</pre>';

Vielleicht hilft das jemand anderem.

UPDATE Nur eine kurze Anmerkung, wie ich sehen kann, sieht das wirklich dumm aus, und es hat keine gute Verwendung mit reinem PHP, weil das array_mergenur dort funktioniert. ABER versuchen Sie es mit dem PHP MongoDB-Treiber, bevor Sie schnell abstimmen. Dieser Typ wird aus irgendeinem Grund Indizes hinzufügen und das zusammengeführte Objekt ruinieren. Mit meiner naiven kleinen Funktion kommt die Verschmelzung genau so heraus, wie es mit einer traditionellen Funktion beabsichtigt war array_merge.

Ich weiß , es ist eine alte Frage , aber ich möchte einen weiteren Fall füge ich mit MongoDB - Treiber - Abfragen und keiner hatte vor kurzem array_merge, array_replacenoch array_pushgearbeitet. Ich hatte eine etwas komplexe Struktur von Objekten, die als Arrays in Arrays verpackt waren:

$a = [
 ["a" => [1, "a2"]],
 ["b" => ["b1", 2]]
];
$t = [
 ["c" => ["c1", "c2"]],
 ["b" => ["b1", 2]]
];

Und ich musste sie zusammenführen und dabei die gleiche Struktur beibehalten:

$merged = [
 ["a" => [1, "a2"]],
 ["b" => ["b1", 2]],
 ["c" => ["c1", "c2"]],
 ["b" => ["b1", 2]]
];

Die beste Lösung, die ich gefunden habe, war folgende:

public static function glueArrays($arr1, $arr2) {
    // merges TWO (2) arrays without adding indexing. 
    $myArr = $arr1;
    foreach ($arr2 as $arrayItem) {
        $myArr[] = $arrayItem;
    }
    return $myArr;
}