cClaude.rocks ☕ Le blog

Voici comment combiner deux fichiers JSON pour obtenir un fichier de synthèse sur la base d’une clé commune.

L’idée est de partir de deux fichiers JSON contenant des données disjointes, mais ayant une clé commune et de construire un fichier contenant les données des deux fichiers.

Prenons deux fichiers JSON :

[
  { "A": "a0", "B": "b0" },
  { "A": "a1", "B": "b1" },
  { "A": "a2", "B": "b2" },
  { "A": "a3", "B": "b3" }
]

[
  { "A": "a0", "C": "c0" },
  { "A": "a2", "C": "c2" },
  { "A": "a4", "C": "c4" },
  { "A": "a8", "C": "c6" },
  { "A": "a6", "C": "c8" }
]

Dans le cas ci-dessus :

• La clé commune est le champ A.
• Le premier fichier renseigne le contenu du champ B,
• Le premier fichier renseigne le contenu du champ C,
• Les données sont incomplètes.

Voici la formule magique :

jq --slurp 'flatten(1) | group_by(.A) | map(reduce .[] as $x ({}; . * $x))' fichier1.json fichier2.json

Explications :

Commençons par voir ce que fait :

jq -c '.' C.json B.json # le -c permet d’avoir une vue compacte du résultat et de voir les « lots » traités par jq.

[{"A":"a0","C":"c0"},{"A":"a2","C":"c2"},{"A":"a4","C":"c4"},{"A":"a8","C":"c6"},{"A":"a6","C":"c8"}]
[{"A":"a0","B":"b0"},{"A":"a1","B":"b1"},{"A":"a2","B":"b2"},{"A":"a3","B":"b3"}]

Ici on comprend que les deux fichiers seront traités séparément et ce n’est pas ce que l’on souhaite, pour résoudre cela nous utiliserons le paramètre --slurp.

jq --slurp -c '.' C.json B.json

[[{"A":"a0","C":"c0"},{"A":"a2","C":"c2"},{"A":"a4","C":"c4"},{"A":"a8","C":"c6"},{"A":"a6","C":"c8"}],[{"A":"a0","B":"b0"},{"A":"a1","B":"b1"},{"A":"a2","B":"b2"},{"A":"a3","B":"b3"}]]

Cette fois, on a bien une seule ligne, mais on a un tableau contenant deux éléments correspondant aux deux fichiers. Cependant nous souhaitons obtenir un seul tableau à la fin (comme dans les fichiers initiaux), pour cela on va commencer le filtre jq par la commande flatten :

jq --slurp -c 'flatten' C.json B.json

[{"A":"a0","C":"c0"},{"A":"a2","C":"c2"},{"A":"a4","C":"c4"},{"A":"a8","C":"c6"},{"A":"a6","C":"c8"},{"A":"a0","B":"b0"},{"A":"a1","B":"b1"},{"A":"a2","B":"b2"},{"A":"a3","B":"b3"}]

Maintenant nous avons un flux JSON avec toutes nos données, mais si on considère le champ A comme une clé, il y a des doublons.

jq -c 'flatten' <<<'[1, [2], [[3]]]'

[1,2,3]

jq -c 'flatten(1)' <<<'[1, [2], [[3]]]'

[1,2,[3]]

jq -c 'flatten(2)' <<<'[1, [2], [[3]]]'

[1,2,3]

Mettons les doublons en évidence à l’aide de la commande group_by :

jq --slurp -c 'flatten(1) | group_by(.A)' C.json B.json

[
  [{"A":"a0","C":"c0"},{"A":"a0","B":"b0"}],
  [{"A":"a1","B":"b1"}],
  [{"A":"a2","C":"c2"},{"A":"a2","B":"b2"}],
  [{"A":"a3","B":"b3"}],[{"A":"a4","C":"c4"}],
  [{"A":"a6","C":"c8"}],[{"A":"a8","C":"c6"}]
]

Il ne reste plus qu’à faire un MapReduce pour obtenir le résultat attendu :

jq --slurp -c 'flatten | group_by(.A) | map(reduce .[] as $x ({}; . * $x))' C.json B.json

• La commande map(x) est équivalente à [.[] | x], cela indique que pour la suite on traitera les éléments du tableau un par un et non pas le tableau dans sa globalité.
• La commande reduce permet d’itérer sur les éléments qui arrive (donc, du fait la commande map précédente, des éléments du tableau.

jq 'reduce .[] as $item (0; . + $item)' <<<'[10,2,5,3,22]'

Dans le cas étudié, on utilise reduce .[] as $x ({}; . * $x):

On part donc de l’élément vide {} et on fusionne (*) tous les éléments du tableau obtenu par group_by ensemble et c’était le résultat souhaité.

Quelques précisions

• Pour aller plus loin

  Voici un exemple complet avec des fichiers de départ légèrement différents, et surtout avec des données inconsistantes dans le champ nommé X.

  Regardons comment cela se comporte :

  cat <<EOF >B.json
  [
    { "A": "a0", "B": "b0" },
    { "A": "a1", "B": "b1", "X": "x1b" },
    { "A": "a2", "B": "b2", "X": "x2b" },
    { "A": "a3", "B": "b3" }
  ]
  EOF
  
  cat <<EOF >C.json
  [
    { "A": "a0", "C": "c0" },
    { "A": "a2", "C": "c2", "X": "x2c" },
    { "A": "a4", "C": "c4" },
    { "A": "a8", "C": "c6" },
    { "A": "a6", "C": "c8" }
  ]
  EOF
  
  jq --slurp --sort-keys -c 'flatten(1) | group_by(.A) | map(reduce .[] as $x ({}; . * $x))' B.json C.json
  jq --slurp --sort-keys -c 'flatten(1) | group_by(.A) | map(reduce .[] as $x ({}; . * $x))' C.json B.json
  

  Notez que pour obtenir un résultat plus prédictible l’option --sort-keys a été ajoutée et que pour améliorer la lisibilité les résultats ont été reformatés.

  Lorsque le fichier B.json est en premier et le fichier C.json en second, on obtient ceci :

  [
    {"A":"a0","B":"b0","C":"c0"},
    {"A":"a1","B":"b1","X":"x1b"},
    {"A":"a2","B":"b2","C":"c2","X":"x2c"},
    {"A":"a3","B":"b3"},
    {"A":"a4","C":"c4"},
    {"A":"a6","C":"c8"},
    {"A":"a8","C":"c6"}
  ]
  

  Lorsque on met d’abord le fichier C.json puis le fichier B.json, on obtient cela :

  [
    {"A":"a0","B":"b0","C":"c0"},
    {"A":"a1","B":"b1","X":"x1b"},
    {"A":"a2","B":"b2","C":"c2","X":"x2b"},
    {"A":"a3","B":"b3"},
    {"A":"a4","C":"c4"},
    {"A":"a6","C":"c8"},
    {"A":"a8","C":"c6"}
  ]
  

  On constate qu’en cas de conflit des données entre les fichiers ce sera le dernier fichier qui sera pris en compte. Ce qui est parfaitement prédictible d’après le code utilisé pour faire la réduction : reduce .[] as $x ({}; . * $x)

Références

Documentation sur les filtres :

• flatten(depth)
• map(x)
• reduce(x)

ᦿ