Fungsi array_merge() Pada PHP

Kali ini kita akan ngobrol santai tentang salah satu fungsi penting dan sering dipakai dalam PHP, yaitu array_merge(). Buat kamu yang sering ngoding pakai PHP, pasti sudah enggak asing dengan fungsi ini. Tapi mungkin ada juga yang baru dengar atau sekadar tahu namanya saja, namun belum paham betul kegunaannya. Nah, di artikel ini, kita akan bahas tuntas mulai dari apa itu array_merge(), cara kerjanya, contoh penerapannya dalam berbagai situasi, sampai hal-hal yang sering bikin kita bingung saat menggunakannya.

Artikel ini cukup panjang, karena kita ingin menyelami array_merge() dengan detail. Jadi, jangan kaget kalau kamu menemukan banyak paragraf dan contoh kode di sini. Kita akan bedah fungsi ini step by step dengan gaya bahasa yang santai agar kamu nggak bosan. Selain itu, semoga setelah membaca artikel ini, kamu bisa lebih lihai dalam memanipulasi array di PHP, baik untuk keperluan pribadi, proyek sekolah, skripsi, pekerjaan, hingga berbagai aplikasi web yang canggih.

Kalau ngomongin array_merge(), sebenarnya fungsinya cukup simpel, yaitu untuk menggabungkan dua atau lebih array jadi satu. Hanya saja, cara menggabungkan array tersebut tergantung jenis key yang ada di dalam array itu. Kadang ada yang berupa key numerik (misalnya 0, 1, 2) atau key asosiatif (misalnya ‘nama’, ‘alamat’, ‘email’). Dalam kasus tertentu, hasil merge-nya bisa jadi tidak seperti yang kita bayangkan, apalagi kalau kita belum tahu cara kerjanya. Di artikel ini, kita akan bahas juga perbedaannya dengan array_merge_recursive(), karena kedua fungsi ini sama-sama berguna tapi punya hasil yang berbeda saat menggabungkan array asosiatif.

Yuk, tanpa berlama-lama lagi, kita langsung masuk ke inti pembahasan. Jangan lupa siapkan kopi atau teh (atau minuman kesukaan kamu) biar santai saat membaca. Kita mulai dengan definisi singkat fungsi array_merge()!

Apa Itu array_merge()?

array_merge() adalah sebuah fungsi bawaan PHP yang berfungsi untuk menggabungkan dua atau lebih array menjadi satu buah array baru. Fungsi ini sangat berguna dalam banyak situasi. Misalnya, ketika kita punya data dari beberapa sumber yang terpisah (seperti data user, data produk, dan data transaksi), lalu kita ingin menggabungkannya menjadi satu struktur yang rapi.

Kalau kita lihat definisi di dokumentasi resmi PHP (ya walaupun kita berusaha bikin artikel ini orisinal dan santai, kita tetap bisa mengecek doc resmi PHP untuk rujukan), array_merge() akan mengambil array pertama, kemudian menambahkan elemen-elemen dari array berikutnya ke dalam array pertama itu. Namun, ingat bahwa saat proses penggabungan, ada perbedaan penanganan elemen dengan key numerik dan key asosiatif, yang nantinya akan kita jelaskan lebih lanjut.

Secara umum, struktur penggunaan array_merge() adalah seperti ini:

// Bentuk umum penggunaan array_merge()
array_merge($array1, $array2, $array3, ...);
    

Artinya, kita bisa melempar dua, tiga, atau bahkan lebih banyak array ke dalam fungsi ini. Hasil yang dikembalikan adalah sebuah array baru. Meskipun demikian, perlu diingat bahwa fungsi ini tidak akan mengubah array aslinya (tidak akan menimpa array pertama secara langsung). Ia akan menghasilkan array baru dengan bentuk yang sudah digabungkan. Tentu saja, kamu bisa menyimpannya ke dalam variabel baru atau langsung menampilkannya jika mau.

Misal kita punya dua array:

$buah1 = ["apel", "jeruk", "mangga"];
$buah2 = ["pisang", "pepaya"];

// Lalu kita gabungkan
$gabungan = array_merge($buah1, $buah2);

print_r($gabungan);
    

Hasilnya akan jadi seperti berikut:

Array
(
    [0] => apel
    [1] => jeruk
    [2] => mangga
    [3] => pisang
    [4] => pepaya
)
    

array_merge() menambahkan elemen-elemen dari $buah2 ke elemen-elemen yang sudah ada di $buah1, lalu membuat $gabungan sebagai array baru. Nah, itu adalah gambaran singkatnya. Selanjutnya, kita akan bahas lebih dalam tentang bagaimana fungsi ini memperlakukan indeks numerik dan key asosiatif, karena di sanalah letak 'keajaiban' dan kadang bikin bingung pemula.

Cara Kerja array_merge() dengan Key Numerik

Bayangin kita punya dua array yang indeksnya sama-sama numerik. Contohnya:

$arrayA = [10, 20, 30];
$arrayB = [40, 50, 60];
    

Index numerik di PHP biasanya berurutan dari 0, 1, 2, dan seterusnya, meskipun kita juga bisa menentukan sendiri. Saat kita menggunakan array_merge(), PHP akan membuat array baru di mana seluruh elemen dari $arrayA dan $arrayB disatukan menjadi satu. Nilai-nilai dari $arrayB akan ditempatkan di indeks selanjutnya. Jadi, hasil akhirnya akan jadi:

$hasil = array_merge($arrayA, $arrayB);

// Hasilnya:
Array
(
    [0] => 10
    [1] => 20
    [2] => 30
    [3] => 40
    [4] => 50
    [5] => 60
)
    

Mudah banget, kan? Kuncinya adalah: kalau key-nya numerik, PHP bakal menambahkan element tersebut ke urutan paling akhir. Artinya, dia enggak akan menimpa atau menimpa index yang sudah ada. Dia akan menambahkan di baris berikutnya. Jadinya, array baru punya jumlah elemen gabungan dari kedua array.

Contoh lain, misalnya $arrayA dan $arrayB berikut punya index yang sama-sama mulai dari 0, bahkan punya 3 elemen di masing-masing array. Hasilnya sama saja, elemen $arrayB akan ditaruh di “belakang” elemen $arrayA sesuai urutan. Jadi, enggak perlu bingung soal tabrakan index. Hal ini berbeda dengan array asosiatif (yang menggunakan key string), sehingga kita akan bahas itu terpisah, biar lebih jelas.

array_merge() dengan Key Asosiatif

Nah, sekarang masuk ke topik yang sering bikin heran kalau belum tahu aturannya: menggabungkan dua array asosiatif. Contohnya:

$user1 = [
    "nama" => "Budi",
    "umur" => 20
];

$user2 = [
    "umur" => 25,
    "kota" => "Jakarta"
];

$gabungUser = array_merge($user1, $user2);
print_r($gabungUser);
    

Pertanyaannya, mana yang muncul di hasil? Apakah umur 20 atau umur 25? Jadi begini, kalau key asosiatif sudah muncul di array pertama, lalu key yang sama juga muncul di array selanjutnya, maka array_merge() akan menimpa nilai yang lama dengan nilai yang lebih baru. Dengan kata lain, “umur” => 25 di $user2 akan meng-override nilai “umur” => 20 di $user1.

Jadi, hasilnya akan jadi seperti ini:

Array
(
    [nama] => Budi
    [umur] => 25
    [kota] => Jakarta
)
    

Perubahan usia dari 20 ke 25 ini terjadi karena $user2 berisi key "umur" yang sama. Jika di array pertama ada key “umur” dan array kedua juga punya key “umur”, maka array_merge() hanya akan mengambil key “umur” satu kali di hasil final, tapi dengan nilai terakhir (dalam contoh ini, 25). Konsep ini terkadang justru kita manfaatkan untuk meng-update nilai-nilai tertentu tanpa repot mengambil data lama secara manual.

Namun, kalau sebuah key asosiatif hanya muncul di salah satu array, maka dia tinggal “dibawa” saja ke array akhir. Enggak ada penimpaan di situ. Contohnya, “kota” => “Jakarta” di $user2 akan muncul di hasil akhir karena di $user1 enggak ada key “kota”.

Menggabungkan Lebih dari Dua Array

Salah satu kelebihan array_merge() adalah kita bisa menggabungkan lebih dari dua array sekaligus. Enggak harus cuma dua, bisa tiga, empat, lima, dan seterusnya, sesuai kebutuhan.

$array1 = [1, 2, 3];
$array2 = [4, 5, 6];
$array3 = [7, 8, 9];

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

print_r($hasil);
    

Maka hasilnya akan jadi:

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

Urutannya akan mengikuti urutan parameter, mulai dari $array1, lalu $array2, dan terakhir $array3. Kalau ada key asosiatif yang sama di ketiga array itu, maka yang jadi pemenang adalah nilai dari array terakhir yang disertakan. Proses override-nya terjadi secara berurutan, dari array pertama, lalu array kedua menimpa, lalu array ketiga menimpa lagi, dan seterusnya.

Perbedaan array_merge() dengan array_merge_recursive()

Meskipun kedua fungsi ini sama-sama berfungsi untuk menggabungkan array, mereka punya perbedaan yang sangat penting. array_merge_recursive() menggabungkan nilai yang memiliki key yang sama ke dalam bentuk array baru. Dengan kata lain, kalau array_merge() meng-override elemen yang punya key sama, maka array_merge_recursive() akan menyimpan dua nilai itu di dalam satu array.

Contohnya, kalau kita pakai array_merge_recursive() pada contoh $user1 dan $user2 di atas:

$gabungUserRec = array_merge_recursive($user1, $user2);
print_r($gabungUserRec);
    

Maka hasilnya bukan 25 yang menimpa 20, melainkan:

Array
(
    [nama] => Budi
    [umur] => Array
        (
            [0] => 20
            [1] => 25
        )
    [kota] => Jakarta
)
    

Jadi, array_merge_recursive() mengumpulkan “umur” yang sama dalam bentuk array, sedangkan array_merge() langsung menimpa nilai lama dengan nilai baru. Mana yang harus dipakai tergantung kebutuhan. Kalau kita mau menimpa data lama dengan data baru, kita pakai array_merge(). Tapi kalau kita mau menyimpan semua data yang ada (walaupun key-nya sama), kita pakai array_merge_recursive().

Contoh Kasus Implementasi array_merge()

Biar makin paham, berikut beberapa contoh kasus nyata di mana array_merge() bisa sangat membantu kamu saat ngoding di PHP.

1. Menggabungkan Data Input Form

Misalnya kita memiliki sebuah form di website yang memiliki dua bagian terpisah: satu bagian input data pribadi (nama, email, dll.), dan satu lagi input alamat (jalan, kota, kode pos, dsb.). Kita bisa simpan data tersebut dalam dua array asosiatif terpisah. Lalu, jika kita mau menggabungkannya jadi satu array agar mudah diproses, kita tinggal panggil array_merge().

// Data pribadi user
$dataPribadi = [
    "nama" => "Agus",
    "email" => "[email protected]"
];

// Data alamat user
$dataAlamat = [
    "alamat" => "Jl. Melati",
    "kota" => "Bandung",
    "kodepos" => 40123
];

// Menggabungkan kedua array
$dataLengkap = array_merge($dataPribadi, $dataAlamat);

print_r($dataLengkap);
    

Hasilnya akan jadi:

Array
(
    [nama] => Agus
    [email] => [email protected]
    [alamat] => Jl. Melati
    [kota] => Bandung
    [kodepos] => 40123
)
    

Langsung rapi kan? Kamu kemudian bisa pakai $dataLengkap untuk disimpan ke database, atau diproses lebih lanjut.

2. Menggabungkan Data dari Database

Kadang kita punya data yang berasal dari beberapa tabel atau query berbeda. Misal, kita ngambil data user yang memuat nama dan email dari satu tabel, lalu kita ngambil data profil dari tabel lain (atau men-decode JSON). Kemudian, kita ingin menyatukan semuanya di satu array sebelum dioper ke front-end.

// Contoh hasil query database
$userData = [
    "user_id" => 1,
    "nama" => "Dewi",
    "email" => "[email protected]"
];

// Contoh data profil tambahan
$userProfile = [
    "hobi" => "Membaca",
    "pekerjaan" => "Programmer"
];

// Gabungkan
$completeData = array_merge($userData, $userProfile);

print_r($completeData);
    

Dengan cara ini, kita dapat dengan mudah menyatukan semua informasi user ke dalam satu struktur data sebelum dikirim dalam format JSON, misalnya. Atau kalau kamu pakai framework tertentu, seringkali data diolah dengan cara serupa agar lebih efisien.

3. Menggabungkan Konfigurasi Aplikasi

Dalam beberapa proyek besar, kita sering punya file konfigurasi yang berisi array PHP. Misalnya, satu file untuk konfigurasi database, satu file lagi untuk konfigurasi mail, satu file lagi untuk konfigurasi caching, dan seterusnya. Kadang kita pengin punya satu array besar yang menampung seluruh konfigurasi secara global.

Misalnya:

// config_db.php
return [
    "db_host" => "localhost",
    "db_name" => "my_database",
    "db_user" => "root",
    "db_pass" => "password"
];

// config_mail.php
return [
    "mail_host" => "smtp.mail.com",
    "mail_user" => "[email protected]",
    "mail_pass" => "secret"
];

// Lalu di file utama, misalnya index.php
$config_db = require("config_db.php");
$config_mail = require("config_mail.php");

$config = array_merge($config_db, $config_mail);

print_r($config);
    

Hasilnya, kita akan punya array $config yang memuat semua informasi dari database dan mail:

Array
(
    [db_host] => localhost
    [db_name] => my_database
    [db_user] => root
    [db_pass] => password
    [mail_host] => smtp.mail.com
    [mail_user] => [email protected]
    [mail_pass] => secret
)
    

Praktis, kan? Begitu juga kalau kita punya banyak file konfigurasi berbeda, tinggal array_merge() saja semua di satu tempat supaya kita punya satu $config besar yang siap dipakai di seluruh aplikasi.

Masalah Umum dan Tips Menggunakan array_merge()

Ada beberapa hal yang perlu kamu perhatikan saat menggunakan array_merge():

1. Index Numerik akan Di-reset: Kalau kamu mengharapkan index numerik dari array pertamamu tetap sama persis di hasil penggabungan, siap-siap kecewa. Karena array_merge() itu akan membuat index baru yang berurutan dari 0, 1, 2, dan seterusnya. Kalau kamu butuh menjaga key numerik yang spesifik, lebih baik pakai fungsi lain seperti array_replace() atau gabungkan array secara manual.
2. Asosiatif akan Di-override oleh Array Terakhir: Kalau ada key asosiatif yang kembar, yang dipakai di hasil final adalah yang terakhir disebut di parameter array_merge(). Perilaku ini mungkin disengaja atau tidak, tergantung use case kamu. Pastikan kamu paham betul kalau ada key asosiatif yang sama di beberapa array yang ingin kamu gabungkan.
3. Tidak Mengubah Array Asli: array_merge() menghasilkan sebuah array baru, bukan memanipulasi array lama. Kalau butuh meng-override secara langsung, kamu bisa melakukan penugasan seperti $array1 = array_merge($array1, $array2). Namun, jika hanya memanggil array_merge($array1, $array2) tanpa menampungnya, ya hasilnya akan terbuang percuma.
4. Gunakan array_merge_recursive() Bila Dibutuhkan: Seperti yang sudah dijelaskan, kalau kamu mau menyimpan semua nilai meskipun key-nya sama, gunakan array_merge_recursive(). Tapi konsekuensinya, kamu akan dapat array bertingkat kalau ada key yang sama, bukan data yang saling menimpa. Pastikan ini sesuai dengan kebutuhanmu.
5. Test Dulu Sebelum Produksi: Meskipun array_merge() relatif sederhana, tetaplah lakukan tes. Apalagi jika ada data yang rumit atau jumlah array yang banyak. Pastikan hasilnya sesuai harapan.

Penanganan array_merge() pada Kasus Spesifik

Walaupun sudah cukup jelas, kadang kita menemukan situasi yang spesifik dan sedikit tricky. Misalnya, kamu ingin menggabungkan dua array numerik yang sebagian isinya sama. Terkadang, kita mengharapkan tidak ada duplikasi. Tapi sayangnya, array_merge() akan memasukkan semua elemen, walaupun nilainya sama persis. Kalau kamu butuh menggabungkan array tanpa duplikasi, biasanya kita pakai array_unique() setelah di-merge.

$array1 = ["apel", "jeruk", "mangga"];
$array2 = ["jeruk", "pepaya"];

// Kita ingin gabung tanpa duplikasi
$gabung = array_merge($array1, $array2);

// Lalu buang duplikasinya
$gabungNoDupe = array_unique($gabung);

print_r($gabungNoDupe);
    

Maka hasilnya:

Array
(
    [0] => apel
    [1] => jeruk
    [2] => mangga
    [4] => pepaya
)
    

Index 3 hilang karena “jeruk” sudah terdeteksi di index 1, dan “array_unique” enggak mengubah index element yang enggak duplikasi, jadi numbering-nya bisa terlihat lompat ke 4. Itu normal, karena array_unique mempertahankan key pertama yang ditemukan.

Ada juga situasi di mana kita butuh menggabungkan array dengan key numeric tertentu. Kita enggak mau index itu diurutkan ulang. Pada kasus seperti ini, array_merge() memang kurang cocok, karena dia akan ‘memperbarui’ index. Kalau kamu pengin menimpa data di index yang sama, coba pakai array_replace(). Sedangkan kalau kamu mau menambahkan data, tapi tetap mempertahankan index, mungkin + (operator plus) di PHP akan membantu, meski punya perilaku yang berbeda pula (key di array pertama tidak akan di-override, hanya menambahkan key yang belum ada).

Keamanan dan Performa

Secara umum, array_merge() aman dipakai. Namun, tetap perlu diingat bahwa setiap kali kamu memanggilnya, PHP membuat array baru. Jadi, kalau datamu sangat besar (misalnya puluhan ribu atau ratusan ribu elemen di masing-masing array), memanggil array_merge() akan memakan memori dan waktu.

Walaupun untuk kasus normal performanya lumayan cepat, untuk proyek besar dengan data sangat besar, kamu mungkin perlu mempertimbangkan cara lain atau minimal mencoba benchmark agar tahu apakah array_merge() cukup efisien. Atau jika struktur data memungkinkannya, kamu bisa pakai iterasi manual untuk menyatukan data. Intinya, semua kembali ke kebutuhan dan volume data yang ditangani.

Contoh Lanjutan: Mencampur Data GET dan POST

Terkadang kita pengin menggabungkan data dari $_GET dan $_POST agar bisa kita proses jadi satu. Walaupun ini jarang disarankan (karena bisa menimbulkan kebingungan soal asal data), tapi kadang-kadang situasi spesifik membuat kita perlu melakukannya.

// Data GET, misalnya ?page=1&limit=10
$_GET = ["page" => "1", "limit" => "10"];

// Data POST, misalnya form berisi 'nama' dan 'email'
$_POST = ["nama" => "Ivan", "email" => "[email protected]"];

$allParams = array_merge($_GET, $_POST);

print_r($allParams);
    

Hasilnya:

Array
(
    [page] => 1
    [limit] => 10
    [nama] => Ivan
    [email] => [email protected]
)
    

Dengan begini, kamu punya satu array berisi semua parameter. Tapi hati-hati, karena data GET atau POST bisa saja menyimpan key yang sama. Kalau itu terjadi, data POST akan menimpa data GET (tergantung urutan parameter array_merge()), atau sebaliknya.

Catatan Penting

Setelah kita membahas panjang lebar tentang array_merge(), beberapa poin penting yang perlu kamu ingat dan catat adalah:

1. Fungsi Dasar Menggabungkan Array: array_merge() adalah solusi praktis jika kamu butuh menggabungkan dua atau lebih array dengan mudah. Dia akan membuat array baru, bukan memodifikasi array lama secara langsung.
2. Penanganan Key Numerik vs. Asosiatif: Jika key-nya numerik, maka indeks dari array baru akan diurutkan ulang. Jika key-nya asosiatif, nilai di array terakhir akan menimpa nilai yang sama di array sebelumnya.
3. Butuh Semua Nilai untuk Key yang Sama? Gunakan array_merge_recursive() agar tiap nilai yang sama key-nya disimpan dalam sub-array. Tapi hal ini membuat struktur array lebih kompleks.
4. Waspadai Duplikasi dan Override: Hasil array_merge() mungkin berisi data duplikat jika isinya memang sama. Jika kamu menggabungkan banyak array asosiatif yang memiliki key sama, data terakhir selalu menimpa yang lama.
5. Gunakan array_unique() Jika Perlu Menghapus Duplikasi: Khususnya untuk array dengan indeks numerik yang menampung nilai sama. Tapi ingat, array_unique() juga berpengaruh pada indeks array tersebut.
6. Performa: Untuk data berukuran normal, array_merge() cukup cepat. Tapi untuk ratusan ribu elemen, perlu diperhitungkan penggunaan memori dan waktu eksekusi.
7. Pastikan Kebutuhan Sebelum Memakai: Tanyakan dulu ke diri sendiri apakah memang ingin menimpa data lama dengan data baru, atau menyimpan keduanya. Itu menentukan pilihanmu: array_merge() atau array_merge_recursive().

Semoga setelah membaca ulasan panjang ini, kamu jadi makin paham bagaimana array_merge() bekerja dan bisa menggunakannya dengan percaya diri di proyek PHP-mu. Selamat berkreasi dengan array, dan tetap semangat belajar hal-hal baru di dunia pemrograman!