Penggabungan JSON

#1Input
#2Input

Alat gabung JSON online gratis. Gabungkan beberapa objek JSON menjadi satu dengan strategi pilihan (Deep Merge/Shallow Merge/Array Concat/Array Replace) dalam sekali klik. Tersedia 4 mode resolusi konflik, cocok untuk agregasi data multi-sumber, konfigurasi berlapis, penggabungan i18n, dan berbagai skenario lainnya.

Rekomendasi Terkait

Apa itu JSON Merge (Penggabungan JSON)?

JSON Merge (penggabungan JSON) adalah operasi menggabungkan dua atau lebih objek JSON menjadi satu objek baru berdasarkan aturan tertentu. Operasi ini sangat sering dijumpai dalam pengembangan perangkat lunak: ① Menggabungkan respons JSON dari beberapa microservice menjadi satu respons terpadu (agregasi lapisan BFF); ② Menggabungkan konfigurasi base, env, dan user menjadi konfigurasi final dengan logika "penimpaan berbasis lingkungan" (Node.js config, Viper, Spring Cloud Config); ③ Menggabungkan, menimpa, dan melengkapi beberapa file terjemahan i18n menjadi kamus lengkap; ④ Menggabungkan beberapa array data mock menjadi data uji yang utuh; ⑤ Menggabungkan beberapa respons paginasi API menjadi hasil lengkap.

Tantangan utama dalam penggabungan bukanlah pada proses "menggabungkan", melainkan pada "cara menangani konflik". Ada 4 strategi resolusi konflik yang umum digunakan: ① **Deep Merge (Penggabungan Dalam)**: memasuki objek bertingkat secara rekursif, menggabungkan setiap key satu per satu, hanya menimpa saat terjadi konflik pada leaf node; cocok untuk konfigurasi berlapis. ② **Shallow Merge (Penggabungan Dangkal)**: hanya menggabungkan key level teratas, key dengan nama sama akan ditimpa seluruhnya; semantik paling sederhana, mirip dengan `Object.assign`. ③ **Array Concat (Penyambungan Array)**: nilai bertipe array digabungkan menjadi satu array panjang dengan mempertahankan urutan semua elemen; cocok untuk agregasi API. ④ **Array Replace (Penggantian Array)**: nilai bertipe array ditimpa seluruhnya oleh input terbaru; cocok untuk penimpaan konfigurasi.

Pada tingkat implementasi, Deep Merge biasanya menggunakan rekursi berbasis stack: terlebih dahulu memeriksa apakah kedua sisi adalah plain object (bukan array, bukan null), kemudian memproses setiap key secara rekursif; saat terjadi ketidakcocokan tipe (misalnya key yang sama di satu sisi bertipe objek dan di sisi lain bertipe array), umumnya ditangani dengan prinsip "input terbaru yang diutamakan", tanpa melakukan konversi tipe. Alat JSON Merge dari GeekFormat memiliki keempat strategi di atas yang dapat diubah langsung di halaman; Anda dapat menempelkan 2 hingga N segmen JSON sekaligus, yang akan digabungkan secara berurutan dan menghasilkan output yang terformat rapi. Seluruh proses penggabungan dilakukan secara lokal di browser, data asli tidak diunggah ke server mana pun.

Kasus penggunaan

  • Menggabungkan respons API dari beberapa microservice menjadi struktur JSON terpadu untuk digunakan frontend
  • Mengagregasi file konfigurasi berlapis base/dev/prod, menghasilkan konfigurasi final dengan penimpaan berbasis lingkungan
  • Menggabungkan, mendeduplikasi, dan melengkapi beberapa file terjemahan i18n per bahasa menjadi kamus lengkap
  • Menggabungkan beberapa array data mock atau beberapa respons API paginasi menjadi dataset lengkap
  • Komponen frontend menggabungkan konfigurasi default + konfigurasi kustom pengguna + konfigurasi eksperimen A/B jarak jauh
  • Dalam migrasi data, menggabungkan file ekspor JSON dari beberapa sistem sumber menjadi format terpadu untuk downstream

Cara Penggunaan

  1. Tempelkan 2 hingga N segmen JSON yang perlu digabungkan secara berurutan ke kolom input sebelah kiri (default 2 kolom), atau klik tombol "+" untuk menambahkan lebih banyak input
  2. Pilih strategi penggabungan pada dropdown toolbar: Deep Merge / Shallow Merge / Array Concat / Array Replace
  3. Klik tombol "Gabungkan", kolom output sebelah kanan akan menampilkan hasil penggabungan yang terformat; jika terdapat kesalahan sintaksis pada input, nomor baris dan pesan error spesifik akan ditampilkan
  4. Setelah memastikan hasil benar, klik "Salin" untuk menyalin hasil penggabungan ke clipboard, atau klik "Unduh" untuk menyimpannya sebagai file merged.json guna melanjutkan proses formatting, validasi Schema, dan penanganan lanjutan lainnya

Fitur

  • 4 strategi penggabungan: Deep Merge / Shallow Merge / Array Concat / Array Replace, dapat diubah sekali klik untuk memenuhi berbagai skenario bisnis
  • Mendukung 2 hingga N segmen JSON: tersedia 2 kolom input secara default, klik tombol "+" untuk menambahkan lebih banyak sumber JSON secara dinamis, fleksibel untuk agregasi multi-sumber
  • Penggabungan rekursif mendalam: memproses objek bertingkat multi-level secara cerdas, menangani konflik leaf node sesuai strategi yang dipilih, mempertahankan semua field yang valid
  • Resolusi konflik yang fleksibel: konflik level teratas dieksekusi sesuai strategi terpilih; konflik objek bertingkat memasuki deep merge; konflik array dibedakan berdasarkan arrayConcat/arrayReplace
  • Output terformat seragam: hasil penggabungan ditampilkan dengan indentasi 2 spasi, memudahkan peninjauan manual dan penyalinan langsung ke alat downstream
  • Penggabungan real-time: tempelkan JSON lalu klik "Gabungkan" untuk mendapatkan hasil; jika terjadi error, nomor baris JSON dan pesan error spesifik akan ditampilkan
  • Diproses secara lokal untuk menjaga privasi: parsing, penggabungan, dan formatting sepenuhnya dilakukan di browser lokal, konten input tidak dikirim ke server mana pun
  • Integrasi mulus dengan alat downstream: hasil penggabungan dapat disalin sekali klik ke alat JSON Format, Schema Validator, Code Generator, dan lainnya untuk diproses lebih lanjut

Contoh Kode

JavaScript Deep Merge menggunakan lodash.merge

javascript
// npm install lodash.merge
import merge from 'lodash.merge';

const a = { user: { name: 'Alice', age: 28 }, tags: ['admin'] };
const b = { user: { email: 'a@x.com', age: 29 }, tags: ['editor'] };

// Deep Merge: objek bertingkat digabungkan secara rekursif, leaf node ditimpa input terbaru
const deep = merge({}, a, b);
console.log(deep);
// => { user: { name: 'Alice', age: 29, email: 'a@x.com' }, tags: ['admin', 'editor'] }

// Shallow Merge: key level teratas ditimpa seluruhnya, tidak memasuki level bertingkat
const shallow = Object.assign({}, a, b);
console.log(shallow);
// => { user: { email: 'a@x.com', age: 29 }, tags: ['editor'] }

Python Deep Merge menggunakan mergedeep

python
# pip install mergedeep
from mergedeep import merge

a = {"user": {"name": "Alice", "age": 28}, "tags": ["admin"]}
b = {"user": {"email": "a@x.com", "age": 29}, "tags": ["editor"]}

# Deep Merge
result = merge(a, b)
print(result)
# => {'user': {'name': 'Alice', 'age': 29, 'email': 'a@x.com'}, 'tags': ['admin', 'editor']}

# Catatan: mergedeep secara default menggabungkan array, string/angka ditimpa
# Jika ingin array ditimpa, tambahkan strategy='override'

Menggabungkan banyak JSON via command line menggunakan jq -s

bash
# Menggabungkan beberapa array JSON menjadi satu array panjang
jq -s 'add' a.json b.json c.json

# Menggabungkan beberapa objek JSON secara rekursif (jq 1.6+)
jq -s 'reduce .[] as $item ({}; . * $item)' a.json b.json

# Shallow Merge: menimpa key level teratas b ke a
jq -s '.[0] * .[1]' a.json b.json

# Setelah penggabungan array, hanya simpan field id yang telah dideduplikasi
jq -s '[.[].items[]] | unique_by(.id)' a.json b.json

Pertanyaan Umum

Apakah JSON Merge dan JSON Concat itu sama?

Tidak sepenuhnya sama. "Concat" (penyambungan) biasanya merujuk pada string yang disambungkan langsung tanpa struktur; "Merge" (penggabungan) merujuk pada penggabungan beberapa objek menjadi satu secara rekursif mengikuti struktur JSON, dengan penanganan konflik nama key. Alat ini menggunakan pendekatan yang terakhir, yaitu JSON Merge yang terstruktur.

Bagaimana memilih antara Deep Merge dan Shallow Merge?

Shallow Merge: hanya memproses key level teratas, key dengan nama sama akan diganti seluruhnya, mirip dengan `Object.assign`, paling sederhana dan langsung. Deep Merge: memasuki objek bertingkat secara rekursif, menggabungkan setiap leaf node satu per satu, lebih cerdas. Jika beberapa JSON Anda menambahkan field pada sub-path yang berbeda (seperti base.user.name dengan override.user.email), gunakan Deep Merge; jika Anda ingin mengganti seluruh sub-objek sekaligus, gunakan Shallow Merge.

Saat menggabungkan array, apakah diurutkan berdasarkan urutan atau indeks?

Alat ini secara default menggunakan semantik "concat" (penyambungan): menggabungkan beberapa array menjadi satu array panjang dengan mempertahankan urutan semua elemen. Jika kedua array Anda memiliki panjang yang sama dan ingin menimpa berdasarkan indeks, beralihlah ke mode "arrayReplace" dan bungkus array secara manual dengan struktur objek.

Saat terjadi konflik nama key, bagaimana menentukan siapa yang menimpa siapa?

Ditentukan berdasarkan urutan input: JSON yang diinputkan kemudian akan menimpa key dengan nama sama dari JSON sebelumnya (pada strategi Shallow/Array Replace terjadi penimpaan seluruhnya, pada Deep Merge hanya menimpa leaf node). Jika Anda ingin "input pertama yang diprioritaskan", cukup balik urutan inputnya.

Apakah mendukung penggabungan JSON array?

Mendukung. Ada dua skenario khas: ① Beberapa JSON semuanya bertipe array → gunakan "arrayConcat" untuk menyambungkan menjadi satu array panjang; ② Beberapa JSON semuanya bertipe objek, dengan field tertentu bertipe array → gunakan "arrayConcat" untuk menggabungkan beberapa array, atau "arrayReplace" untuk mengutamakan input terbaru.

Bisakah menggabungkan lebih dari 2 JSON sekaligus?

Bisa. Tersedia 2 kolom input secara default, klik tombol "+" untuk menambahkan lebih banyak kolom input secara dinamis; semua input akan digabungkan secara berurutan dari atas ke bawah. Secara teori tidak ada batasan jumlah, namun memori browser akan membatasi ukuran per segmen.

Bagaimana urutan key ditentukan setelah penggabungan?

Deep Merge: urutan key dari JSON pertama diutamakan, key baru dari JSON kedua ditambahkan di akhir level yang sesuai. Shallow Merge: mengikuti urutan input, semua key dari JSON pertama muncul lebih dahulu, key baru dari JSON berikutnya ditambahkan di level teratas; key dengan nama sama mempertahankan urutan pertama.

Apakah alat ini akan mengubah tipe field?

Tidak akan mengubah tipe secara aktif. Jika pada strategi Shallow/Array Replace, key dengan nama sama dari dua JSON memiliki tipe yang berbeda (satu objek, satu array), maka akan ditimpa langsung dengan prinsip "input terbaru diutamakan", tanpa konversi tipe. Deep Merge hanya melakukan rekursi ketika "kedua sisi adalah plain object", kondisi lainnya ditangani dengan penimpaan.

Bisakah nilai null dipertahankan?

Bisa. null adalah nilai yang sah dalam JSON, alat ini akan memperlakukan null sebagai nilai leaf biasa: pada Shallow/Array Replace, null dari input terbaru akan menimpa nilai sebelumnya; pada Deep Merge, null akan ditangani mengikuti aturan penimpaan dan tidak dilewati secara khusus.

Apakah akan menampilkan informasi statistik setelah penggabungan?

Ya. Area hasil akan menampilkan jumlah segmen JSON yang ikut digabungkan dan jumlah total key, memudahkan verifikasi hasil secara cepat; untuk daftar field yang mendetail, silakan lihat langsung output terformat di sebelah kanan.

Apakah alat ini akan mengunggah JSON saya ke server?

Tidak. Parsing, penggabungan, dan formatting sepenuhnya dilakukan secara lokal di browser, input dan hasil antara tidak dikirim ke server mana pun. Dapat digunakan secara offline, cocok untuk memproses JSON multi-sumber yang mengandung informasi sensitif (seperti konfigurasi production, respons API internal).

Apa urutan terbaik saat menggunakan alat ini bersama JSON Formatter dan Schema Validator?

Alur kerja yang direkomendasikan: ① JSON Repair (membersihkan JSON tidak valid) → ② JSON Merge alat ini (penggabungan multi-sumber) → ③ JSON Format (penyeragaman indentasi) → ④ JSON Schema Validation (validasi struktur akhir) → ⑤ Code Generation lanjutan (TypeScript / Java / Go, dll.). Pilih beberapa langkah sesuai kebutuhan.

Pemecahan Masalah

Muncul pesan "Unexpected token" atau "Invalid JSON" saat penggabungan

Penyebab: setidaknya ada satu JSON di kolom input yang tidak valid. Solusi: tempelkan JSON yang error ke alat "JSON Repair" untuk dibersihkan (menangani trailing comma, single quote, key tanpa tanda kutip, dll. secara otomatis), lalu kembali ke alat ini untuk menggabungkan; atau periksa apakah kurung kurawal / kurung siku luar terlewat.

Beberapa field tidak muncul setelah penggabungan

Penyebab: pada strategi Shallow/Array Replace, key dengan nama sama ditimpa seluruhnya oleh input terbaru; pada Deep Merge, field bernilai null juga akan menimpa objek sebelumnya. Solusi: beralihlah ke strategi "Deep Merge" dan periksa lapis demi lapis; jika yakin null dari input terbaru yang menimpa, hapus field null tersebut dari JSON input terbaru atau ganti dengan nilai placeholder.

Array ditimpa bukannya disambungkan

Penyebab: strategi saat ini adalah "Shallow Merge" atau "Array Replace". Solusi: beralihlah ke "Array Concat" pada dropdown toolbar; atau gabungkan kedua array secara manual terlebih dahulu sebelum melakukan penggabungan.

Dalam hasil Deep Merge, objek berubah menjadi array atau sebaliknya

Penyebab: pada jalur key yang sama, kedua JSON memiliki tipe yang tidak konsisten ("objek vs array"), Deep Merge akan mengikuti prinsip "input terbaru diutamakan" saat menemui ketidakcocokan tipe. Solusi: seragamkan tipe kedua sisi (keduanya objek atau keduanya array), atau beralih ke strategi Shallow/Array Replace untuk memperjelas semantik.

Urutan key menjadi tidak beraturan setelah penggabungan

Penyebab: key baru dari JSON kedua akan ditambahkan setelah JSON pertama berdasarkan "posisi penyisipan", browser/parser akan mengurutkan key bilangan bulat murni secara numerik secara otomatis. Solusi: gunakan alat "JSON Sort" untuk menyeragamkan urutan key pada semua input JSON terlebih dahulu, baru kemudian gabungkan; atau urutkan kembali sebelum menggunakan hasilnya.

Penggabungan file besar (10 MB+) mengalami freeze/hang

Penyebab: JSON.parse pada beberapa segmen teks besar sekaligus di browser akan memakan banyak memori. Solusi: batasi setiap input dalam rentang 1-2 MB; gunakan script Node.js (lodash.merge) atau Python (mergedeep) secara lokal untuk memproses file yang sangat besar; setelah selesai, gunakan alat ini untuk verifikasi kecil.

Glosarium

JSON Merge
Operasi menggabungkan dua atau lebih objek JSON menjadi satu objek baru berdasarkan aturan tertentu; tantangan utamanya adalah "strategi resolusi saat terjadi konflik nama key".
Deep Merge / Penggabungan Dalam
Strategi penggabungan yang memasuki objek bertingkat secara rekursif dan menggabungkan setiap leaf node; jika kedua sisi adalah plain object maka dilakukan rekursi, selainnya ditangani dengan penimpaan.
Shallow Merge / Penggabungan Dangkal
Strategi yang hanya menggabungkan key level teratas, key dengan nama sama akan ditimpa seluruhnya; dalam JavaScript ekuivalen dengan `Object.assign({}, a, b)`.
Array Concat / Penyambungan Array
Salah satu strategi penggabungan array: menggabungkan beberapa array menjadi satu array panjang dengan mempertahankan urutan semua elemen; sering digunakan untuk agregasi respons API.
Array Replace / Penggantian Array
Salah satu strategi penggabungan array: array dengan nama key yang sama akan ditimpa seluruhnya oleh input terbaru; sering digunakan untuk penimpaan konfigurasi.
Object.assign
Method bawaan JavaScript yang menyalin semua properti enumerable milik sendiri dari satu atau lebih objek sumber ke objek target secara shallow (dangkal); merupakan implementasi standar de facto untuk shallow merge.
lodash.merge
Fungsi deep merge yang disediakan oleh library Lodash, merupakan implementasi deep merge yang paling banyak digunakan dalam ekosistem Node.js; array digabungkan (bukan ditimpa).
mergedeep (Python)
Library deep merge untuk ekosistem Python, instal dengan pip install mergedeep; mendukung parameter strategy untuk mengontrol perilaku penggabungan/penimpaan array.
jq -s 'add'
Perintah jq untuk menjumlahkan beberapa array JSON menjadi satu array tunggal; untuk menggabungkan beberapa objek JSON gunakan `reduce .[] as $item ({}; . * $item)`.
BFF (Backend for Frontend)
Lapisan agregasi yang terletak antara frontend dan layanan backend dalam arsitektur microservice; sering kali perlu menggabungkan respons JSON dari beberapa layanan menjadi respons terpadu, merupakan skenario klasik JSON Merge.

Perbandingan 4 Strategi JSON Merge

StrategiCakupanPenanganan ArraySkenario Khas
Deep Merge (Dalam)Rekursif ke semua level bertingkatMengikuti pilihan arrayConcat/arrayReplaceKonfigurasi berlapis multi-lingkungan, penggabungan kamus i18n
Shallow Merge (Dangkal)Hanya level teratasDitimpa seluruhnyaPenimpaan sederhana ala Object.assign
Array Concat (Sambung Array)Level teratasDisambung menjadi array baruAgregasi API paginasi, penggabungan data mock
Array Replace (Ganti Array)Level teratasInput terbaru diutamakanPenimpaan konfigurasi Feature Flag

Tabel Perbandingan Implementasi JSON Merge yang Umum

Implementasi/LibraryBahasaPerilaku DefaultCatatan
Object.assignJavaScriptShallow MergeLibrary standar ES2015; setelah ES2017 dapat menggunakan `Object.assign({}, a, b)`
{ ...a, ...b }JavaScriptShallow MergeSpread operator, sintaks lebih ringkas
lodash.mergeJavaScriptDeep MergeArray digabungkan bukan ditimpa, npm install lodash.merge
mergedeepPythonDeep MergeGunakan strategy='override' untuk mengubah penggabungan array menjadi penimpaan
deepmerge (Python)PythonDeep MergeImplementasi populer lainnya, pip install deepmerge
jq -s 'add'ShellPenjumlahan arrayPenggabungan objek menggunakan `reduce .[] as $i ({}; . * $i)`

Authoritative References