Wie man JSON zusammenführt
2025/05/20
9 Min. Lesezeit

Wie man JSON zusammenführt

Umfassender Leitfaden zum Zusammenführen von JSON-Objekten in verschiedenen Programmiersprachen

Einführung in das Zusammenführen von JSON

Das Zusammenführen von JSON-Objekten ist eine grundlegende Operation in der Datenverarbeitung, dem Konfigurationsmanagement und bei API-Interaktionen. Ob Sie Benutzereinstellungen kombinieren, Konfigurationsdateien zusammenführen oder API-Antworten aggregieren, das Verständnis der korrekten Zusammenführung von JSON-Objekten ist für die moderne Entwicklung entscheidend.

JSON-Zusammenführung bezieht sich auf den Prozess, zwei oder mehr JSON-Objekte zu einem einheitlichen Objekt zu kombinieren. Dieser Prozess kann für flache Objekte einfach sein, wird aber komplexer, wenn es um verschachtelte Strukturen, Arrays und widersprüchliche Werte geht.

Grundlegende Konzepte der JSON-Zusammenführung

Bevor wir in die Implementierungsdetails eintauchen, ist es wichtig, einige Schlüsselkonzepte im Zusammenhang mit der JSON-Zusammenführung zu verstehen:

Flache vs. Tiefe Zusammenführung

  • Flache Zusammenführung: Nur die Eigenschaften der obersten Ebene werden kombiniert. Wenn beide Objekte dieselbe Eigenschaft enthalten, überschreibt der Wert aus dem zweiten Objekt den ersten.
  • Tiefe Zusammenführung: Der Zusammenführungsvorgang durchläuft rekursiv den Objektbaum und kombiniert verschachtelte Objekte, anstatt sie zu ersetzen.

Zusammenführungsstrategien für widersprüchliche Werte

Bei der Zusammenführung von JSON-Objekten können widersprüchliche Werte auf verschiedene Weise behandelt werden:

StrategieBeschreibungAnwendungsfall
Letzter gewinntWert aus dem letzten Objekt überschreibt frühere WerteStandardkonfigurationen
Erster gewinntWert aus dem ersten Objekt wird beibehaltenBeibehaltung von Benutzereinstellungen
Benutzerdefinierte LogikAnwendung spezifischer Logik für verschiedene EigenschaftenKomplexe Geschäftsregeln
Fehler bei KonfliktFehler auslösen, wenn Konflikte erkannt werdenKritische Datenintegrität

JavaScript-Methoden zum Zusammenführen von JSON

JavaScript bietet mehrere integrierte Methoden zum Zusammenführen von JSON-Objekten:

Verwendung von Object.assign()

Die Methode Object.assign() führt eine flache Zusammenführung durch und kopiert alle aufzählbaren eigenen Eigenschaften von Quellobjekten in ein Zielobjekt.

const json1 = { name: "John", age: 30 };
const json2 = { city: "New York", age: 31 };

const merged = Object.assign({}, json1, json2);
console.log(merged);
// Ausgabe: { name: "John", city: "New York", age: 31 }

Beachten Sie, dass Eigenschaften mit demselben Schlüssel von Objekten überschrieben werden, die später in der Parameterliste stehen.

Verwendung des Spread-Operators (...)

Der Spread-Operator bietet eine präzisere Möglichkeit, Objekte zusammenzuführen:

const json1 = { name: "John", age: 30 };
const json2 = { city: "New York", age: 31 };

const merged = { ...json1, ...json2 };
console.log(merged);
// Ausgabe: { name: "John", city: "New York", age: 31 }

Diese Methode überschreibt auch doppelte Schlüssel mit Werten aus späteren Objekten.

Tiefes Zusammenführen von JSON-Objekten

Sowohl Object.assign() als auch der Spread-Operator führen flache Zusammenführungen durch. Für verschachtelte Objekte benötigen Sie eine tiefe Zusammenführungsimplementierung:

Rekursive Funktion für tiefe Zusammenführung

function deepMerge(target, source) {
  const output = Object.assign({}, target);
  
  if (isObject(target) && isObject(source)) {
    Object.keys(source).forEach(key => {
      if (isObject(source[key])) {
        if (!(key in target)) {
          Object.assign(output, { [key]: source[key] });
        } else {
          output[key] = deepMerge(target[key], source[key]);
        }
      } else {
        Object.assign(output, { [key]: source[key] });
      }
    });
  }
  
  return output;
}

function isObject(item) {
  return (item && typeof item === 'object' && !Array.isArray(item));
}

// Verwendung
const json1 = { 
  name: "John", 
  address: { 
    city: "New York", 
    zip: 10001 
  } 
};

const json2 = { 
  name: "Jane", 
  address: { 
    state: "NY" 
  } 
};

const merged = deepMerge(json1, json2);
console.log(merged);
// Ausgabe: { 
//   name: "Jane", 
//   address: { 
//     city: "New York", 
//     zip: 10001, 
//     state: "NY" 
//   } 
// }

Verwendung von Bibliotheken zum Zusammenführen von JSON

Für komplexere Zusammenführungsszenarien sollten Sie etablierte Bibliotheken in Betracht ziehen:

Lodash's merge und mergeWith

Lodash bietet robuste Funktionen für tiefe Zusammenführungen:

const _ = require('lodash');

const json1 = { user: { name: "John", data: [1, 2] } };
const json2 = { user: { age: 30, data: [3, 4] } };

// Einfache tiefe Zusammenführung
const merged1 = _.merge({}, json1, json2);
console.log(merged1);
// Ausgabe: { user: { name: "John", age: 30, data: [3, 4] } }

// Benutzerdefinierte Zusammenführung mit mergeWith
const merged2 = _.mergeWith({}, json1, json2, (objValue, srcValue) => {
  if (Array.isArray(objValue)) {
    return objValue.concat(srcValue);
  }
});
console.log(merged2);
// Ausgabe: { user: { name: "John", age: 30, data: [1, 2, 3, 4] } }

deepmerge Paket

Das deepmerge npm-Paket ist speziell für tiefe Zusammenführungen konzipiert:

const deepmerge = require('deepmerge');

const json1 = { user: { name: "John", hobbies: ["reading"] } };
const json2 = { user: { age: 30, hobbies: ["swimming"] } };

// Standardzusammenführung (verkettet Arrays)
const merged = deepmerge(json1, json2);
console.log(merged);
// Ausgabe: { user: { name: "John", age: 30, hobbies: ["reading", "swimming"] } }

// Benutzerdefinierte Array-Zusammenführung
const overwriteMerge = (destinationArray, sourceArray) => sourceArray;
const options = { arrayMerge: overwriteMerge };
const mergedCustom = deepmerge(json1, json2, options);
console.log(mergedCustom);
// Ausgabe: { user: { name: "John", age: 30, hobbies: ["swimming"] } }

Zusammenführen von JSON in anderen Sprachen

Python

Verwendung der integrierten Dictionary-Update-Methode:

import json

json1_str = '{"name": "John", "age": 30}'
json2_str = '{"city": "New York", "age": 31}'

# JSON-Strings in Dictionaries parsen
json1 = json.loads(json1_str)
json2 = json.loads(json2_str)

# Dictionaries zusammenführen
merged = {**json1, **json2}  # Python 3.5+

# Zurück in JSON-String konvertieren
merged_json = json.dumps(merged)
print(merged_json)
# Ausgabe: {"name": "John", "city": "New York", "age": 31}

Für tiefe Zusammenführung in Python:

def deep_merge(dict1, dict2):
    result = dict1.copy()
    for key, value in dict2.items():
        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
            result[key] = deep_merge(result[key], value)
        else:
            result[key] = value
    return result

json1 = {"user": {"name": "John", "settings": {"theme": "dark"}}}
json2 = {"user": {"age": 30, "settings": {"notifications": True}}}

merged = deep_merge(json1, json2)
print(merged)
# Ausgabe: {'user': {'name': 'John', 'settings': {'theme': 'dark', 'notifications': True}, 'age': 30}}

Ruby

Verwendung der Hash#merge-Methode:

require 'json'

json1_str = '{"name": "John", "age": 30}'
json2_str = '{"city": "New York", "age": 31}'

# JSON-Strings in Hashes parsen
json1 = JSON.parse(json1_str)
json2 = JSON.parse(json2_str)

# Hashes zusammenführen
merged = json1.merge(json2)

# Zurück in JSON-String konvertieren
merged_json = JSON.generate(merged)
puts merged_json
# Ausgabe: {"name":"John","city":"New York","age":31}

Für tiefe Zusammenführung in Ruby:

require 'json'

# Rubys integrierte deep_merge
require 'active_support/core_ext/hash/deep_merge'

json1 = JSON.parse('{"user": {"name": "John", "settings": {"theme": "dark"}}}')
json2 = JSON.parse('{"user": {"age": 30, "settings": {"notifications": true}}}')

merged = json1.deep_merge(json2)
puts JSON.generate(merged)
# Ausgabe: {"user":{"name":"John","settings":{"theme":"dark","notifications":true},"age":30}}

Spezielle Zusammenführungsfälle

Zusammenführen von Arrays

Beim Zusammenführen von JSON-Objekten, die Arrays enthalten, haben Sie mehrere Strategien:

  1. Ersetzen: Spätere Arrays ersetzen frühere vollständig
  2. Verketten: Kombinieren Sie die Elemente beider Arrays
  3. Zusammenführen nach Index: Führen Sie Array-Elemente an denselben Positionen zusammen
  4. Zusammenführen nach ID: Führen Sie Array-Elemente basierend auf einem Identifikationsfeld zusammen
// Beispiel für Verkettung von Arrays
const json1 = { tags: ["important", "urgent"] };
const json2 = { tags: ["completed", "archived"] };

const merged = {
  ...json1,
  tags: [...json1.tags, ...json2.tags]
};
console.log(merged);
// Ausgabe: { tags: ["important", "urgent", "completed", "archived"] }

// Beispiel für Zusammenführen von Arrays nach ID
const users1 = { users: [{ id: 1, name: "John" }, { id: 2, name: "Jane" }] };
const users2 = { users: [{ id: 1, age: 30 }, { id: 3, name: "Bob", age: 25 }] };

function mergeArraysById(arr1, arr2, idKey) {
  const merged = [...arr1];
  
  arr2.forEach(item2 => {
    const item1Index = merged.findIndex(item1 => item1[idKey] === item2[idKey]);
    
    if (item1Index >= 0) {
      merged[item1Index] = { ...merged[item1Index], ...item2 };
    } else {
      merged.push(item2);
    }
  });
  
  return merged;
}

const mergedUsers = {
  users: mergeArraysById(users1.users, users2.users, 'id')
};

console.log(mergedUsers);
// Ausgabe: {
//   users: [
//     { id: 1, name: "John", age: 30 },
//     { id: 2, name: "Jane" },
//     { id: 3, name: "Bob", age: 25 }
//   ]
// }

Umgang mit null und undefined Werten

Beim Zusammenführen von Objekten müssen Sie entscheiden, wie mit null und undefined Werten umgegangen werden soll:

const json1 = { name: "John", age: null, city: undefined };
const json2 = { age: 30 };

// Standardverhalten (null-Werte werden kopiert, undefined werden ignoriert)
const merged1 = Object.assign({}, json1, json2);
console.log(merged1);
// Ausgabe: { name: "John", age: 30 }

// Benutzerdefinierte Behandlung bei tiefer Zusammenführung
function customDeepMerge(target, source) {
  const output = Object.assign({}, target);
  
  if (isObject(target) && isObject(source)) {
    Object.keys(source).forEach(key => {
      // Null-Werte in der Quelle überspringen
      if (source[key] === null) return;
      
      if (isObject(source[key])) {
        if (!(key in target)) {
          output[key] = source[key];
        } else {
          output[key] = customDeepMerge(target[key], source[key]);
        }
      } else {
        output[key] = source[key];
      }
    });
  }
  
  return output;
}

Kommandozeilentools zum Zusammenführen von JSON

Verwendung von jq

jq ist ein leistungsstarker Kommandozeilen-JSON-Prozessor, der JSON-Dateien zusammenführen kann:

# Zwei JSON-Dateien zusammenführen
jq -s '.[0] * .[1]' file1.json file2.json > merged.json

# Tiefe Zusammenführung mit benutzerdefinierter Array-Behandlung
jq -s '.[0] * .[1] | .array = (.[0].array + .[1].array)' file1.json file2.json > merged.json

Verwendung von Node.js

Sie können ein einfaches Skript erstellen, um JSON-Dateien mit Node.js zusammenzuführen:

const fs = require('fs');
const _ = require('lodash');

// JSON-Dateien lesen
const file1 = JSON.parse(fs.readFileSync('file1.json', 'utf8'));
const file2 = JSON.parse(fs.readFileSync('file2.json', 'utf8'));

// Objekte zusammenführen
const merged = _.merge({}, file1, file2);

// Ergebnis schreiben
fs.writeFileSync('merged.json', JSON.stringify(merged, null, 2));

Best Practices für das Zusammenführen von JSON

  1. Seien Sie explizit bei doppelten Schlüsseln: Verstehen Sie, wie Ihre gewählte Methode Schlüsselkonflikte behandelt
  2. Berücksichtigen Sie Unveränderlichkeit: Erstellen Sie neue Objekte, anstatt bestehende zu modifizieren
  3. Behandeln Sie tiefe Zusammenführung sorgfältig: Verwenden Sie geeignete rekursive Methoden oder Bibliotheken für verschachtelte Objekte
  4. Validieren Sie das zusammengeführte Ergebnis: Stellen Sie sicher, dass das endgültige Objekt eine gültige Struktur hat
  5. Testen Sie mit Grenzfällen: Leere Objekte, Null-Werte, tief verschachtelte Strukturen
  6. Dokumentieren Sie Ihre Zusammenführungsstrategie: Machen Sie deutlich, wie Konflikte gelöst werden
  7. Berücksichtigen Sie die Leistung: Bei großen Objekten können einige tiefe Zusammenführungsimplementierungen ineffizient sein

Fazit

Das Zusammenführen von JSON-Objekten ist eine häufige, aber nuancierte Operation. Die geeignete Zusammenführungsstrategie hängt von Ihren spezifischen Anforderungen, der Datenstruktur und der Sprachumgebung ab. Durch das Verständnis der verschiedenen Zusammenführungstechniken und ihrer Auswirkungen können Sie Daten aus verschiedenen Quellen effektiv kombinieren und gleichzeitig die Datenintegrität wahren und die Bedürfnisse Ihrer Anwendung erfüllen.

Autor

avatar for Corey
Corey

Kategorien

Newsletter

Treten Sie der Community bei

Abonnieren Sie unseren Newsletter für die neuesten Nachrichten und Updates