array_merge() ב-PHP: מיזוג שני מערכים או יותר

array_merge($a, $b) מחזירה מערך חדש עם האיברים של $a ואחריהם האיברים של $b. מפתחות מספריים ממוספרים מחדש מ-0; כששני המערכים מכילים אותו מפתח מחרוזת, הערך מהמערך המאוחר מנצח. העבירו כמה מערכים שתרצו.

<?php
$fruits = ['apple', 'pear'];
$veg    = ['carrot', 'leek'];
print_r(array_merge($fruits, $veg));

$defaults = ['color' => 'blue', 'size' => 'M'];
$chosen   = ['size' => 'L'];
print_r(array_merge($defaults, $chosen));   // later value wins

array_merge() לא משנה את הארגומנטים שלה. היא מחזירה את המערך המאוחד, אז הציבו את התוצאה: $all = array_merge($all, $more);.

מפתחות מספריים ממוספרים מחדש

array_merge() מתייחסת למפתחות שלמים כמיקומים, לא כשמות. כל איבר עם מפתח שלם מתווסף ומקבל מפתח חדש מ-0, גם אם המערכים השתמשו באותם מספרים או בפערים. זה מה שרוצים ברשימות, והפתעה כשהמספרים הם מזהים.

<?php
$a = [5 => 'Ada', 9 => 'Linus'];
$b = [5 => 'Grace'];

print_r(array_merge($a, $b));   // keys 0, 1, 2: the IDs are gone

$usersById = [101 => 'Ada', 102 => 'Linus'];
$more      = [103 => 'Grace'];
print_r($usersById + $more);    // + keeps the integer keys

מפתחות מחרוזת שנראים כמו מספרים שלמים ('101') נשמרים כמספרים שלמים, ולכן גם הם ממוספרים מחדש. מפתחות כמו 'id101' נשארים כמו שהם.

array_merge מול האופרטור +

גם האופרטור + (איחוד מערכים) מחבר מערכים, אבל עם הכלל ההפוך: לכל מפתח שכבר קיים במערך הראשון, הערך הראשון מנצח והערך מהמערך השני נזרק. הוא אף פעם לא ממספר מחדש. זה הופך את + לדרך הטבעית להשלים ברירות מחדל, ואת array_merge() לדרך הטבעית לדרוס אותן.

<?php
$defaults = ['theme' => 'light', 'lang' => 'en', 'per_page' => 20];
$user     = ['theme' => 'dark'];

print_r(array_merge($defaults, $user));   // user overrides defaults
print_r($user + $defaults);               // same result: user is on the left

// With lists, + compares positions and drops duplicates by key
print_r(['a', 'b'] + ['x', 'y', 'z']);

הדוגמה האחרונה בבלוק היא המלכודת הקלאסית של +: ['a', 'b'] + ['x', 'y', 'z'] נותן a, b, z, כי המפתחות 0 ו-1 כבר קיימים במערך הראשון.

תחביר פריסה: [...$a, ...$b]

אופרטור הפריסה פורק מערכים בתוך ליטרל מערך. הוא מתנהג כמו array_merge(): מפתחות שלמים ממוספרים מחדש, ומאז PHP 8.1 מותרים מפתחות מחרוזת והמאוחר מנצח. הוא נקרא טוב כשמערבבים מערכים עם ערכים בודדים.

<?php
$first  = [1, 2];
$second = [3, 4];

print_r([...$first, ...$second, 5]);

$base  = ['host' => 'localhost', 'port' => 3306];
$local = ['port' => 3307];
print_r([...$base, ...$local]);

כדי להוסיף מערך למערך קיים במקום, ראו את array_push() עם אופרטור הפריסה.

מיזוג מערך של מערכים

כשהמערכים לחיבור נמצאים בעצמם ברשימה, פרסו את הרשימה הזו לתוך array_merge(). זו גם הדרך המהירה למזג בתוך לולאה: אספו את החלקים, ואז מזגו פעם אחת.

<?php
$pages = [
    ['ada', 'linus'],
    ['grace'],
    ['margaret', 'alan'],
];

$all = array_merge(...$pages);
print_r($all);

$batches = [];
for ($page = 1; $page <= 3; $page++) {
    $batches[] = range($page * 10, $page * 10 + 2);   // pretend API page
}
echo implode(', ', array_merge(...$batches)), "\n";

var_dump(array_merge(...[]));   // an empty list gives []

כתיבה של $all = array_merge($all, $batch); בתוך הלולאה עובדת, אבל היא מעתיקה את כל המערך הגדל בכל סבב, וזה נעשה איטי עם אלפי פריטים.

array_merge_recursive ו-array_replace

array_merge_recursive() ממזגת גם מערכים מקוננים, אבל במפתח מחרוזת כפול שמחזיק ערכים פשוטים היא לא דורסת: היא אוספת את שני הערכים למערך חדש. לעיתים רחוקות זה מה שרוצים בהגדרות. array_replace_recursive() היא בדרך כלל הכלי הנכון שם: היא דורסת ערכים בכל רמה ושומרת על המפתחות.

<?php
$defaults = ['db' => ['host' => 'localhost', 'port' => 3306], 'debug' => false];
$override = ['db' => ['port' => 3307], 'debug' => true];

echo json_encode(array_merge($defaults, $override)), "\n";
echo json_encode(array_merge_recursive($defaults, $override)), "\n";
echo json_encode(array_replace_recursive($defaults, $override)), "\n";

print_r(array_replace([5 => 'a', 9 => 'b'], [9 => 'B']));   // keeps integer keys

קראו את שלוש שורות ה-JSON מלמעלה למטה: array_merge() החליפה את כל המערך db ואיבדה את host, array_merge_recursive() הפכה את port ואת debug לרשימות של שני איברים, ו-array_replace_recursive() הפיקה את ההגדרות שהתכוונתם אליהן.

טעות נפוצה: מיזוג לא מסיר כלום

array_merge() שומרת ערכים כפולים שיושבים תחת מפתחות שונים. מיזוג של שתי רשימות תגיות נותן לכם כל תגית משותפת פעמיים. העבירו את התוצאה דרך array_unique() ואז array_values() כדי למספר אותה מחדש.

<?php
$postTags  = ['php', 'arrays', 'beginner'];
$extraTags = ['arrays', 'tutorial', 'php'];

$merged = array_merge($postTags, $extraTags);
echo implode(', ', $merged), "\n";

$unique = array_values(array_unique($merged));
echo implode(', ', $unique), "\n";

עמוד array_unique מכסה הסרת כפילויות משורות וממערכים מקוננים.