Comment fusionner 2 objets JSON à partir de 2 fichiers en utilisant jq?

J'utilise les outils jq (jq-json-processor) dans le script shell pour analyser json.

J'ai 2 fichiers json et je souhaite les fusionner en un seul fichier

Voici le contenu des fichiers:

fichier1

{
    "value1": 200,
    "timestamp": 1382461861,
    "value": {
        "aaa": {
            "value1": "v1",
            "value2": "v2"
        },
        "bbb": {
            "value1": "v1",
            "value2": "v2"
        },
        "ccc": {
            "value1": "v1",
            "value2": "v2"
        }
    }
}

fichier2

{
    "status": 200,
    "timestamp": 1382461861,
    "value": {
        "aaa": {
            "value3": "v3",
            "value4": 4
        },
        "bbb": {
            "value3": "v3"
        },      
        "ddd": {
            "value3": "v3",
            "value4": 4
        }
    }
}

résultat attendu

{
    "value": {
        "aaa": {
            "value1": "v1",
            "value2": "v2",
            "value3": "v3",
            "value4": 4
        },
        "bbb": {
            "value1": "v1",
            "value2": "v2",
            "value3": "v3"
        },
        "ccc": {
            "value1": "v1",
            "value2": "v2"
        },
        "ddd": {
            "value3": "v3",
            "value4": 4
        }
    }
}

J'essaye beaucoup de combinaisons mais le seul résultat que j'obtiens est le suivant, ce qui n'est pas le résultat attendu:

{
  "ccc": {
    "value2": "v2",
    "value1": "v1"
  },
  "bbb": {
    "value2": "v2",
    "value1": "v1"
  },
  "aaa": {
    "value2": "v2",
    "value1": "v1"
  }
}
{
  "ddd": {
    "value4": 4,
    "value3": "v3"
  },
  "bbb": {
    "value3": "v3"
  },
  "aaa": {
    "value4": 4,
    "value3": "v3"
  }
}

En utilisant cette commande:

jq -s '.[].value' file1 file2

Depuis la version 1.4, cela est désormais possible avec l' *opérateur. Lorsqu'on lui donne deux objets, il les fusionnera récursivement. Par exemple,

jq -s '.[0] * .[1]' file1 file2

Important: notez l' -s (--slurp)indicateur, qui place les fichiers dans le même tableau.

Vous obtiendriez:

{
  "value1": 200,
  "timestamp": 1382461861,
  "value": {
    "aaa": {
      "value1": "v1",
      "value2": "v2",
      "value3": "v3",
      "value4": 4
    },
    "bbb": {
      "value1": "v1",
      "value2": "v2",
      "value3": "v3"
    },
    "ccc": {
      "value1": "v1",
      "value2": "v2"
    },
    "ddd": {
      "value3": "v3",
      "value4": 4
    }
  },
  "status": 200
}

Si vous souhaitez également vous débarrasser des autres clés (comme le résultat attendu), une façon de le faire est la suivante:

jq -s '.[0] * .[1] | {value: .value}' file1 file2

Ou probablement un peu plus efficace (car il ne fusionne aucune autre valeur):

jq -s '.[0].value * .[1].value | {value: .}' file1 file2

Utilisez jq -s add:

$ echo '{"a":"foo","b":"bar"} {"c":"baz","a":0}' | jq -s add
{
  "a": 0,
  "b": "bar",
  "c": "baz"
}

Cela lit tous les textes JSON de stdin dans un tableau ( jq -sfait cela) puis il les "réduit".

( addest défini comme def add: reduce .[] as $x (null; . + $x);, qui itère sur les valeurs du tableau d'entrée / objet et les ajoute. Ajout d'objet == merge.)

Qui sait si vous en avez encore besoin, mais voici la solution.

Une fois que vous arrivez à l' --slurpoption, c'est facile!

--slurp/-s:
    Instead of running the filter for each JSON object in the input,
    read the entire input stream into a large array and run the filter just once.

Ensuite, l' +opérateur fera ce que vous voulez:

jq -s '.[0] + .[1]' config.json config-user.json

(Remarque: si vous souhaitez fusionner des objets internes au lieu de simplement écraser ceux du fichier de gauche par ceux du fichier de droite, vous devrez le faire manuellement)

Voici une version qui fonctionne de manière récursive (en utilisant *) sur un nombre arbitraire d'objets:

echo '{"A": {"a": 1}}' '{"A": {"b": 2}}' '{"B": 3}' | jq --slurp 'reduce .[] as $item ({}; . * $item)'
{
  "A": {
    "a": 1,
    "b": 2
  },
  "B": 3
}

Premièrement, {"value": .value} peut être abrégé en seulement {value}.

Deuxièmement, l'option --argfile (disponible dans jq 1.4 et jq 1.5) peut être intéressante car elle évite d'avoir à utiliser l'option --slurp.

En les mettant ensemble, les deux objets des deux fichiers peuvent être combinés de la manière spécifiée comme suit:

$ jq -n --argfile o1 file1 --argfile o2 file2 '$o1 * $o2 | {value}'

Le drapeau '-n' dit à jq de ne pas lire depuis stdin, puisque les entrées proviennent des options --argfile ici.

Cela peut être utilisé pour fusionner n'importe quel nombre de fichiers spécifié dans la commande:

jq -rs 'reduce .[] as $item ({}; . * $item)' file1.json file2.json file3.json ... file10.json

ou ceci pour n'importe quel nombre de fichiers

jq -rs 'reduce .[] as $item ({}; . * $item)' ./*.json