Unire JSON
Strumento online gratuito per unire JSON. Con un clic unisci più oggetti JSON secondo una strategia scelta (Profonda / Superficiale / Concatena Array / Sostituisci Array) con 4 modalità di risoluzione dei conflitti. Ideale per aggregazione multi-fonte, stratificazione di config e consolidamento i18n.
Raccomandazioni correlate
Cos'è Unire JSON (JSON Merge)?
Unire JSON (JSON Merge) è l'operazione di combinare due o più oggetti JSON in un nuovo oggetto secondo determinate regole. Appare con estrema frequenza in ingegneria: ① Assemblare JSON da più microservizi in una risposta unificata (aggregazione del livello BFF); ② Combinare config base / env / utente secondo la logica 'override per ambiente' per produrre la config finale (Node.js config, Viper, Spring Cloud Config); ③ Unire, sovrascrivere e integrare più file di traduzione i18n in un dizionario completo; ④ Combinare più array di dati mock in dati di test completi; ⑤ Unire più risposte API paginate in un dataset completo.
La parte difficile non è l'unione, ma 'come gestire i conflitti'. Ci sono 4 strategie comuni di risoluzione dei conflitti: ① **Deep Merge**: ricorsione negli oggetti annidati, unendo ogni chiave individualmente e sovrascrivendo solo in caso di conflitto sui nodi foglia - ideale per la stratificazione delle config. ② **Shallow Merge**: unisce solo le chiavi di livello superiore, sostituendo interamente le chiavi con lo stesso nome - semantica più semplice, simile a `Object.assign`. ③ **Concatena Array**: concatena i valori array in un array lungo preservando l'ordine degli elementi - ideale per l'aggregazione di API. ④ **Sostituisci Array**: sostituisce interamente i valori array con l'input successivo - ideale per l'override di config.
A livello di implementazione, il deep merge utilizza tipicamente la ricorsione basata su stack: prima verifica che entrambi i lati siano oggetti semplici (non array, non null), poi elabora ricorsivamente ogni chiave; in caso di tipi incoerenti (es. un lato è un oggetto, l'altro è un array per lo stesso nome), segue generalmente la regola 'l'ultimo input vince' senza conversione di tipo. Lo strumento Unire JSON di GeekFormat include le 4 strategie sopra e permette di passare direttamente sulla pagina; puoi incollare da 2 a N segmenti JSON contemporaneamente, unire automaticamente in ordine, e produrre un risultato uniformemente formattato. L'intero processo di unione avviene localmente nel browser, i dati originali non vengono caricati.
Casi d'uso
- Unisci più risposte API di microservizi in una struttura JSON unificata per il frontend
- Aggrega file di configurazione stratificati base / dev / prod nella config finale tramite override per ambiente
- Unisci più file di traduzione i18n per lingua, deduplica e integra in un dizionario completo
- Combina più array di dati mock o risposte API paginate in un dataset completo
- Componente frontend che unisce config predefinita + personalizzazione utente + config di esperimenti A/B remoti
- Durante la migrazione dei dati, unisci più export JSON di sistemi sorgente in un formato a valle unificato
Come utilizzare
- Incolla da 2 a N segmenti JSON da unire nelle caselle di input sinistre (2 per impostazione predefinita), o clicca '+' per aggiungere altri input
- Seleziona una strategia di unione dal menu a discesa della barra degli strumenti: Deep Merge / Shallow Merge / Concatena Array / Sostituisci Array
- Clicca il pulsante 'Unisci'; la casella di output destra mostra il risultato formattato. Se l'input ha errori di sintassi, vengono mostrati il numero di riga specifico e il messaggio di errore
- Dopo aver confermato il risultato, clicca 'Copia' per mettere l'output unito negli appunti, o clicca 'Scarica' per salvare come merged.json per ulteriore formattazione, validazione Schema, ecc.
Funzionalità
- 4 strategie di unione: Deep Merge / Shallow Merge / Concatena Array / Sostituisci Array, commutabili con un clic per diversi scenari business
- Supporta da 2 a N segmenti JSON: 2 caselle di input predefinite, clicca '+' per aggiungere dinamicamente più JSON sorgente, flessibile per l'aggregazione multi-fonte
- Fusione ricorsiva profonda: gestisce intelligentemente oggetti annidati multi-livello, risolve i conflitti delle foglie secondo la strategia specificata, preservando tutti i campi validi
- Risoluzione dei conflitti flessibile: i conflitti di livello superiore seguono la strategia selezionata; i conflitti di oggetti annidati vanno in profondità; i conflitti di array si differenziano tramite arrayConcat/arrayReplace
- Output uniformemente formattato: i risultati sono mostrati con indentazione di 2 spazi per facile revisione umana e copia diretta verso strumenti a valle
- Esecuzione in tempo reale: clicca 'Unisci' subito dopo l'incollaggio per ottenere i risultati; gli errori mostrano numeri di riga JSON specifici e messaggi di errore
- Elaborazione locale per la privacy: analisi, unione e formattazione avvengono localmente nel browser, nessun input inviato a un server
- Passaggio fluido verso strumenti a valle: i risultati possono essere copiati con un clic verso Formattatore JSON, Validatore Schema, generatori di codice, ecc.
Esempi di codice
Fusione profonda in JavaScript con 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'] };
// Fusione profonda: gli oggetti annidati vengono uniti ricorsivamente, i nodi foglia prendono il valore successivo
const deep = merge({}, a, b);
console.log(deep);
// => { user: { name: 'Alice', age: 29, email: 'a@x.com' }, tags: ['admin', 'editor'] }
// Fusione superficiale: le chiavi di livello superiore vengono sostituite interamente, senza scendere nell'annidamento
const shallow = Object.assign({}, a, b);
console.log(shallow);
// => { user: { email: 'a@x.com', age: 29 }, tags: ['editor'] }Fusione profonda in Python con 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"]}
# Fusione profonda
result = merge(a, b)
print(result)
# => {'user': {'name': 'Alice', 'age': 29, 'email': 'a@x.com'}, 'tags': ['admin', 'editor']}
# Nota: mergedeep concatena gli array per impostazione predefinita; string/number sovrascrive.
# Per la sovrascrittura degli array, aggiungi strategy='override'Unione multi-JSON in CLI con jq -s
bash# Unisci più array JSON in un array lungo
jq -s 'add' a.json b.json c.json
# Unisci ricorsivamente più oggetti JSON (jq 1.6+)
jq -s 'reduce .[] as $item ({}; . * $item)' a.json b.json
# Fusione superficiale: sovrappone le chiavi di livello superiore di b su a
jq -s '.[0] * .[1]' a.json b.json
# Unisci array e mantieni solo i campi id deduplicati
jq -s '[.[].items[]] | unique_by(.id)' a.json b.jsonDomande frequenti
Unire JSON e Concatenare JSON sono la stessa cosa?
Non esattamente. 'Concatenare' di solito significa unire direttamente le stringhe senza struttura; 'unire' significa combinare ricorsivamente più oggetti per struttura JSON e gestire i conflitti dei nomi delle chiavi. Questo strumento si riferisce al secondo - unione strutturata di JSON.
Come scelgo tra Deep Merge e Shallow Merge?
Shallow Merge: gestisce solo le chiavi di livello superiore, le chiavi con lo stesso nome vengono sostituite interamente, simile a `Object.assign` - il più semplice. Deep Merge: ricorre negli oggetti annidati, unendo a ogni nodo foglia - più intelligente. Se i tuoi più JSON aggiungono campi in sotto-percorsi diversi (es. base.user.name e override.user.email), usa deep merge. Se vuoi sostituire un intero sotto-oggetto in una volta, usa shallow merge.
Quando unisco gli array, è per ordine o per indice?
Per impostazione predefinita, questo strumento segue la semantica 'concat': combina più array in un array lungo preservando l'ordine degli elementi. Se i tuoi due array hanno la stessa lunghezza e vuoi la sovrascrittura per indice, passa a 'arrayReplace' e avvolgi manualmente l'array in una struttura di oggetto prima.
Come viene deciso il vincitore del conflitto quando i nomi delle chiavi si scontrano?
Deciso dall'ordine di input: il JSON successivo sovrascrive le chiavi con lo stesso nome precedenti (sovrascrittura totale sotto Shallow / Sostituisci Array, solo sovrascrittura foglia sotto Deep Merge). Se vuoi 'l'input precedente vince', inverti l'ordine di input.
Può unire array JSON?
Sì. Due scenari tipici: ① Più JSON sono tutti array → usa 'arrayConcat' per unire in un array lungo; ② Più JSON sono oggetti, ma un campo è un array → usa 'arrayConcat' per unire gli array, o 'arrayReplace' per mantenere il valore dell'input successivo.
Può unire più di 2 JSON contemporaneamente?
Sì. Per impostazione predefinita ci sono 2 caselle di input; clicca '+' per aggiungerne dinamicamente altre. Tutti gli input vengono uniti dall'alto verso il basso in ordine. Teoricamente illimitato, ma la memoria del browser limita la dimensione di un singolo segmento.
Come viene determinato l'ordine delle chiavi dopo l'unione?
Deep Merge: l'ordine delle chiavi del primo JSON ha la priorità; le nuove chiavi dei JSON successivi vengono aggiunte alla fine del livello corrispondente. Shallow Merge: per ordine di input - tutte le chiavi del primo JSON appaiono per prime, le nuove chiavi dei JSON successivi vengono aggiunte al livello superiore; le chiavi con lo stesso nome mantengono l'ordine della prima invariato.
Lo strumento modifica i tipi dei campi?
No, non modifica attivamente i tipi. Se sotto la strategia Shallow / Sostituisci Array le chiavi con lo stesso nome in due JSON sono di tipi diversi (uno oggetto, uno array), segue 'l'ultimo input vince' e sovrascrive direttamente, senza conversione di tipo. Deep Merge ricorre solo quando entrambi i lati sono oggetti semplici; in tutti gli altri casi sovrascrive.
I valori null vengono preservati?
Sì. null è un valore JSON valido; questo strumento tratta null come un normale valore foglia: sotto Shallow / Sostituisci Array, un null successivo sovrascrive il valore precedente; sotto Deep Merge, un null viene gestito dalla regola di sovrascrittura e non viene saltato appositamente.
L'unione emette statistiche?
Sì. L'area dei risultati mostra il numero di segmenti JSON e il conteggio totale delle chiavi, per una verifica rapida; consulta l'output formattato a destra per la lista completa dei campi.
Lo strumento carica il mio JSON su un server?
No. Analisi, unione e formattazione avvengono localmente nel browser, input e risultati intermedi non vengono inviati a nessun server. Funziona offline, adatto per JSON multi-fonte sensibili (es. config di ambienti di produzione, risposte API interne).
Qual è il miglior ordine di utilizzo con Formattatore JSON e Validatore Schema?
Catena raccomandata: ① Riparare JSON (pulire JSON illegale) → ② Questo strumento Unire JSON (unione multi-fonte) → ③ Formattare JSON (unificare indentazione) → ④ Validazione JSON Schema (verificare struttura finale) → ⑤ Generazione di codice (TypeScript / Java / Go ecc.). Scegli i passi che ti servono.
Risoluzione dei problemi
L'unione mostra 'Unexpected token' o 'Invalid JSON'
Causa: almeno una casella di input contiene JSON non valido. Soluzione: incolla prima il JSON che fallisce nello strumento Riparare JSON per pulirlo (gestisce automaticamente virgole finali, apici singoli, chiavi senza apici, ecc.), poi torna a questo strumento; oppure verifica se ti mancano graffe/parentesi esterne.
Alcuni campi non appaiono dopo l'unione
Causa: sotto la strategia Shallow / Sostituisci Array, le chiavi con lo stesso nome vengono sostituite interamente dall'input successivo; sotto Deep Merge, i campi con valore null sovrascrivono anche l'oggetto precedente. Soluzione: cambia la strategia in 'Deep Merge' per controllare livello per livello; se confermato che è una sovrascrittura null successiva, rimuovi il campo null dal JSON successivo o sostituiscilo con un valore segnaposto.
L'array è stato sostituito invece di concatenato
Causa: la strategia attuale è 'Shallow Merge' o 'Sostituisci Array'. Soluzione: nel menu a discesa della barra degli strumenti, passa a 'Concatena Array'; oppure unisci manualmente i due array in uno prima dell'unione.
Un oggetto è diventato un array (o viceversa) dopo Deep Merge
Causa: i due JSON hanno tipi incoerenti nello stesso percorso ('oggetto vs array'); Deep Merge segue 'l'ultimo input vince' quando i tipi differiscono. Soluzione: unifica i tipi su entrambi i lati (entrambi come oggetto o entrambi come array), o passa alla strategia Shallow / Sostituisci Array per rendere la semantica esplicita.
L'ordine delle chiavi è disordinato dopo l'unione
Causa: le nuove chiavi del secondo JSON vengono aggiunte per posizione di inserimento dopo il primo JSON; browser/parser ordinano automaticamente le chiavi intere pure numericamente. Soluzione: passa prima tutti i JSON di input attraverso lo strumento JSON Sort per unificare l'ordine dei nomi delle chiavi, poi unisci; oppure ordina di nuovo prima di usare il risultato.
File di grandi dimensioni (10 MB+) fanno congelare l'unione
Causa: analizzare molti testi grandi con JSON.parse in una volta occupa molta memoria. Soluzione: mantieni ogni input entro 1-2 MB; per file enormi usa script Node.js (lodash.merge) o Python (mergedeep) localmente; usa questo strumento per piccole verifiche in seguito.
Glossario
- JSON Merge
- Operazione di combinare due o più oggetti JSON in uno nuovo secondo regole specificate. La sfida centrale è la strategia per risolvere i conflitti dei nomi delle chiavi.
- Deep Merge
- Strategia che ricorre negli oggetti annidati e unisce a ogni nodo foglia; ricorre solo quando entrambi i lati sono oggetti semplici, altrimenti ricade sulla sovrascrittura.
- Shallow Merge
- Strategia che unisce solo le chiavi di livello superiore e sostituisce interamente le chiavi con lo stesso nome; equivalente in JS a `Object.assign({}, a, b)`.
- Array Concat
- Una delle strategie di unione degli array: combina più array in un array lungo preservando l'ordine degli elementi; spesso usata per l'aggregazione di risposte API.
- Array Replace
- Una delle strategie di unione degli array: gli array con lo stesso nome vengono sostituiti interamente con l'input successivo; spesso usata per l'override di config.
- Object.assign
- Metodo integrato di JavaScript che copia superficialmente tutte le proprietà proprie enumerabili da uno o più oggetti sorgente a un oggetto destinazione; l'implementazione standard di fatto della fusione superficiale.
- lodash.merge
- Funzione di deep merge fornita dalla libreria Lodash; l'implementazione di deep merge più comune nell'ecosistema Node.js; gli array vengono concatenati, non sovrascritti.
- mergedeep (Python)
- Libreria di deep merge nell'ecosistema Python (pip install mergedeep); supporta un parametro strategy per controllare il comportamento concat vs replace degli array.
- jq -s 'add'
- Comando jq che somma più array JSON in uno; unire più oggetti JSON richiede `reduce .[] as $item ({}; . * $item)`.
- BFF (Backend for Frontend)
- Livello di aggregazione nell'architettura a microservizi situato tra frontend e servizi backend; spesso deve unire le risposte JSON di più servizi in una risposta unificata - uno scenario classico di unione JSON.
4 Strategie di Unione JSON a Confronto
| Strategia | Ambito | Gestione array | Scenario tipico |
|---|---|---|---|
| Deep Merge | Ricorre in tutti i livelli annidati | Secondo arrayConcat/arrayReplace selezionato | Stratificazione config multi-env, unione dizionari i18n |
| Shallow Merge | Unisce solo il livello superiore | Sovrascrittura totale | Sostituzione semplice in stile Object.assign |
| Concatena Array | Livello superiore | Concatenato in nuovo array | Aggregazione API paginate, unione dati mock |
| Sostituisci Array | Livello superiore | L'ultimo input vince | Override config di Feature Flag |
Implementazioni Comuni di Unione JSON a Confronto
| Implementazione / libreria | Linguaggio | Comportamento predefinito | Note |
|---|---|---|---|
| Object.assign | JavaScript | Fusione superficiale | Lib standard ES2015; dopo ES2017 puoi usare `Object.assign({}, a, b)` |
| { ...a, ...b } | JavaScript | Fusione superficiale | Operatore spread; sintassi più concisa |
| lodash.merge | JavaScript | Fusione profonda | Array concatenati (no sovrascrittura); npm install lodash.merge |
| mergedeep | Python | Fusione profonda | strategy='override' per cambiare concat di array in replace |
| deepmerge (Python) | Python | Fusione profonda | Altra implementazione popolare; pip install deepmerge |
| jq -s 'add' | Shell | Somma di array | Unione di oggetti richiede `reduce .[] as $i ({}; . * $i)` |
Authoritative References
- Compressione JSON
- CSV in JSON
- JSON to CSV
- JSON Diff
- JSON Escape / Unescape
- Appiattimento JSON
- Formattatore JSON
- Generatore JSON
- Query JSONPath
- Unire JSON
- Riparare JSON
- Validatore di Schema JSON
- Ordinare JSON
- JSON Stringify
- JSON in HTML
- JSON in Java
- JSON to Markdown
- JSON in SQL
- JSON in TOML
- JSON in TypeScript
- XML in JSON
- JSON in XML
- YAML in JSON
- Da JSON a YAML
- JSON in Python
- JSON in Go
- JSON in Rust
- JSON in Swift
- JSON a C#
- JSON a C++
- JSON to PHP