Início / unix / Perguntas / 780762
Accepted
tinlyx
Asked: 2024-07-25 17:41:07 +0800 CST

Como usar jq para criar um objeto JSON com pares caminho-valor (em vez de pares chave-valor)?

  • 772

Em jqscripts, eu precisava criar objetos json usando pares de valores de caminho (que são mais gerais do que os antigos pares de valores-chave). Ou seja, em vez de uma chave, preciso utilizar um caminho, para que o valor seja criado em um nível mais profundo. (Esses caminhos são fornecidos externamente, então não os conheço antecipadamente.)

Por exemplo, em pseudocódigo que não funciona, gostaria de usar caminhos para criar um objeto como este:

jq -n '{"a"."x" : 3, "b"."y" : 4}'

para que ele crie o mesmo objeto json que jq -n '{"a":{"x" : 3}, "b":{"y" : 4}}', ou seja,

{
  "a": {
    "x": 3
  },
  "b": {
    "y": 4
  }
}

De certa forma, isso é semelhante ao mdir -pque permite criar diretamente um diretório de destino com todos os diretórios ancestrais ao longo do caminho. Mas preciso fazer isso para (muitos) objetos JSON. Daí a pergunta:

Qual é a maneira mais simples de criação de objetos por pares caminho-valor usando jq nativo (talvez mais algum bash)?

(Estou procurando uma solução de baixa complexidade sem programação séria. Isso é com jq-1.7.1. no Ubuntu 24.04 LTS)

-- Esclarecimento --

A entrada que tenho em mente é uma lista de caminhos mais uma lista de valores, como:

[".a.x", ".b.y"]

e

[3, 4]

. O caminho é separado por pontos. Para simplificar, presumo que cada parte entre os pontos seja um identificador simples como y(não um identificador complexo como "y.z"). Ou seja, não considero (por enquanto) caminhos como:

[".a.x", ".b.\"y.z\""]
jq

1 respostas

  1. Best Answer
    $ jq -n '.a.x = 3 | .b.y = 4'
{
  "a": {
    "x": 3
  },
  "b": {
    "y": 4
  }
}

    A jqexpressão primeiro define a xchave abaixo acomo 3e o objeto resultante é passado por meio do canal para outra atribuição semelhante, definindo a ychave bcomo 4no mesmo objeto.

    No entanto, isso usa os caminhos estáticos .a.xe .b.y.

    Você gostaria de trabalhar com dados fornecidos pelo shell, então você poderia fazer o seguinte para seus dois valores:

    jq -n --argjson value 3 'setpath($ARGS.positional; $value)' --args a x |
jq    --argjson value 4 'setpath($ARGS.positional; $value)' --args b y

    Serve setpath()para definir o caminho fornecido pela lista no final da linha de comando ( ae xna primeira instância) para o valor fornecido à $valuevariável. O resultado é então passado para uma jqinvocação semelhante que adiciona um segundo valor em outro caminho (observe a falta -naqui!) Se o valor deve ser adicionado como uma string (não um número), então use --argno lugar de --argjsonquando você dê o valor.

    O resultado desse pipeline seria

    {
  "a": {
    "x": 3
  },
  "b": {
    "y": 4
  }
}

    Dependendo da forma em que você tem o caminho no shell, pode ser útil passar uma matriz de caminho totalmente construída para jq:

    jq -n --argjson path '["a","x"]' --argjson value 3 'setpath($path; $value)' |
jq    --argjson path '["b","y"]' --argjson value 4 'setpath($path; $value)'

    Se você tiver os caminhos no formato .a.xe .b.y, poderá dividi-los para split()formar matrizes de caminho para setpath():

    jq -n --arg path .a.x --argjson value 3 'setpath($path|split(".")[1:]; $value)' |
jq    --arg path .b.y --argjson value 4 'setpath($path|split(".")[1:]; $value)'

    O [1:]resultado de split()é necessário apenas se as strings do caminho começarem com um ponto. Observe que esta é a primeira variação desta solução que não permite pontos nos nomes das chaves.

    Com sua opinião esclarecida levada em consideração, você pode usar

    jq -n --argjson path '[".a.x", ".b.y"]' --argjson value '[3,4]' '[ ([$path,$value]|transpose[]) as [$p,$v] | setpath($p|split(".")[1:];$v) ] | add'

    Isso primeiro cria um único par $p("caminho") e $v("valor") de cada elemento combinado das duas matrizes $pathe $value. A $pstring é então dividida de maneira semelhante a antes, e o valor $vé atribuído a ela com setpath().

    A única “mágica” aqui é a inicial [$path,$value] | transpose[], que gera os dois arrays

    [".a.x",3]
[".b.y",4]

    ... e o fato de toda a operação ocorrer dentro de um construtor de array, formando o array

    [
  {
    "a": {
      "x": 3
    }
  },
  {
    "b": {
      "y": 4
    }
  }
]

    ... que addentão se combina em nosso produto final:

    {
  "a": {
    "x": 3
  },
  "b": {
    "y": 4
  }
}

    Novamente, pontos não são permitidos em strings de chaves e também assumimos que o comprimento dos arrays de entrada será sempre o mesmo.

    • 3

relate perguntas