jq - Online na nuvem

PROGRAMA:

NOME

jq - Processador JSON de linha de comando

SINOPSE

jq [opções...] filtro [arquivos...]

jq pode transformar JSON de várias maneiras, selecionando, iterando, reduzindo e de outra forma
mutilar documentos JSON. Por exemplo, executando o comando jq ´map (.price) | adicionar precisarão
pegue uma matriz de objetos JSON como entrada e retorne a soma de seus campos de "preço".

jq pode aceitar entrada de texto também, mas por padrão, jq lê um fluxo de entidades JSON
(incluindo números e outros literais) de stdin. O espaço em branco só é necessário para separar
entidades como 1 e 2 e verdadeiro e falso. Um ou mais arquivos pode ser especificado, no qual
casas jq irá ler a entrada daqueles em vez disso.

A opções são descritos no INVOCAÇÃO JQ seção; eles se referem principalmente a entradas e saídas
formatação. O filtro é escrito na linguagem jq e especifica como transformar o
arquivo ou documento de entrada.

FILTROS

Um programa jq é um "filtro": ele pega uma entrada e produz uma saída. Há muitos
filtros embutidos para extrair um determinado campo de um objeto ou converter um número para
uma string, ou várias outras tarefas padrão.

Os filtros podem ser combinados de várias maneiras - você pode canalizar a saída de um filtro para
outro filtro ou colete a saída de um filtro em uma matriz.

Alguns filtros produzem resultados múltiplos, por exemplo, há um que produz todos os
elementos de sua matriz de entrada. Canalizar esse filtro em um segundo executa o segundo filtro para
cada elemento da matriz. Geralmente, coisas que seriam feitas com loops e iteração
em outras línguas, são feitos apenas colando filtros em jq.

É importante lembrar que todo filtro possui uma entrada e uma saída. Mesmo literais
como "olá" ou 42 são filtros - eles recebem uma entrada, mas sempre produzem o mesmo literal que
saída. Operações que combinam dois filtros, como adição, geralmente alimentam a mesma entrada
para ambos e combinar os resultados. Então, você pode implementar um filtro de média como adicionar / comprimento
- alimentar a matriz de entrada tanto para o adicionar filtro e o comprimento filtrar e, em seguida, executar
a divisão.

Mas isso é nos ultrapassar. :) Vamos começar com algo mais simples:

INVOCAÇÃO JQ

Os filtros jq são executados em um fluxo de dados JSON. A entrada para jq é analisada como uma sequência de
valores JSON separados por espaços em branco que são passados ​​pelo filtro fornecido um em um
Tempo. A (s) saída (s) do filtro são gravadas para saída padrão, novamente como uma sequência de
dados JSON separados por espaço em branco.

Nota: é importante observar as regras de cotação do shell. Como regra geral, é melhor
sempre entre aspas (com aspas simples) o programa jq, já que muitos caracteres com
significado especial para jq também são metacaracteres de shell. Por exemplo, jq "foo" vai falhar em
a maioria dos shells Unix porque isso será o mesmo que jq Foo, que geralmente falhará
Porque Foo is não definido. Ao usar o shell de comando do Windows (cmd.exe), é melhor
use aspas duplas em seu programa jq quando fornecido na linha de comando (em vez do -f
arquivo de programa opção), mas as aspas duplas no programa jq precisam de escape de barra invertida.

Você pode afetar como jq lê e escreve sua entrada e saída usando alguma linha de comando
opções:

· --versão:

Produza a versão jq e saia com zero.

· --seq:

Use o application / json-seq Esquema de tipo MIME para separar textos JSON na entrada jq
e saída. Isso significa que um caractere ASCII RS (separador de registro) é impresso antes
cada valor na saída e um ASCII LF (alimentação de linha) é impresso após cada saída. Entrada
Textos JSON que falham na análise são ignorados (mas avisados ​​sobre), descartando todos
entrada subsequente até o próximo RS. Este mais também analisa a saída de jq sem o
--seq opção.

· --Stream:

Analisa a entrada em streaming, gerando matrizes de valores de caminho e folha
(escalares e matrizes vazias ou objetos vazios). Por exemplo, "a" torna-se [[],"uma"] e
[[], "a", ["b"]] torna-se [[0], []], [[1], "a"] e [[1,0], "b"].

Isso é útil para processar entradas muito grandes. Use isso em conjunto com
filtragem e o reduzir e foreach sintaxe para reduzir grandes entradas de forma incremental.

· --slurp/-s:

Em vez de executar o filtro para cada objeto JSON na entrada, leia toda a entrada
stream em uma grande matriz e execute o filtro apenas uma vez.

· --entrada bruta/-R:

Não analise a entrada como JSON. Em vez disso, cada linha de texto é passada para o filtro como um
fragmento. Se combinado com --slurp, então toda a entrada é passada para o filtro como um
única corda longa.

· --null-input/-n:

Não leia nenhuma entrada! Em vez disso, o filtro é executado uma vez usando nulo como entrada.
Isso é útil ao usar jq como uma calculadora simples ou para construir dados JSON a partir de
coçar, arranhão.

· --saída compacta / -c:

Por padrão, jq ​​imprime bastante a saída JSON. Usar esta opção resultará em mais
saída compacta colocando cada objeto JSON em uma única linha.

· --aba:

Use uma tabulação para cada nível de indentação em vez de dois espaços.

· --recuar n:

Use o número fornecido de espaços (não mais do que 8) para recuo.

· --color-saída / -C e - saída monocromática / -M:

Por padrão, jq ​​gera JSON colorido se estiver gravando em um terminal. Você pode forçá-lo a
produza cor mesmo se escrever em um tubo ou arquivo usando -C, e desabilitar a cor com -M.

· --saída ascii / -a:

jq geralmente produz pontos de código Unicode não ASCII como UTF-8, mesmo se a entrada especificada
como sequências de escape (como "\ u03bc"). Usando esta opção, você pode forçar jq a
produza saída ASCII pura com cada caractere não ASCII substituído pelo equivalente
sequência de fuga.

· --sem buffer

Libere a saída após cada objeto JSON ser impresso (útil se você estiver fazendo um piping lento
fonte de dados em jq e saída de jq em outro lugar).

· --sort-keys / -S:

Produza os campos de cada objeto com as chaves em ordem de classificação.

· --saída bruta / -r:

Com esta opção, se o resultado do filtro for uma string, ele será escrito diretamente
para a saída padrão em vez de ser formatado como uma string JSON com aspas. Isso pode
ser útil para fazer filtros jq se comunicarem com sistemas não baseados em JSON.

· --join-saída / -j:

Como -r mas jq não imprimirá uma nova linha após cada saída.

· -f nome do arquivo / --De arquivo nome do arquivo:

Lê o filtro do arquivo em vez da linha de comando, como a opção -f do awk. Vocês
também pode usar ´ # ´ para fazer comentários.

· -Ldiretório / -L anuário:

Anexar anuário para a lista de pesquisa de módulos. Se esta opção for usada, então não
lista de pesquisa embutida é usada. Veja a seção sobre módulos abaixo.

· -e / --exit-status:

Define o status de saída de jq para 0 se os últimos valores de saída não foram falso nem nulo,
1 se o último valor de saída foi falso or nuloou 4 se nenhum resultado válido foi
produzido. Normalmente o jq sai com 2 se houver algum problema de uso ou erro do sistema, 3
se houve um erro de compilação do programa jq ou 0 se o programa jq foi executado.

· --arg nome valor:

Esta opção passa um valor para o programa jq como uma variável predefinida. Se você executar o jq
com --arg Foo Barra, Em seguida $ foo está disponível no programa e tem o valor "Barra".
Observe que valor será tratado como uma string, então --arg Foo 123 vai ligar $ foo para "123".

· --argjson nome Texto JSON:

Esta opção passa um valor codificado em JSON para o programa jq como uma variável predefinida. Se
você executa o jq com --argjson Foo 123, Em seguida $ foo está disponível no programa e tem o
valor 123.

· --slurpfile nome variável nome do arquivo:

Esta opção lê todos os textos JSON no arquivo nomeado e vincula uma matriz de
valores JSON analisados ​​para a variável global fornecida. Se você executar o jq com --argfile Foo Barra,
então $ foo está disponível no programa e tem uma matriz cujos elementos correspondem a
os textos no arquivo denominado Barra.

· --argfile nome variável nome do arquivo:

Não use. Usar --slurpfile ao invés.

(Esta opção é como --slurpfile, mas quando o arquivo tem apenas um texto, então esse é
usado, caso contrário, uma matriz de textos é usada como em --slurpfile.)

· --run-testes [nome do arquivo]:

Executa os testes no arquivo fornecido ou na entrada padrão. Esta deve ser a última opção dada
e não respeita todas as opções anteriores. A entrada consiste em linhas de comentários, vazias
linhas e linhas de programa seguidas por uma linha de entrada, tantas linhas de saída quantas forem
esperado (um por saída) e uma linha vazia final. Testes de falha de compilação
comece com uma linha contendo apenas "%% FAIL" e, em seguida, uma linha contendo o programa para
compile, em seguida, uma linha contendo uma mensagem de erro para comparar com o real.

Esteja avisado que esta opção pode mudar de forma incompatível com versões anteriores.

BASIC FILTROS

.
O filtro absolutamente mais simples (e menos interessante) é .. Este é um filtro que leva seu
entrada e a produz inalterada como saída.

Uma vez que jq por padrão imprime bastante todas as saídas, este programa trivial pode ser uma maneira útil de
formatar a saída JSON de, digamos, enrolar.

jq´.´
"Olá Mundo!"
=> "Olá, mundo!"

.foo, .foo.bar
O mais simples útil filtro é .foo. Quando dado um objeto JSON (também conhecido como dicionário ou hash) como
entrada, produz o valor na chave "foo", ou null se não houver nenhum presente.

Se a chave contiver caracteres especiais, você deve colocá-la entre aspas duplas, como
esta: . "foo $".

Um filtro do formulário .foo.bar é equivalente a .foo | .bar.

jq ´.foo´
{"foo": 42, "bar": "dados menos interessantes"}
=> 42

jq ´.foo´
{"notfoo": verdadeiro, "alsonotfoo": falso}
=> nulo

jq ´. ["foo"] ´
{"foo": 42}
=> 42

.foo?
Assim como .foo, mas não produz nem mesmo um erro quando . não é uma matriz ou um objeto.

jq ´.foo? ´
{"foo": 42, "bar": "dados menos interessantes"}
=> 42

jq ´.foo? ´
{"notfoo": verdadeiro, "alsonotfoo": falso}
=> nulo

jq ´. ["foo"]? ´
{"foo": 42}
=> 42

jq ´ [.foo?] ´

=> []

. [ ], . [2], . [10:15]
Você também pode pesquisar os campos de um objeto usando uma sintaxe como . ["foo"] (.foo acima é um
versão abreviada disso). Este também funciona para matrizes, se a chave for um inteiro.
Matrizes são baseadas em zero (como javascript), então . [2] retorna o terceiro elemento da matriz.

A . [10:15] A sintaxe pode ser usada para retornar um subarray de um array ou substring de uma string.
A matriz retornada por . [10:15] será de comprimento 5, contendo os elementos do índice 10
(inclusive) para o índice 15 (exclusivo). Qualquer um dos índices pode ser negativo (nesse caso, conta
para trás a partir do final da matriz), ou omitido (neste caso, refere-se ao início ou
final da matriz).

A . [2] A sintaxe pode ser usada para retornar o elemento no índice fornecido. Índices negativos são
permitido, com -1 referindo-se ao último elemento, -2 referindo-se ao próximo ao último elemento,
e assim por diante.

A .foo a sintaxe funciona apenas para chaves simples, ou seja, chaves que são todas caracteres alfanuméricos.
. [ ] funciona com teclas que contêm caracteres especiais, como dois pontos e pontos. Para
exemplo . ["foo :: bar"] e . ["foo.bar"] trabalhar enquanto .foo :: bar e .foo.bar não faria.

A ? "operador" também pode ser usado com o operador de fatia, como em . [10:15]?, que produz
valores onde as entradas podem ser cortadas.

jq ´. [0] ´
[{"nome": "JSON", "bom": verdadeiro}, {"nome": "XML", "bom": falso}]
=> {"nome": "JSON", "bom": verdadeiro}

jq ´. [2] ´
[{"nome": "JSON", "bom": verdadeiro}, {"nome": "XML", "bom": falso}]
=> nulo

jq ´. [2: 4] ´
["a", "b", "c", "d", "e"]
=> ["c", "d"]

jq ´. [2: 4] ´
"abcdefghi"
=> "cd"

jq ´. [: 3] ´
["a", "b", "c", "d", "e"]
=> ["a", "b", "c"]

jq ´. [- 2:] ´
["a", "b", "c", "d", "e"]
=> ["d", "e"]

jq ´. [- 2] ´

=> 2

. []
Se você usar o .[índice] sintaxe, mas omita o índice inteiramente, ele retornará todos os que acontecerá no marco da
elementos de uma matriz. Correndo . [] com a entrada irá produzir os números como três
resultados separados, em vez de uma única matriz.

Você também pode usar isso em um objeto e ele retornará todos os valores do objeto.

jq ´. [] ´
[{"nome": "JSON", "bom": verdadeiro}, {"nome": "XML", "bom": falso}]
=> {"nome": "JSON", "bom": verdadeiro}, {"nome": "XML", "bom": falso}

jq ´. [] ´
[]
=>

jq ´. [] ´
{"a": 1, "b": 1}
=> 1, 1

. []?
Como . [], mas nenhum erro será gerado se. não é uma matriz ou objeto.

,
Se dois filtros forem separados por uma vírgula, a entrada será alimentada em ambos e lá
serão várias saídas: primeiro, todas as saídas produzidas pela expressão à esquerda e
em seguida, todas as saídas produzidas pela direita. Por exemplo, filtro .foo, .Barraproduz
ambos os campos "foo" e "bar" como saídas separadas.

jq ´.foo, .bar´
{"foo": 42, "bar": "algo mais", "baz": verdadeiro}
=> 42, "outra coisa"

jq ´.user, .projects [] ´
{"usuário": "stedolan", "projetos": ["jq", "wikiflow"]}
=> "stedolan", "jq", "wikiflow"

jq ´. [4,2] ´
["a", "b", "c", "d", "e"]
=> "e", "c"

|
O | operador combina dois filtros, alimentando a (s) saída (s) daquele à esquerda em
a entrada da direita. É praticamente o mesmo que o tubo do shell Unix, se
você está acostumado com isso.

Se o da esquerda produzir vários resultados, o da direita será executado para
cada um desses resultados. Então, a expressão . [] | .foo recupera o campo "foo" de cada
elemento da matriz de entrada.

jq ´. [] | .nome
[{"nome": "JSON", "bom": verdadeiro}, {"nome": "XML", "bom": falso}]
=> "JSON", "XML"

TIPOS E VALORES

jq suporta o mesmo conjunto de tipos de dados que JSON - números, strings, booleanos, matrizes,
objetos (que na linguagem JSON são hashes com apenas chaves de string) e "null".

Booleanos, nulos, strings e números são escritos da mesma maneira que em javascript. Assim como
tudo o mais em jq, esses valores simples pegam uma entrada e produzem uma saída - 42 é um
expressão jq válida que recebe uma entrada, a ignora e retorna 42 em seu lugar.

Ordem formação - []
Como em JSON, [] é usado para construir matrizes, como em . Os elementos das matrizes podem
ser qualquer expressão jq. Todos os resultados produzidos por todas as expressões são coletados
em uma grande matriz. Você pode usá-lo para construir uma matriz a partir de uma quantidade conhecida de valores
(Como em [.foo, .Barra, .baz]) ou para "coletar" todos os resultados de um filtro em uma matriz (como
in [.itens []. nome])

Depois de entender o operador ",", você pode olhar para a sintaxe do array jq em um diferente
luz: a expressão não está usando uma sintaxe integrada para matrizes separadas por vírgulas,
mas, em vez disso, está aplicando o [] operador (coleta de resultados) para a expressão 1,2,3 (que
produz três resultados diferentes).

Se você tiver um filtro X que produz quatro resultados, então a expressão [X] irá produzir um
resultado único, uma matriz de quatro elementos.

jq ´ [.user, .projects []] ´
{"usuário": "stedolan", "projetos": ["jq", "wikiflow"]}
=> ["stedolan", "jq", "wikiflow"]

objetos - {}
Como JSON, {} é para construir objetos (também conhecidos como dicionários ou hashes), como em: {"uma": 42,
"b": 17/XNUMX/XNUMX}.

Se as teclas forem "sensíveis" (todos os caracteres alfabéticos), as aspas podem ser deixadas de fora.
O valor pode ser qualquer expressão (embora você possa precisar colocá-lo entre parênteses se for um
complicado), que é aplicado à {} entrada da expressão (lembre-se, todos os filtros
tem uma entrada e uma saída).

{foo: .bar}

irá produzir o objeto JSON {"foo": 42/XNUMX/XNUMX} se dado o objeto JSON {"bar": 42, "baz": 43}.
Você pode usar isso para selecionar campos específicos de um objeto: se a entrada for um objeto com
"usuário", "título", "id" e "conteúdo" campos e se você quiser apenas "usuário" e "título", você pode
escrever

{usuário: .user, título: .title}

Por ser tão comum, existe uma sintaxe de atalho: {do utilizador, título}.

Se uma das expressões produzir vários resultados, vários dicionários serão
produzido. Se a entrada for

{"usuário": "stedolan", "títulos": ["JQ Primer", "Mais JQ"]}

então a expressão

{usuário, título: .titles []}

irá produzir dois resultados:

{"usuário": "stedolan", "título": "JQ Primer"}
{"usuário": "stedolan", "título": "Mais JQ"}

Colocar parênteses ao redor da chave significa que ela será avaliada como uma expressão. Com o
mesma entrada acima,

{(.usuário): .títulos}

produz

{"stedolan": ["JQ Primer", "More JQ"]}

jq ´ {usuário, título: .títulos []} ´
{"usuário": "stedolan", "títulos": ["JQ Primer", "Mais JQ"]}
=> {"usuário": "stedolan", "title": "JQ Primer"}, {"user": "stedolan", "title": "More JQ"}

jq ´ {(. usuário): .titles} ´
{"usuário": "stedolan", "títulos": ["JQ Primer", "Mais JQ"]}
=> {"stedolan": ["JQ Primer", "Mais JQ"]}

CONSTRUÍDAS EM OPERADORES E FUNÇÕES

Algum operador jq (por exemplo, +) fazem coisas diferentes dependendo do tipo de
argumentos (matrizes, números, etc.). No entanto, jq ​​nunca faz conversões de tipo implícitas. Se
você tenta adicionar uma string a um objeto, você obterá uma mensagem de erro e nenhum resultado.

Adição - +
O operador + pega dois filtros, aplica-os à mesma entrada e adiciona o
resultados juntos. O que "adicionar" significa depende dos tipos envolvidos:

· Números são adicionados pela aritmética normal.

· Arrays são adicionados ao serem concatenados em uma matriz maior.

· Cordas são adicionados sendo unidos em uma string maior.

· objetos são adicionados pela mesclagem, ou seja, inserindo todos os pares de valores-chave de ambos
objetos em um único objeto combinado. Se ambos os objetos contiverem um valor para o mesmo
chave, o objeto à direita do + vitórias. (Para mesclagem recursiva, use o * operador.)

nulo pode ser adicionado a qualquer valor e retorna o outro valor inalterado.

jq ´.a + 1´
{"a": 7}
=> 8

jq ´.a + .b´
{"a": [1,2], "b": [3,4]}
=> [1,2,3,4]

jq ´.a + nulo´
{"a": 1}
=> 1

jq ´.a + 1´
{}
=> 1

jq ´ {a: 1} + {b: 2} + {c: 3} + {a: 42} ´
nulo
=> {"a": 42, "b": 2, "c": 3}

Subtração - -
Bem como a subtração aritmética normal em números, o - operador pode ser usado em matrizes
para remover todas as ocorrências dos elementos do segundo array do primeiro array.

jq ´4 - .a´
{"a": 3}
=> 1

jq ´. - ["xml", "yaml"] ´
["xml", "yaml", "json"]
=> ["json"]

Multiplicação, divisão, módulo - *, /, e %
Esses operadores infixos se comportam conforme o esperado quando dados dois números. Divisão por zero aumentos
um erro. x % y calcula x módulo y.

Multiplicar uma string por um número produz a concatenação dessa string que muitos
vezes. "x" * 0 produz nulo.

Dividir uma corda por outra divide a primeira usando a segunda como separadores.

Multiplicar dois objetos irá fundi-los recursivamente: isso funciona como adição, mas se ambos
objetos contêm um valor para a mesma chave e os valores são objetos, os dois são mesclados
com a mesma estratégia.

jq ´10 /. * 3´
5
=> 6

jq ´. / "," ´
"a, b, c, d, e"
=> ["a", "b, c, d", "e"]

jq ´ {"k": {"a": 1, "b": 2}} * {"k": {"a": 0, "c": 3}} ´
nulo
=> {"k": {"a": 0, "b": 2, "c": 3}}

jq ´. [] | (1 /.)? ´
[1,0, -1]
=> 1, -1

comprimento
A função embutida comprimento obtém o comprimento de vários tipos diferentes de valor:

· O comprimento de um corda é o número de pontos de código Unicode que ele contém (que serão
o mesmo que seu comprimento codificado em JSON em bytes se for ASCII puro).

· O comprimento de um ordem é o número de elementos.

· O comprimento de um objeto é o número de pares de valores-chave.

· O comprimento do nulo é zero.

jq ´. [] | comprimento´ [[1,2], "string", {"a": 2}, nulo] => 2, 6, 1, 0

chaves, chaves_unsorted
A função embutida chaves, quando dado um objeto, retorna suas chaves em um array.

As chaves são classificadas "em ordem alfabética", por ordem de ponto de código Unicode. Isto não é um pedido
que faz sentido em qualquer idioma em particular, mas você pode contar que é o
mesmo para quaisquer dois objetos com o mesmo conjunto de chaves, independentemente das configurações de localidade.

Quando chaves recebe uma matriz, ele retorna os índices válidos para essa matriz: os inteiros
de 0 a comprimento-1.

A chaves_unsorted função é como chaves, mas se a entrada for um objeto, as chaves
não serão classificadas; em vez disso, as chaves estarão aproximadamente no pedido de inserção.

jq ´chaves´
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["Foo", "abc", "abcd"]

jq ´chaves´

=> [0,1,2]

tem (chave)
A função embutida tem retorna se o objeto de entrada tem a chave dada, ou a entrada
array tem um elemento no índice fornecido.

tem ($ key) tem o mesmo efeito que verificar se $ chave é um membro da matriz retornada
by chaves, Embora tem será mais rápido.

jq ´map (has ("foo")) ´
[{"foo": 42}, {}]
=> [verdadeiro, falso]

jq ´map (tem(2)) ´
[[0,1], ["a", "b", "c"]]
=> [falso, verdadeiro]

in
A função embutida in retorna a chave de entrada está no objeto fornecido, ou o índice de entrada
corresponde a um elemento na matriz fornecida. É, essencialmente, uma versão inversa de
tem.

jq ´. [] | em ({"foo": 42}) ´
["foo", "bar"]
=> verdadeiro, falso

jq ´map (in ([0,1])) ´
[2, 0]
=> [falso, verdadeiro]

caminho (path_expression)
Exibe representações de matriz da expressão de caminho fornecida em .. As saídas são matrizes de
strings (chaves em objetos0 e / ou números (índices de array.

Expressões de caminho são expressões jq como .a, Mas também . []. Existem dois tipos de caminho
expressões: aquelas que podem corresponder exatamente e aquelas que não podem. Por exemplo, .abc é um
expressão de caminho de correspondência exata, enquanto .a []. b não é.

caminho (exact_path_expression) irá produzir a representação do array da expressão do caminho
mesmo que não exista em ., Se . is nulo ou uma matriz ou um objeto.

caminho (padrão) irá produzir representações de array dos caminhos correspondentes de cinto de segurança se o
caminhos existem em ..

Observe que as expressões de caminho não são diferentes das expressões normais. A expressão
caminho (.. | select (type == "boolean")) produz todos os caminhos para valores booleanos em ., e somente
esses caminhos.

jq ´caminho (.a [0] .b) ´
nulo
=> ["a", 0, "b"]

jq ´ [caminho (..)] ´
{"a": [{"b": 1}]}
=> [[], ["a"], ["a", 0], ["a", 0, "b"]]

del (path_expression)
A função embutida do remove uma chave e seu valor correspondente de um objeto.

jq ´del (.foo) ´
{"foo": 42, "bar": 9001, "baz": 42}
=> {"bar": 9001, "baz": 42}

jq ´del (. [1, 2]) ´
["foo", "bar", "baz"]
=> ["foo"]

para_entradas, de_entradas, com_entradas
Essas funções são convertidas entre um objeto e uma matriz de pares de valores-chave. Se para_entradas
é passado um objeto, então para cada k: v entrada na entrada, a matriz de saída inclui
{"chave": k, "valor": v}.

de_entradas faz a conversão oposta, e with_entries (foo) é uma abreviatura para
para_entradas | mapa (foo) | de_entradas, útil para fazer alguma operação em todas as chaves e
valores de um objeto. de_entradas aceita chave, chave, nome, valor e valor como chaves.

jq ´para_entries´
{"a": 1, "b": 2}
=> [{"chave": "a", "valor": 1}, {"chave": "b", "valor": 2}]

jq ´de_entradas´
[{"chave": "a", "valor": 1}, {"chave": "b", "valor": 2}]
=> {"a": 1, "b": 2}

jq ´with_entries (.key | = "KEY_" +.) ´
{"a": 1, "b": 2}
=> {"KEY_a": 1, "KEY_b": 2}

select (boolean_expression)
A função selecionar (foo) produz sua entrada inalterada se Foo retorna verdadeiro para essa entrada,
e não produz nenhuma saída de outra forma.

É útil para filtrar listas: | mapa (selecione (. >= 2)) Darei à você .

jq ´map (selecione (.> = 2)) ´

=> [5,3,7]

jq ´. [] | selecione (.id == "segundo") ´
[{"id": "primeiro", "val": 1}, {"id": "segundo", "val": 2}]
=> {"id": "segundo", "val": 2}

matrizes, objetos, iteráveis, booleanos, números, normais, finitos, cordas, nulos, valores,
escalares
Esses integrados selecionam apenas entradas que são arrays, objetos, iteráveis ​​(arrays ou
objetos), booleanos, números, números normais, números finitos, strings, nulo, não nulo
valores e não iteráveis, respectivamente.

jq ´. [] | números´
[[], {}, 1, "foo", nulo, verdadeiro, falso]
=> 1

vazio
vazio não retorna resultados. Nenhum mesmo. Nem mesmo nulo.

É útil de vez em quando. Você saberá se precisar :)

jq ´1, vazio, 2´
nulo
=> 1, 2

jq ´ [1,2, vazio, 3] ´
nulo
=> [1,2,3]

erro(Mensagem)
Produz um erro, assim como .a aplicado a valores diferentes de null e objetos seriam, mas
com a mensagem fornecida como o valor do erro.

$ __ loc__
Produz um objeto com uma tecla "arquivo" e uma tecla "linha", com o nome do arquivo e o número da linha
onde $ __ loc__ ocorre, como valores.

jq ´try error ("\ ($ __ loc__)") catch .´
nulo
=> "{\" arquivo \ ": \" \",\"linha 1}"

mapa (x), map_values ​​(x)
Para qualquer filtro x, mapa (x) irá executar esse filtro para cada elemento da matriz de entrada, e
produz as saídas em uma nova matriz. mapa (. + 1) irá incrementar cada elemento de uma matriz de
números.

Do mesmo modo, map_values ​​(x) executará esse filtro para cada elemento, mas retornará um
objeto quando um objeto é passado.

mapa (x) é equivalente a [. [] | x]. Na verdade, é assim que está definido. De forma similar,
map_values ​​(x) é definido como . [] |= x.

jq ´map (. + 1) ´

=> [2,3,4]

jq ´map_values ​​(. + 1) ´
{"a": 1, "b": 2, "c": 3}
=> {"a": 2, "b": 3, "c": 4}

caminhos, caminhos (node_filter), caminhos_folha
caminhos envia os caminhos para todos os elementos em sua entrada (exceto que não produz o
lista vazia, representando. em si).

caminhos (f) produz os caminhos para quaisquer valores para os quais f é verdade. Isso é, caminhos (números)
gera os caminhos para todos os valores numéricos.

caminhos_folha é um pseudônimo de caminhos (escalares); caminhos_folha is obsoleta e será removido em
o próximo grande lançamento.

jq ´ [caminhos] ´
[1, [[], {"a": 2}]]
=> [[0],[1],[1,0],[1,1],[1,1,"a"]]

jq ´ [caminhos (escalares)] ´
[1, [[], {"a": 2}]]
=> [[0], [1,1, "a"]]

adicionar
O filtro adicionar toma como entrada um array e produz como saída os elementos do array
somados. Isso pode significar somados, concatenados ou mesclados, dependendo dos tipos de
os elementos da matriz de entrada - as regras são iguais às do + operador
(descrito acima).

Se a entrada for uma matriz vazia, adicionar Retorna nulo.

jq ´adicionar´
["abc"]
=> "abc"

jq ´adicionar´
[1, 2, 3]
=> 6

jq ´adicionar´
[]
=> nulo

qualquer, qualquer (condição), qualquer (gerador; doença)
O filtro qualquer toma como entrada uma matriz de valores booleanos e produz verdadeiro como saída se
qualquer um dos elementos da matriz é verdadeiro.

Se a entrada for uma matriz vazia, qualquer Retorna falso.

A qualquer (condição) forma aplica a condição fornecida aos elementos da matriz de entrada.

A qualquer (gerador; doença) forma aplica a condição dada a todas as saídas do
determinado gerador.

jq ´qualquer´
[verdadeiro falso]
=> verdadeiro

jq ´qualquer´
[falso, falso]
=> falso

jq ´qualquer´
[]
=> falso

tudo, todos (condição), todos (gerador; doença)
O filtro todos os toma como entrada uma matriz de valores booleanos e produz verdadeiro como saída se
todos os elementos da matriz são verdadeiro.

A todos (condição) forma aplica a condição fornecida aos elementos da matriz de entrada.

A todos (gerador; doença) forma aplica a condição dada a todas as saídas do
determinado gerador.

Se a entrada for uma matriz vazia, todos os Retorna verdadeiro.

jq ´todos´
[verdadeiro falso]
=> falso

jq ´todos´
[verdade verdade]
=> verdadeiro

jq ´todos´
[]
=> verdadeiro

[Requer 1.5] achatar, achatar (profundidade)
O filtro achatar recebe como entrada uma matriz de matrizes aninhadas e produz uma matriz simples em
em que todos os arrays dentro do array original foram recursivamente substituídos por seus valores.
Você pode passar um argumento para ele para especificar quantos níveis de aninhamento nivelar.

achatar(2) é como achatar, mas indo apenas até dois níveis de profundidade.

jq ´achatar´
[1, [2], [[3]]]
=> [1, 2, 3]

jq´achatar(1) ´
[1, [2], [[3]]]
=> [1, 2, [3]]

jq ´achatar´
[[]]
=> []

jq ´achatar´
[{"foo": "bar"}, [{"foo": "baz"}]]
=> [{"foo": "bar"}, {"foo": "baz"}]

alcance (até), intervalo (de; até) intervalo (de; até; por)
A alcance função produz um intervalo de números. intervalo (4; 10) produz 6 números, de 4
(inclusivo) a 10 (exclusivo). Os números são produzidos como saídas separadas. Usar
[intervalo (4; 10)] para obter um intervalo como uma matriz.

A forma de um argumento gera números de 0 até o número fornecido, com um incremento de
1.

A forma de dois argumentos gera números de da para até com um incremento de 1.

A forma de três argumentos gera números da para até com um incremento de by.

jq ´range (2; 4) ´
nulo
=> 2, 3

jq ´ [intervalo (2; 4)] ´
nulo
=> [2,3]

jq ´ [alcance(4)] ´
nulo
=> [0,1,2,3]

jq ´ [intervalo (0; 10; 3)] ´
nulo
=> [0,3,6,9]

jq ´ [intervalo (0; 10; -1)] ´
nulo
=> []

jq ´ [intervalo (0; -5; -1)] ´
nulo
=> [0,-1,-2,-3,-4]

andar
A andar função retorna o piso de sua entrada numérica.

jq ´piso´
3.14159
=> 3

sqrt
A sqrt função retorna a raiz quadrada de sua entrada numérica.

jq ´sqrt´
9
=> 3

enumerar
A enumerar função analisa sua entrada como um número. Ele irá converter formatado corretamente
strings ao seu equivalente numérico, deixe os números como estão e dê um erro em todos os outros
entrada.

jq ´. [] | enumerar
[1, "1"]
=> 1, 1

para sequenciar
A para sequenciar função imprime sua entrada como uma string. Strings são deixadas inalteradas, e todos
outros valores são codificados por JSON.

jq ´. [] | para sequenciar
[1, "1", [1]]
=> "1", "1", "[1]"

tipo
A tipo função retorna o tipo de seu argumento como uma string, que é nula,
booleano, número, string, array ou objeto.

jq ´map (tipo) ´
[0, falso, [], {}, nulo, "olá"]
=> ["número", "booleano", "array", "objeto", "nulo", "string"]

infinito, Não, isinfinito, Isnan, isfinito, é normal
Algumas operações aritméticas podem render infinitos e valores "não um número" (NaN). o
isinfinito retornos embutidos verdadeiro se sua entrada for infinita. o isnan retornos embutidos verdadeiro
se sua entrada for um NaN. o infinito builtin retorna um valor infinito positivo. o nan
builtin retorna um NaN. o é normal builtin retorna verdadeiro se sua entrada for um número normal.

Observe que a divisão por zero gera um erro.

Atualmente, a maioria das operações aritméticas operando em infinitos, NaNs e sub-normais não
levantar erros.

jq ´. [] | (infinito *.) <0´
[-onze]
=> verdadeiro, falso

jq ´infinite, nan | modelo
nulo
=> "número", "número"

ordenar, sort_by (path_expression)
A tipo funções classifica sua entrada, que deve ser uma matriz. Os valores são classificados no
seguinte ordem:

· nulo

· falso

· verdadeiro

· Números

· Strings, em ordem alfabética (por valor de ponto de código Unicode)

· Matrizes, em ordem lexical

· Objetos

A ordem dos objetos é um pouco complexa: primeiro, eles são comparados, comparando seus
conjuntos de chaves (como matrizes em ordem classificada), e se suas chaves forem iguais, os valores são
comparação chave por chave.

tipo pode ser usado para classificar por um determinado campo de um objeto ou pela aplicação de qualquer filtro jq.

sort_by (foo) compara dois elementos comparando o resultado de Foo em cada elemento.

jq ´classificar´
[8,3, nulo, 6]
=> [nulo, 3,6,8]

jq ´sort_by (.foo) ´
[{"foo": 4, "bar": 10}, {"foo": 3, "bar": 100}, {"foo": 2, "bar": 1}]
=> [{"foo": 2, "bar": 1}, {"foo": 3, "bar": 100}, {"foo": 4, "bar": 10}]

group_by (path_expression)
group_by (.foo) toma como entrada um array, agrupa os elementos que possuem o mesmo .foo campo
em matrizes separadas e produz todas essas matrizes como elementos de uma matriz maior,
classificado pelo valor do .foo campo.

Qualquer expressão jq, não apenas um acesso de campo, pode ser usada no lugar de .foo. A classificação
a ordem é a mesma que a descrita no tipo função acima.

jq ´grupo_by (.foo) ´
[{"foo": 1, "bar": 10}, {"foo": 3, "bar": 100}, {"foo": 1, "bar": 1}]
=> [[{"foo": 1, "bar": 10}, {"foo": 1, "bar": 1}], [{"foo": 3, "bar": 100}]]

min max, min_by (path_exp), max_by (path_exp)
Encontre o elemento mínimo ou máximo da matriz de entrada.

A min_by (path_exp) e max_by (path_exp) funções permitem que você especifique um determinado
campo ou propriedade a examinar, por exemplo min_by (.foo) encontra o objeto com o menor Foo
campo.

jq'min'

=> 2

jq ´max_by (.foo) ´
[{"foo": 1, "bar": 14}, {"foo": 2, "bar": 3}]
=> {"foo": 2, "bar": 3}

único, unique_by (path_exp)
A único função recebe como entrada uma matriz e produz uma matriz dos mesmos elementos, em
ordem classificada, com as duplicatas removidas.

A unique_by (path_exp) função irá manter apenas um elemento para cada valor obtido por
aplicando o argumento. Pense nisso como fazer uma matriz retirando um elemento de cada
grupo produzido por grupo.

jq ´único´

=> [1,2,3,5]

jq ´unique_by (.foo) ´
[{"foo": 1, "bar": 2}, {"foo": 1, "bar": 3}, {"foo": 4, "bar": 5}]
=> [{"foo": 1, "bar": 2}, {"foo": 4, "bar": 5}]

jq ´unique_by (comprimento) ´
["em pedaços", "bacon", "gatinho", "cigarra", "aspargos"]
=> ["bacon", "em pedaços", "aspargos"]

reverso
Esta função inverte uma matriz.

jq ´rverso´

=> [4,3,2,1]

contém (elemento)
O filtro contém (b) produzirá verdadeiro se b estiver completamente contido na entrada. UMA
a string B está contida em uma string A se B for uma substring de A. Uma matriz B está contida em
uma matriz A se todos os elementos em B estão contidos em qualquer elemento em A. Um objeto B é
contido no objeto A se todos os valores em B estiverem contidos no valor em A com o
mesma chave. Todos os outros tipos são considerados contidos uns nos outros se forem iguais.

jq ´contains ("bar") ´
"foobar"
=> verdadeiro

jq ´contains (["baz", "bar"]) ´
["foobar", "foobaz", "blarp"]
=> verdadeiro

jq ´contains (["bazzzzz", "bar"]) ´
["foobar", "foobaz", "blarp"]
=> falso

jq ´contains ({foo: 12, bar: [{barp: 12}]}) ´
{"foo": 12, "bar": [1,2, {"barp": 12, "blip": 13}]}
=> verdadeiro

jq ´contains ({foo: 12, bar: [{barp: 15}]}) ´
{"foo": 12, "bar": [1,2, {"barp": 12, "blip": 13}]}
=> falso

índices (s)
Produz uma matriz contendo os índices em . onde s ocorre. A entrada pode ser uma matriz, em
qual caso se s é uma matriz, então a saída dos índices será aquela em que todos os elementos em .
coincidir com os de s.

jq ´indices (",") ´
"a, b, cd, efg, hijk"
=> [3,7,12]

jq´índices(1) ´

=> [1,3,5]

jq ´indices ([1,2]) ´

=> [1,8]

índice (s), rindex (s)
Produz o índice do primeiro (índice) ou por último (Rindex) ocorrência de s na entrada.

jq ´index (",") ´
"a, b, cd, efg, hijk"
=> 3

jq ´rindex (",") ´
"a, b, cd, efg, hijk"
=> 12

dentro
O filtro dentro (b) produzirá verdadeiro se a entrada estiver completamente contida em b. Isto
é, essencialmente, uma versão invertida de contém.

jq ´inside ("foobar") ´
"Barra"
=> verdadeiro

jq ´inside (["foobar", "foobaz", "blarp"]) ´
["baz", "bar"]
=> verdadeiro

jq ´inside (["foobar", "foobaz", "blarp"]) ´
["bazzzzz", "bar"]
=> falso

jq ´inide ({"foo": 12, "bar": [1,2, {"barp": 12, "blip": 13}]}) ´
{"foo": 12, "bar": [{"barp": 12}]}
=> verdadeiro

jq ´inide ({"foo": 12, "bar": [1,2, {"barp": 12, "blip": 13}]}) ´
{"foo": 12, "bar": [{"barp": 15}]}
=> falso

começa com (str)
Saídas verdadeiro E se . começa com o argumento de string fornecido.

jq ´ [. [] | startswith ("foo")] ´
["fo", "foo", "barfoo", "foobar", "barfoob"]
=> [falso, verdadeiro, falso, verdadeiro, falso]

endswith (str)
Saídas verdadeiro E se . termina com o argumento de string fornecido.

jq ´ [. [] | endswith ("foo")] ´
["foobar", "barfoo"]
=> [falso, verdadeiro]

combinações, combinações (n)
Produz todas as combinações dos elementos das matrizes na matriz de entrada. Se for dado um
argumento n, ele produz todas as combinações de n repetições da matriz de entrada.

jq ´combinações´
[[1,2], [3, 4]]
=> [1, 3], [1, 4], [2, 3], [2, 4]

jq´combinações(2) ´
[0, 1]
=> [0, 0], [0, 1], [1, 0], [1, 1]

ltrimstr (str)
Produz sua entrada com a string de prefixo fornecida removida, se começar com ela.

jq ´ [. [] | ltrimstr ("foo")] ´
["fo", "foo", "barfoo", "foobar", "afoo"]
=> ["fo", "", "barfoo", "bar", "afoo"]

rtrimstr (str)
Produz sua entrada com a string de sufixo fornecida removida, se terminar com ela.

jq ´ [. [] | rtrimstr ("foo")] ´
["fo", "foo", "barfoo", "foobar", "foob"]
=> ["fo", "", "bar", "foobar", "foob"]

explodir
Converte uma string de entrada em um array de números de codepoint da string.

jq ´explodir´
"foobar"
=> [102,111,111,98,97,114]

implodir
O inverso de explodir.

jq 'implodir'
[65, 66, 67]
=> "ABC"

divisão
Divide uma string de entrada no argumento separador.

jq ´split (",") ´
"a, b, c, d, e,"
=> ["a", "b, c, d", "e", ""]

junção (str)
Une a matriz de elementos fornecidos como entrada, usando o argumento como separador. É o
inverso de divisão: isto é, correndo dividir ("foo") | juntar ("foo") sobre qualquer string de entrada
retorna a referida string de entrada.

jq ´join (",") ´
["a", "b, c, d", "e"]
=> "a, b, c, d, e"

ascii_downcase, ascii_upcase
Emita uma cópia da string de entrada com seus caracteres alfabéticos (az e AZ) convertidos para
o caso especificado.

enquanto (cond; atualizar)
A enquanto (cond; atualizar) função permite que você aplique repetidamente uma atualização para . até cond
é falso.

Observe que enquanto (cond; atualizar) é definido internamente como uma função jq recursiva. Recursiva
chamadas dentro enquanto não consumirá memória adicional se atualizar produz no máximo um
saída para cada entrada. Veja os tópicos avançados abaixo.

jq ´ [enquanto (. <100;. * 2)] ´
1
=> [1,2,4,8,16,32,64]

até (cond; Próximo)
A até (cond; Próximo) função permite que você aplique repetidamente a expressão Próximo,
inicialmente para . em seguida, para sua própria saída, até cond é verdade. Por exemplo, isso pode ser usado
para implementar uma função fatorial (veja abaixo).

Observe que até (cond; Próximo) é definido internamente como uma função jq recursiva. Recursiva
chamadas dentro até() não consumirá memória adicional se Próximo produz no máximo um
saída para cada entrada. Veja os tópicos avançados abaixo.

jq ´ [., 1] | até (. [0] <1; [. [0] - 1,. [1] *. [0]]) |. [1] ´
4
=> 24

recurse (f), recurso, recurse (f; doença), recurse_down
A recurse (f) função permite que você pesquise uma estrutura recursiva e extraia
dados interessantes de todos os níveis. Suponha que sua entrada represente um sistema de arquivos:

{"nome": "/", "crianças": [
{"nome": "/ bin", "crianças": [
{"nome": "/ bin / ls", "crianças": []},
{"nome": "/ Bin / sh", "crianças": []}]},
{"nome": "/ Home", "crianças": [
{"nome": "/ home / stephen", "crianças": [
{"nome": "/ home / stephen / jq", "crianças": []}]}]}]}

Agora suponha que você deseja extrair todos os nomes de arquivos presentes. Você precisa recuperar . Nome,
.children []. nome, .children []. children []. name, e assim por diante. Você pode fazer isso com:

recurse (.crianças []) | .nome

Quando chamado sem argumento, recurso é equivalente a recurso(.[]?).

recurse (f) é idêntico a recurse (f; . != nulo) e pode ser usado sem preocupações sobre
profundidade de recursão.

recurse (f; doença) é um gerador que começa emitindo. e então emite por sua vez
. | f,. | f | f,. | f | f | f, ... desde que o valor calculado satisfaça a condição. Para
exemplo, para gerar todos os inteiros, pelo menos em princípio, pode-se escrever recurse (. + 1;
verdade).

Por motivos de legado, recurse_down existe como um apelido para chamar recurso sem argumentos.
Este alias é considerado obsoleta e será removido na próxima versão principal.

As chamadas recursivas em recurso não consumirá memória adicional sempre que f produz em
mais uma única saída para cada entrada.

jq ´recurso (.foo []) ´
{"foo": [{"foo": []}, {"foo": [{"foo": []}]}]}
=> {"foo": [{"foo": []}, {"foo": [{"foo": []}]}]}, {"foo": []}, {"foo": [{"foo": []}]}, {"foo": []}

jq 'enfermeira'
{"a": 0, "b": [1]}
=> {"a": 0, "b": [1]}, 0, [1], 1

jq ´recurso (. *.;. <20) ´
2
=> 2, 4, 16

..
Abreviação de recurso sem argumentos. Pretende-se que se assemelhe ao XPath //
operador. Observe que ..e não funciona; usar .. | a em vez de. No exemplo abaixo, usamos
.. | .a? para encontrar todos os valores das chaves de objeto "a" em qualquer objeto encontrado "abaixo" ..

jq ´ .. | .a? ´
[[{"a": 1}]]
=> 1

env
Produz um objeto que representa o ambiente jq.

jq ´env.PAGER´
nulo
=> "menos"

transpor
Transponha uma matriz possivelmente irregular (uma matriz de matrizes). As linhas são preenchidas com nulos para que o
o resultado é sempre retangular.

jq ´transpor´
[[1], [2,3]]
=> [[1,2], [nulo, 3]]

bsearch (x)
bsearch (x) conduz uma busca binária por x na matriz de entrada. Se a entrada for classificada e
contém x, então bsearch (x) retornará seu índice no array; caso contrário, se a matriz for
classificado, ele retornará (-1 - ix) onde ix é um ponto de inserção de forma que a matriz
ainda será classificado após a inserção de x em ix. Se a matriz não for classificada, bsearch (x)
retornará um número inteiro que provavelmente não tem interesse.

jq´pesquisa(0) ´

=> 0

jq´pesquisa(0) ´

=> -1

jq´pesquisa(4) como $ ix | se $ ix <0 então. [- (1 + $ ix)] = 4 else. fim

=> [1,2,3,4]

Tanga interpolação - \ (foo)
Dentro de uma string, você pode colocar uma expressão dentro de parênteses após uma barra invertida. Qualquer que seja
os retornos da expressão serão interpolados na string.

jq ´ "A entrada foi \ (.), que é um a menos que \ (. + 1)" ´
42
=> "A entrada foi 42, que é um a menos que 43"

Converter de / para JSON
A tojson e de json valores embutidos despejam valores como textos JSON ou analisam textos JSON em
valores, respectivamente. O tojson embutido difere de tostring em que tostring retorna
strings não modificadas, enquanto tojson codifica strings como strings JSON.

jq ´ [. [] | tostring] ´
[1, "foo", ["foo"]]
=> ["1", "foo", "[\" foo \ "]"]

jq ´ [. [] | tojson] ´
[1, "foo", ["foo"]]
=> ["1", "\" foo \ "", "[\" foo \ "]"]

jq ´ [. [] | tojson | fromjson] ´
[1, "foo", ["foo"]]
=> [1, "foo", ["foo"]]

Formato cordas e escapando
A @foo a sintaxe é usada para formatar e escapar strings, o que é útil para construir URLs,
documentos em uma linguagem como HTML ou XML e assim por diante. @foo pode ser usado como um filtro em
próprios, os escapes possíveis são:

@texto:

chamadas para sequenciar, consulte essa função para obter detalhes.

@json:

Serializa a entrada como JSON.

@html:

Aplica escape HTML / XML, mapeando os caracteres <> & ´ " para sua entidade
equivalentes <, >, , ', ".

@uri:

Aplica codificação percentual, mapeando todos os caracteres URI reservados para um % XX seqüência.

@csv:

A entrada deve ser uma matriz e é processada como CSV com aspas duplas para
strings e aspas escapadas por repetição.

@tsv:

A entrada deve ser uma matriz e é processada como TSV (valores separados por tabulação). Cada
a matriz de entrada será impressa como uma única linha. Os campos são separados por uma única guia
(ascii 0x09) Alimentação de linha de caracteres de entrada (ascii 0x0a), retorno de carro (ascii
0x0d), guia (ascii 0x09) e barra invertida (ascii 0x5c) será gerado como escape
sequências \n, \r, \t, \\ respectivamente.

@sh:

A entrada tem escape adequado para uso em uma linha de comando para um shell POSIX. Se o
input é um array, a saída será uma série de strings separadas por espaço.

@ base64:

A entrada é convertida em base64 conforme especificado pela RFC 4648.

Esta sintaxe pode ser combinada com a interpolação de strings de uma forma útil. Você pode seguir um
@foo token com um literal de string. O conteúdo do literal de string irá não ser escapado.
No entanto, todas as interpolações feitas dentro desse literal de string terão escape. Por exemplo,

@uri "https://www.google.com/search?q=\(.search)"

irá produzir a seguinte saída para a entrada {"pesquisar": "o que is jq? "}:

"https://www.google.com/search?q=what%20is%20jq%3F"

Observe que as barras, o ponto de interrogação etc. no URL não têm escape, pois faziam parte
do literal de string.

jq ´ @ html´
"Isso funciona se x <y"
=> "Isso funciona se x <y"

jq ´ @ sh "echo \ (.)" ´
"O´Hara´s Ale"
=> "echo ´O´ \\ ´´Hara´ \\ ´´s Ale´"

Datas
jq fornece algumas funcionalidades básicas de manipulação de dados, com alguns de alto e baixo nível
builtins. Em todos os casos, esses builtins lidam exclusivamente com a hora em UTC.

A dedataiso8601 integrado analisa datetimes no formato ISO 8601 para um número de segundos
desde a época do Unix (1970-01-01T00: 00: 00Z). o todaiso8601 builtin faz o inverso.

A da data builtin analisa strings de data e hora. Atualmente da data suporta apenas ISO 8601
strings datetime, mas no futuro tentará analisar strings datetime em mais
formatos.

A Até a presente data builtin é um apelido para todaiso8601.

A agora integrado emite a hora atual, em segundos, desde a época do Unix.

Interfaces jq de baixo nível para as funções de tempo da biblioteca C também são fornecidas: tempo de strp,
horário de trabalho, mktime e horário gm. Consulte a documentação do sistema operacional do seu host para o
strings de formato usadas por tempo de strp e horário de trabalho. Nota: estes não são necessariamente estáveis
interfaces em jq, particularmente quanto à sua funcionalidade de localização.

A horário gm builtin consome alguns segundos desde a época do Unix e produz uma "falha
down time "representação do tempo como uma matriz de números que representam (nesta ordem): o
ano, o mês (base zero), o dia do mês, a hora do dia, o minuto do
hora, o segundo do minuto, o dia da semana e o dia do ano - todos
baseado em um, a menos que indicado de outra forma.

A mktime embutido consome representações de "tempo interrompido" da produção de tempo por horário gm
e tempo de strp.

A strptime (fmt) integrado analisa as strings de entrada que correspondem ao fmt argumento. A saída está em
a representação de "tempo de interrupção" consumido por horário gm e saída por mktime.

A strftime (fmt) formata incorporada uma hora com o formato fornecido.

As strings de formato para tempo de strp e horário de trabalho são descritos na biblioteca C típica
documentação. A string de formato para data e hora ISO 8601 é "% Y-% m-% dT% H:% M:% SZ".

jq pode não suportar algumas ou todas as funcionalidades de data em alguns sistemas.

jq ´a partir da data´
"2015-03-05T23:51:47Z"
=> 1425599507

jq ´strptime ("% Y-% m-% dT% H:% M:% SZ") ´
"2015-03-05T23:51:47Z"
=> [2015,2,5,23,51,47,4,63]

jq ´strptime ("% Y-% m-% dT% H:% M:% SZ") | mktime´
"2015-03-05T23:51:47Z"
=> 1425599507

CONDICIONAIS E COMPARAÇÕES

==, !=
A expressão ´a == b´ produzirá ´verdadeiro´ se os resultados de aeb forem iguais (ou seja,
se eles representam documentos JSON equivalentes) e ´false´ caso contrário. Em particular, strings
nunca são considerados iguais a números. Se você está vindo de Javascript, jq´s == é como
Javascript's === - considerando valores iguais apenas quando eles têm o mesmo tipo, bem como
o mesmo valor.

! = é "diferente", e ´a! = b´ retorna o valor oposto de ´a == b´

jq ´. [] == 1´
[1, 1.0, "1", "banana"]
=> verdadeiro, verdadeiro, falso, falso

se-então-senão
if A então B outro C final vai agir da mesma forma que B if A produz um valor diferente de falso ou
nulo, mas age da mesma forma que C de outra forma.

Verificar se há falso ou nulo é uma noção mais simples de "veracidade" do que a encontrada em Javascript
ou Python, mas significa que às vezes você terá que ser mais explícito sobre a condição
que você quer: você não pode testar se, por exemplo, uma string está vazia usando if . Nome então A outro B final,
você vai precisar de algo mais parecido com if (.nome | comprimento) > 0 então A outro B final ao invés.

Se a condição A produzir vários resultados, ela será considerada "verdadeira" se qualquer um desses
os resultados não são falsos ou nulos. Se produzir resultado zero, é considerado falso.

Mais casos podem ser adicionados a um se estiver usando elif A então B sintaxe.

jq ´if. == 0 então

elif "zero". == 1 então "um" senão "muitos" fim´ 2 => "muitos"

>, > =, <=, <
Os operadores de comparação >, >=, <=, < retornar se o argumento à esquerda é maior que,
maior ou igual a, menor ou igual a ou menor que seu argumento correto
(respectivamente).

A ordem é a mesma que a descrita para tipo, acima.

jq ´. <5´
2
=> verdadeiro

e / ou / não
jq suporta os operadores booleanos normais e / ou / não. Eles têm o mesmo padrão de verdade
como se as expressões - falso e nulo fossem consideradas "valores falsos" e qualquer outra coisa fosse um
"valor real".

Se um operando de um desses operadores produz vários resultados, o próprio operador
irá produzir um resultado para cada entrada.

não é na verdade uma função embutida em vez de um operador, por isso é chamado como um filtro para
quais coisas podem ser canalizadas em vez de com sintaxe especial, como em .foo e .Barra | não.

Esses três produzem apenas os valores "verdadeiro" e "falso" e, portanto, só são úteis para genuínos
Operações booleanas, em vez do idioma Perl / Python / Ruby comum de
"value_that_may_be_null ou default". Se você quiser usar essa forma de "ou", escolha entre
dois valores em vez de avaliar uma condição, consulte o operador "//" abaixo.

jq ´42 e "uma string" ´
nulo
=> verdadeiro

jq ´ (verdadeiro, falso) ou falso´
nulo
=> verdadeiro, falso

jq ´ (verdadeiro, verdadeiro) e (verdadeiro, falso) ´
nulo
=> verdadeiro, falso, verdadeiro, falso

jq ´ [verdadeiro, falso | não
nulo
=> [falso, verdadeiro]

Alternative operador - //
Um filtro do formulário a // b produz os mesmos resultados que a, Se a produz resultados outros
do que falso e nulo. De outra forma, a // b produz os mesmos resultados que b.

Isso é útil para fornecer padrões: .foo // 1 irá avaliar para 1 se não houver .foo
elemento na entrada. É parecido com como or às vezes é usado em Python (jq´s or operador
está reservado para operações estritamente booleanas).

jq ´.foo // 42´
{"foo": 19}
=> 19

jq ´.foo // 42´
{}
=> 42

tentar pegar
Erros podem ser detectados usando tentar EXP captura EXP. A primeira expressão é executada, e se
ele falha e o segundo é executado com a mensagem de erro. A saída do manipulador, se
any, é a saída como se fosse a saída da expressão a ser tentada.

A tentar EXP forma usa vazio como o manipulador de exceção.

jq ´try .a catch ". não é um objeto" ´
verdadeiro
=> ". não é um objeto"

jq ´ [. [] | tente .a] ´
[{}, verdadeiro, {"a": 1}]
=> [nulo, 1]

jq ´try error ("alguma exceção") catch .´
verdadeiro
=> "alguma exceção"

Quebra Fora of ao controle estruturas
Um uso conveniente de try / catch é quebrar estruturas de controle como reduzir, foreach,
enquanto, E assim por diante.

Por exemplo:

# Repita uma expressão até levantar "quebra" como um
# erro, então pare de repetir sem relançar o erro.
# Mas se o erro detectado não for "quebrar", aumente-o novamente.
try repeat (exp) catch. == "break" then empty else error;

jq tem uma sintaxe para rótulos lexicais nomeados para "quebrar" ou "ir (voltar) para":

etiqueta $ out | ... liberar $ ...

A quebrar $ label_name expressão fará com que o programa aja como se o mais próximo
(Para a esquerda) rótulo $ label_name produzido vazio.

A relação entre o quebrar e correspondente rótulo é léxico: o rótulo tem que ser
"visível" do intervalo.

Para sair de um reduzir, Por exemplo:

etiqueta $ out | reduza. [] como $ item (nulo; if. == false then break $ out else ... end)

O seguinte programa jq produz um erro de sintaxe:

quebrar $ fora

porque nenhum rótulo $ out é visível.

? operador
A ? operador, usado como EXP?, é uma abreviatura para tentar EXP.

jq ´ [. [] | (.a)?] ´
[{}, verdadeiro, {"a": 1}]
=> [nulo, 1]

REGULAR EXPRESSÕES (PCR)

jq usa a biblioteca de expressão regular Oniguruma, assim como php, ruby, TextMate, Sublime Text,
etc, portanto, a descrição aqui se concentrará nos detalhes de jq.

Os filtros jq regex são definidos para que possam ser usados ​​usando um destes padrões:

STRING | FILTRO (REGEX)
STRING | FILTRO (REGEX; BANDEIRAS)
STRING | FILTRO ([REGEX])
STRING | FILTRO ([REGEX, FLAGS])

onde: * STRING, REGEX e FLAGS são strings jq e estão sujeitos à interpolação de strings jq; *
REGEX, após a interpolação da string, deve ser uma regex PCRE válida; * FILTER é um dos teste,
partidaou capturar, como descrito abaixo.

FLAGS é uma string que consiste em um ou mais dos sinalizadores suportados:

· g - Pesquisa global (encontre todas as correspondências, não apenas a primeira)

· i - Pesquisa que não diferencia maiúsculas de minúsculas

· m - Modo multilinha (´.´ corresponderá a novas linhas)

· n - Ignorar partidas vazias

· p - Os modos s e m estão ativados

· s - Modo linha única (´ ^ ´ -> ´ \ A´, ´ $ ´ -> ´ \ Z´)

· l - Encontre as correspondências mais longas possíveis

· x - Formato regex estendido (ignorar espaços em branco e comentários)

Para coincidir com os espaços em branco em um padrão x, use um escape como \ s, por exemplo

· Teste ("a \ sb", "x").

Observe que certos sinalizadores também podem ser especificados no REGEX, por exemplo

· Jq -n ´ ("teste", "TEst", "teST", "TEST") | teste ("(? i) te (? - i) st") ´

avalia como: verdadeiro, verdadeiro, falso, falso.

[Requer 1.5] teste (val), teste (regex; bandeiras)
Como partida, mas não retorna objetos correspondentes, apenas verdadeiro or falso para se ou não o
regex corresponde à entrada.

jq ´test ("foo") ´
"foo"
=> verdadeiro

jq ´. [] | teste ("abc # espaços são ignorados"; "ix") ´
["xabcd", "ABC"]
=> verdadeiro, verdadeiro

[Requer 1.5] combinar (val), match (regex; bandeiras)
partida gera um objeto para cada correspondência que encontra. As correspondências têm os seguintes campos:

· compensar - deslocamento em pontos de código UTF-8 desde o início da entrada

· comprimento - comprimento em pontos de código UTF-8 da partida

· corda - a string que combinou

· capturas - uma série de objetos que representam grupos de captura.

A captura de objetos de grupo possui os seguintes campos:

· compensar - deslocamento em pontos de código UTF-8 desde o início da entrada

· comprimento - comprimento em pontos de código UTF-8 deste grupo de captura

· corda - a corda que foi capturada

· nome - o nome do grupo de captura (ou nulo se não tivesse nome)

A captura de grupos que não correspondem a nada retorna um deslocamento de -1

jq ´match ("(abc) +"; "g") ´
"abc abc"
=> {"offset": 0, "length": 3, "string": "abc", "captura": [{"offset": 0, "length": 3, "string": "abc", " name ": null}]}, {" offset ": 4," length ": 3," string ":" abc "," captura ": [{" offset ": 4," length ": 3," string " : "abc", "nome": null}]}

jq ´match ("foo") ´
"foo bar foo"
=> {"deslocamento": 0, "comprimento": 3, "string": "foo", "captura": []}

jq ´match (["foo", "ig"]) ´
"foo bar FOO"
=> {"offset": 0, "length": 3, "string": "foo", "captura": []}, {"offset": 8, "length": 3, "string": "FOO "," captura ": []}

jq ´match ("foo (? bar)? foo ";" ig ") ´
"foo bar foo foo foo"
=> {"offset": 0, "length": 11, "string": "foo bar foo", "captura": [{"offset": 4, "length": 3, "string": "bar" , "name": "bar123"}]}, {"offset": 12, "length": 8, "string": "foo foo", "captura": [{"offset": -1, "length" : 0, "string": null, "name": "bar123"}]}

jq ´ [match ("."; "g")] | comprimento
"abc"
=> 3

[Requer 1.5] captura (val), captura (regex; bandeiras)
Coleta as capturas nomeadas em um objeto JSON, com o nome de cada captura como a chave,
e a string correspondente como o valor correspondente.

jq ´capture ("(? [az] +) - (? [0-9] +) ") ´
"xyzzy-14"
=> {"a": "xyzzy", "n": "14"}

[Requer 1.5] scan (regex), scan (regex; bandeiras)
Emita um fluxo das substrings não sobrepostas da entrada que correspondem à regex em
de acordo com os sinalizadores, se algum tiver sido especificado. Se não houver correspondência, o fluxo é
vazio. Para capturar todas as correspondências para cada string de entrada, use o idioma [ expr ], por exemplo [
scan (regex) ].

dividir (regex; bandeiras)
Para compatibilidade com versões anteriores, divisão divide-se em uma string, não em um regex.

[Requer 1.5] divisões (regex), divisões (regex; bandeiras)
Eles fornecem os mesmos resultados que seus divisão homólogos, mas como um riacho em vez de um
matriz.

[Requer 1.5] sub (regex; para sequenciar) sub (regex; corda bandeiras)
Emita a string obtida substituindo a primeira correspondência de regex na string de entrada com
para sequenciar, após a interpolação. para sequenciar deve ser uma string jq e pode conter referências
para capturas nomeadas. As capturas nomeadas são, com efeito, apresentadas como um objeto JSON (como
construído por capturar) A para sequenciar, então uma referência a uma variável capturada chamada "x" seria
assumir a forma: "(.x)".

[Requer 1.5] gsub (regex; fragmento), gsub (regex; corda bandeiras)
gsub é como abaixo mas todas as ocorrências não sobrepostas da regex são substituídas pelo
string, após a interpolação.

ADVANCED CARATERÍSTICAS

Variáveis ​​são uma necessidade absoluta na maioria das linguagens de programação, mas são relegadas
para um "recurso avançado" no jq.

Na maioria das linguagens, as variáveis ​​são o único meio de transmissão de dados. Se você calcular um
valor, e você deseja usá-lo mais de uma vez, você precisará armazená-lo em uma variável. Para
passar um valor para outra parte do programa, você precisará dessa parte do programa para
definir uma variável (como um parâmetro de função, membro de objeto ou qualquer outro) na qual colocar
os dados.

Também é possível definir funções em jq, embora esta seja uma característica cujo maior
uso é definir a biblioteca padrão jq (muitas funções jq, como mapa, e find são de fato
escrito em jq).

jq tem operadores de redução, que são muito poderosos, mas um pouco complicados. Novamente, estes são
usado principalmente internamente, para definir alguns bits úteis da biblioteca padrão do jq.

Pode não ser óbvio no início, mas jq é tudo sobre geradores (sim, como frequentemente encontrado em
outras línguas). Alguns utilitários são fornecidos para ajudar a lidar com geradores.

Algum suporte mínimo de I / O (além de ler JSON da entrada padrão e escrever JSON para
saída padrão) está disponível.

Finalmente, existe um sistema de módulo / biblioteca.

Variáveis
No jq, todos os filtros têm uma entrada e uma saída, portanto, o encanamento manual não é necessário para
passe um valor de uma parte de um programa para a próxima. Muitas expressões, por exemplo a + b,
passar sua entrada para duas subexpressões distintas (aqui a e b ambos são passados ​​do mesmo
entrada), então as variáveis ​​geralmente não são necessárias para usar um valor duas vezes.

Por exemplo, calcular o valor médio de uma matriz de números requer alguns
variáveis ​​na maioria das linguagens - pelo menos uma para conter a matriz, talvez uma para cada elemento
ou para um contador de loop. Em jq, é simplesmente adicionar / comprimento - a adicionar expressão é dada a
array e produz sua soma, e o comprimento expressão recebe a matriz e produz seu
comprimento.

Portanto, geralmente há uma maneira mais limpa de resolver a maioria dos problemas em jq do que definir variáveis.
Ainda assim, às vezes eles tornam as coisas mais fáceis, então jq permite que você defina variáveis ​​usando
expressão as $ variável. Todos os nomes de variáveis ​​começam com $. Aqui está uma versão um pouco mais feia
do exemplo de média da matriz:

comprimento como $ array_length | add / $ array_length

Precisaremos de um problema mais complicado para encontrar uma situação em que o uso de variáveis ​​realmente
torna nossas vidas mais fáceis.

Suponha que temos uma matriz de postagens de blog, com os campos "autor" e "título", e outro
objeto que é usado para mapear nomes de usuário do autor para nomes reais. Nossa entrada se parece com:

{"posts": [{"title": "Frist psot", "author": "anon"},
{"title": "Um artigo bem escrito", "author": "person1"}],
"realnames": {"anon": "Covarde Anônimo",
"person1": "Person McPherson"}}

Queremos produzir as postagens com o campo autor contendo um nome real, como em:

{"título": "Primeiro psot", "autor": "Covarde anônimo"}
{"title": "Um artigo bem escrito", "autor": "Person McPherson"}

Usamos uma variável, $ names, para armazenar o objeto realnames, para que possamos nos referir a ele mais tarde
ao procurar nomes de usuário de autor:

.realnames as $ names | .posts [] | {título, autor: $ names [.author]}

A expressão exp as $x | ... significa: para cada valor de expressão exp, execute o resto de
o pipeline com toda a entrada original e com $x definido para esse valor. Por isso as
funciona como uma espécie de loop foreach.

Assim como {foo} é uma maneira prática de escrever {foo: .foo}, assim {$ foo} é uma maneira prática de escrever
{foo: $ foo}.

Múltiplas variáveis ​​podem ser declaradas usando um único as expressão fornecendo um padrão
que corresponde à estrutura da entrada (isso é conhecido como "desestruturação"):

. como {realnames: $ names, posts: [$ first, $ second]} | ...

As declarações de variáveis ​​em padrões de matriz (por exemplo, . as [$ primeiro, $ segundo]) ligar-se ao
os elementos da matriz partem do elemento no índice zero para cima, em ordem. Quando não há
valor no índice de um elemento de padrão de matriz, nulo está ligado a essa variável.

As variáveis ​​têm como escopo o resto da expressão que as define, então

.realnames as $ names | (.posts [] | {título, autor: $ names [.author]})

vai funcionar, mas

(.realnames como $ names | .posts []) | {título, autor: $ names [.author]}

não vai.

Para os teóricos da linguagem de programação, é mais correto dizer que as variáveis ​​jq são
vinculações com escopo léxico. Em particular, não há como alterar o valor de uma ligação;
só se pode configurar uma nova ligação com o mesmo nome, mas que não será visível onde
o antigo era.

jq ´.bar como $ x | .foo | . + $ x´
{"foo": 10, "bar": 200}
=> 210

jq ´. como $ i | [(. * 2 |. como $ i | $ i), $ i] ´
5
=> [10,5]

jq ´. como [$ a, $ b, {c: $ c}] | $ a + $ b + $ c´
[2, 3, {"c": 4, "d": 5}]
=> 9

jq ´. [] as [$ a, $ b] | {a: $ a, b: $ b} ´
[[0], [0, 1], [2, 1, 0]]
=> {"a": 0, "b": nulo}, {"a": 0, "b": 1}, {"a": 2, "b": 1}

Definindo Funções
Você pode dar um nome a um filtro usando a sintaxe "def":

incremento de def:. + 1;

A partir daí, incremento pode ser usado como um filtro, assim como uma função embutida (na verdade, este
é como alguns dos builtins são definidos). Uma função pode receber argumentos:

def map (f): [. [] | f];

Os argumentos são passados ​​como filtros, não como valores. O mesmo argumento pode ser referenciado
várias vezes com entradas diferentes (aqui f é executado para cada elemento da matriz de entrada).
Os argumentos para uma função funcionam mais como retornos de chamada do que como argumentos de valor. Isto é
importante entender. Considerar:

def foo (f): f | f;
5 | foo (. * 2)

O resultado será 20 porque f is . * 2, e durante a primeira invocação de f . será 5,
e na segunda vez será 10 (5 * 2), então o resultado será 20. Argumentos da função
são filtros, e os filtros esperam uma entrada quando chamados.

Se você quiser o comportamento do argumento de valor para definir funções simples, você pode apenas usar um
variável:

def addvalue (f): f as $ f | mapa (. + $ f);

Ou use a abreviação:

def addvalue ($ f): ...;

Com qualquer definição, addvalue (.foo) irá adicionar as entradas atuais .foo campo para cada
elemento da matriz.

São permitidas várias definições usando o mesmo nome de função. Cada redefinição substitui
o anterior para o mesmo número de argumentos de função, mas apenas para referências de
funções (ou programa principal) subsequente à redefinição.

jq ´def addvalue (f):. + [f]; map (addvalue (. [0])) ´
[[1,2], [10,20]]
=> [[1,2,1], [10,20,10]]

jq ´def addvalue (f): f as $ x | mapa (. + $ x); addvalue (. [0]) ´
[[1,2], [10,20]]
=> [[1,2,1,2], [10,20,1,2]]

Reduzir
A reduzir sintaxe em jq permite combinar todos os resultados de uma expressão por
acumulando-os em uma única resposta. Por exemplo, vamos passar a esta
expressão:

reduzir. [] como $ item (0;. + $ item)

Para cada resultado que . [] produz, . + $ item é executado para acumular um total em execução,
começando de 0. Neste exemplo, . [] produz os resultados 3, 2 e 1, então o efeito é
semelhante a executar algo assim:

0 | (3 como $ item |. + $ Item) |
(2 como $ item |. + $ Item) |
(1 como $ item |. + $ Item)

jq ´reduzir. [] como $ item (0;. + $ item) ´

=> 20

limite (n; exp)
A limitar a função extrai até n saídas de exp.

jq ´ [limit (3;. [])] ´

=> [0,1,2]

primeiro (expr), último (expr), enésimo (n; exp)
A primeiro (expr) e último (expr) funções extraem o primeiro e o último valor de expr,
respectivamente.

A enésimo (n; exp) função extrai o enésimo valor de saída por expr. Isso pode ser definido como
def enésimo (n; exp): último (limite (n + 1; expr));. Observe que enésimo (n; exp) não suporta
valores negativos de n.

jq ´ [primeiro (intervalo (.)), último (intervalo (.)), enésimo (./ 2; intervalo (.))] ´
10
=> [0,9,5]

primeiro, último, enésimo (n)
A primeiro e último funções extraem o primeiro e o último valor de qualquer array em ..

A enésimo (n) função extrai o enésimo valor de qualquer array em ..

jq ´ [intervalo (.)] | [primeiro, último, enésimo(5)] ´
10
=> [0,9,5]

foreach
A foreach sintaxe é semelhante a reduzir, mas pretendia permitir a construção de limitar
e redutores que produzem resultados intermediários (ver exemplo).

O formulário é foreach EXP as $ var (INICIAR; ATUALIZAR; EXTRAIR). Como reduzir, INIT é avaliado
uma vez para produzir um valor de estado, então cada saída de EXP é obrigado a $ var, ATUALIZAÇÃO is
avaliado para cada saída de EXP com o estado atual e com $ var visível. Cada valor
saída por ATUALIZAÇÃO substitui o estado anterior. Finalmente, EXTRAIR é avaliado para cada novo
estado para extrair uma saída de foreach.

Isso é principalmente útil apenas para construir reduzir e limitarfunções semelhantes. Mas isso é
muito mais geral, pois permite reduções parciais (veja o exemplo abaixo).

jq ´ [foreach. [] as $ item ([[], []]; if $ item == null then [[],. [0]] else [(. [0] + [$ item]), [ ]] fim; se $ item == nulo então. [1] senão fim vazio)] ´
[1,2,3,4, nulo, "a", "b", nulo]
=> [[1,2,3,4], ["a", "b"]]

Recursão
Como descrito acima, recurso usa recursão e qualquer função jq pode ser recursiva. O
enquanto builtin também é implementado em termos de recursão.

As chamadas finais são otimizadas sempre que a expressão à esquerda das saídas da chamada recursiva
seu último valor. Na prática, isso significa que a expressão à esquerda do recursivo
chamada não deve produzir mais de uma saída para cada entrada.

Por exemplo:

def recurse (f): def r:., (f | select (.! = null) | r); r;

def while (cond; atualização):
def _enquanto:
if cond then., (update | _while) else empty end;
_enquanto;

def repetir (exp):
def _repetir:
exp, _repetir;
_repita;

geradores e iteradores
Alguns operadores e funções jq são, na verdade, geradores, pois podem produzir zero,
um ou mais valores para cada entrada, assim como se poderia esperar em outra programação
linguagens que possuem geradores. Por exemplo, . [] gera todos os valores em sua entrada
(que deve ser uma matriz ou um objeto), intervalo (0; 10) gera os inteiros entre 0 e
10 e assim por diante.

Até mesmo o operador vírgula é um gerador, gerando primeiro os valores gerados pelo
expressão à esquerda da vírgula, então, para cada uma delas, os valores gerados pelo
expressão à direita da vírgula.

A vazio builtin é o gerador que produz saídas zero. O vazio builtin
retrocede para a expressão geradora anterior.

Todas as funções jq podem ser geradores apenas usando geradores embutidos. Também é possível
para definir novos geradores usando apenas recursão e o operador vírgula. Se o recursivo
call (s) is (are) "in tail position" (posição final), então o gerador será eficiente. No exemplo
abaixo da chamada recursiva por _alcance para si mesmo está na posição da cauda. O exemplo mostra
três tópicos avançados: recursão de cauda, ​​construção de gerador e subfunções.

jq ´def range (init; upto; by): def _range: if (by> 0 e. <upto) ou (by <0 e.> upto) then., ((. + by) | _range) else. fim; if by == 0 then init else init | _range end | selecione ((por> 0 e. <até) ou (por <0 e.> até)); intervalo (0; 10; 3) ´
nulo
=> 0, 3, 6, 9

jq ´def while (cond; atualizar): def _while: se cond então., (atualizar | _while) senão fim vazio; _enquanto; [enquanto (. <100;. * 2)] ´
1
=> [1,2,4,8,16,32,64]

MATEMÁTICA

jq atualmente só tem suporte para número de ponto flutuante de precisão dupla IEEE754 (64 bits).

Além de operadores aritméticos simples, como +, jq também tem a maioria das funções matemáticas padrão
da biblioteca de matemática C. Funções matemáticas C que levam um único argumento de entrada (por exemplo, sem ())
estão disponíveis como funções jq de argumento zero. Funções matemáticas C que levam duas entradas
argumentos (por exemplo, prisioneiro de guerra()) estão disponíveis como funções jq de dois argumentos que ignoram ..

A disponibilidade de funções matemáticas padrão depende da disponibilidade dos correspondentes
funções matemáticas em seu sistema operacional e biblioteca de matemática C. Funções matemáticas indisponíveis
será definido, mas gerará um erro.

I / O

Neste momento jq tem suporte mínimo para I / O, principalmente na forma de controle sobre quando
entradas são lidas. Duas funções integradas são fornecidas para isso, entrada e inputs, que leu
das mesmas fontes (por exemplo, stdin, arquivos nomeados na linha de comando) como o próprio jq. Esses
dois builtins e as próprias ações de leitura de jq podem ser intercalados entre si.

Um integrado fornece recursos de saída mínimos, depurar. (Lembre-se de que um programa jq é
os valores de saída são sempre produzidos como textos JSON em stdout.) O depurar embutido pode ter
comportamento específico do aplicativo, como para executáveis ​​que usam a API libjq C, mas não
o próprio executável jq.

entrada
Produz uma nova entrada.

inputs
Produz todas as entradas restantes, uma por uma.

Isso é útil principalmente para reduções sobre as entradas de um programa.

depurar
Faz com que uma mensagem de depuração seja produzida com base no valor de entrada. O executável jq envolve
o valor de entrada com ["DEPURAR:", ] e imprime isso e uma nova linha em stderr,
compactamente. Isso pode mudar no futuro.

nome_do_arquivo de entrada
Retorna o nome do arquivo cuja entrada está sendo filtrada no momento. Observe que isso vai
não funciona bem a menos que jq esteja sendo executado em um local UTF-8.

número_linha_de_entrada
Retorna o número da linha da entrada que está sendo filtrada no momento.

STREAMING

Com o --Stream opção jq pode analisar textos de entrada em um modo de streaming, permitindo jq
programas para começar a processar grandes textos JSON imediatamente, em vez de após a análise
completa. Se você tiver um único texto JSON com 1 GB de tamanho, o streaming permitirá que você
para processá-lo muito mais rapidamente.

No entanto, o streaming não é fácil de lidar, pois o programa jq terá [ ,
] (e algumas outras formas) como entradas.

Diversos recursos integrados são fornecidos para facilitar o manuseio dos fluxos.

Os exemplos abaixo usam a forma de fluxo de [0, [1]], o que é
[[0],0],[[1,0],1],[[1,0]],[[1]].

Os formulários de streaming incluem [ , ] (para indicar qualquer valor escalar, array vazio,
ou objeto vazio), e [ ] (para indicar o fim de uma matriz ou objeto). Futuro
versões de jq executadas com --Stream e -seq pode gerar formulários adicionais, como ["erro
mensagem"] quando um texto de entrada falha ao analisar.

truncate_stream (stream_expression)
Consome um número como entrada e trunca o número correspondente de elementos de caminho de
à esquerda das saídas da expressão de streaming fornecida.

jq ´[1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]])]´
1
=> [[[0], 2], [[0]]]

fromstream (stream_expression)
Valores de saída correspondentes às saídas da expressão de fluxo.

jq ´fromstream(1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]]))´
nulo
=> [2]

para transmitir
A para transmitir embutido emite a forma de fluxo de sua entrada.

jq ´. como $ dot | fromstream ($ dot | tostream) |. == $ dot´
[0, [1, {"a": 1}, {"b": 2}]]
=> verdadeiro

TAREFA

A atribuição funciona de maneira um pouco diferente em jq do que na maioria das linguagens de programação. jq não
distinguir entre referências e cópias de algo - dois objetos ou matrizes são
igual ou diferente, sem qualquer noção adicional de ser "o mesmo objeto" ou "não
o mesmo objeto ".

Se um objeto tem dois campos que são matrizes, .foo e .Barra, e você acrescenta algo a
.foo, Em seguida .Barra não vai ficar maior. Mesmo se você acabou de definir .Barra = .foo. Se você está acostumado
a programação em linguagens como Python, Java, Ruby, Javascript, etc., então você pode pensar
dele como se jq fizesse uma cópia profunda completa de cada objeto antes de fazer a atribuição
(para performance, na verdade não faz isso, mas essa é a ideia geral).

Todos os operadores de atribuição em jq têm expressões de caminho no lado esquerdo.

=
O filtro .foo = 1 tomará como entrada um objeto e produzirá como saída um objeto com o
campo "foo" definido como 1. Não há noção de "modificar" ou "mudar" algo em jq -
todos os valores jq são imutáveis. Por exemplo,

.foo = .bar | .foo.baz = 1

não terá o efeito colateral de definir .bar.baz para ser definido como 1, já que o
programa em Javascript, Python, Ruby ou outras linguagens. Ao contrário dessas línguas (mas
como Haskell e algumas outras linguagens funcionais), não há noção de duas matrizes ou
objetos sendo "o mesmo array" ou "o mesmo objeto". Eles podem ser iguais ou diferentes, mas
se mudarmos um deles, em nenhuma circunstância o outro mudará pelas nossas costas.

Isso significa que é impossível construir valores circulares em jq (como uma matriz cujo
primeiro elemento é ele mesmo). Isso é bastante intencional e garante que qualquer coisa um jq
programa pode produzir pode ser representado em JSON.

Observe que o lado esquerdo de ´ = ´ se refere a um valor em .. portanto $ var.foo = 1 não vai funcionar
como esperado ($ var.foo não é uma expressão de caminho válida ou útil em .); usar $ var | .foo = 1
ao invés.

Se o lado direito de ´ = ´ produz vários valores, então para cada um desses valores jq irá
defina os caminhos no lado esquerdo para o valor e então ele irá imprimir o ..
Por exemplo, nos (.a, .b) =alcance(2) outputs {"a": 0, "b": 0}, Em seguida {"a": 1, "b": 1}. A atualização"
formulários de atribuição (veja abaixo) não fazem isso.

Note também que .a, .b = 0 não define .a e .b, mas (.a, .b) = 0 define ambos.

|=
Bem como o operador de atribuição ´ = ´, jq fornece o operador "atualizar" ´ | = ´, que
pega um filtro do lado direito e calcula o novo valor para a propriedade de .
sendo atribuído executando o valor antigo por meio desta expressão. Por exemplo, .foo | =
. + 1 irá construir um objeto com o campo "foo" definido como "foo" mais 1 da entrada.

Este exemplo deve mostrar a diferença entre ´ = ´ e ´ | = ´:

Forneça entrada ´ {"a": {"b": 10}, "b": 20} ´ para os programas:

.a = .b .a | = .b

O primeiro definirá o campo "a" da entrada para o campo "b" da entrada, e produzirá
a saída {"a": 20}. Este último irá definir o campo "a" da entrada para o campo "a"
campo "b", produzindo {"a": 10}.

O lado esquerdo pode ser qualquer expressão de caminho geral; Vejo caminho().

Observe que o lado esquerdo de ´ | = ´ se refere a um valor em .. portanto $ var.foo |= . + 1 não vai
trabalhe como esperado ($ var.foo não é uma expressão de caminho válida ou útil em .); usar $ var | .foo
|= . + 1 ao invés.

Se o lado direito produzir vários valores, apenas o último será usado.

jq ´ (.. | select (type == "boolean")) | = if. então 1 mais 0 fim´
[verdadeiro, falso, [5, verdadeiro, [verdadeiro, [falso]], falso]]
=> [1,0,[5,1,[1,[0]],0]]

+ =, - =, * =, / =, % =, // =
jq tem alguns operadores do formulário a op = b, que são todos equivalentes a a |= . op b. Assim,
+= 1 pode ser usado para incrementar valores.

jq ´.foo + = 1´
{"foo": 42}
=> {"foo": 43}

Complexo atribuições
Muito mais coisas são permitidas no lado esquerdo de uma atribuição jq do que na maioria
línguas. Já vimos acessos de campo simples do lado esquerdo, e não
surpresa que os acessos de array funcionam tão bem:

.posts [0] .title = "Manual JQ"

O que pode ser uma surpresa é que a expressão à esquerda pode produzir vários
resultados, referindo-se a diferentes pontos no documento de entrada:

.posts []. comentários | =. + ["isso é ótimo"]

Esse exemplo anexa a string "isso é ótimo" ao array "comentários" de cada postagem em
a entrada (onde a entrada é um objeto com um campo "postagens" que é uma matriz de postagens).

Quando jq encontra uma atribuição como ´a = b´, ele registra o "caminho" usado para selecionar um
parte do documento de entrada durante a execução de a. Este caminho é então usado para encontrar qual parte do
a entrada a ser alterada durante a execução da atribuição. Qualquer filtro pode ser usado no
lado esquerdo de um igual - qualquer caminho que ele selecionar a partir da entrada estará onde o
atribuição é realizada.

Esta é uma operação muito poderosa. Suponha que queremos adicionar um comentário às postagens do blog, usando
a mesma entrada de "blog" acima. Desta vez, queremos apenas comentar as postagens escritas por
"stedolan". Podemos encontrar essas postagens usando a função "selecionar" descrita anteriormente:

.posts [] | select (.author == "stedolan")

Os caminhos fornecidos por esta operação apontam para cada uma das postagens que "stedolan" escreveu, e
podemos comentar sobre cada um deles da mesma forma que fizemos antes:

(.posts [] | select (.author == "stedolan") | .comments) | =
. + ["terrível."]

MÓDULOS

jq tem um sistema de biblioteca / módulo. Módulos são arquivos cujos nomes terminam em .jq.

Módulos importados por um programa são pesquisados ​​em um caminho de pesquisa padrão (veja abaixo). O
importar e incluir as diretivas permitem que o importador altere esse caminho.

Os caminhos em um caminho de pesquisa estão sujeitos a várias substituições.

Para caminhos que começam com "~ /", o diretório inicial do usuário é substituído por "~".

Para caminhos que começam com "$ ORIGIN /", o caminho do executável jq é substituído por
"$ ORIGIN".

Para caminhos que começam com "./" ou caminhos que são ".", O caminho do arquivo incluído é
substituído por ".". Para programas de nível superior fornecidos na linha de comando, o atual
diretório é usado.

As diretivas de importação podem, opcionalmente, especificar um caminho de pesquisa ao qual o padrão é anexado.

O caminho de pesquisa padrão é o caminho de pesquisa dado ao -L opção de linha de comando, senão
["~ / .jq", "$ ORIGIN /../ lib / jq", "$ ORIGIN / ../ lib"].

Elementos de caminho de string nulos e vazios encerram o processamento do caminho de pesquisa.

Uma dependência com caminho relativo "foo / bar" seria pesquisada em "foo / bar.jq" e
"foo / bar / bar.jq" no caminho de pesquisa fornecido. O objetivo é permitir que os módulos sejam colocados
em um diretório junto com, por exemplo, arquivos de controle de versão, arquivos README e assim por diante,
mas também para permitir módulos de arquivo único.

Componentes consecutivos com o mesmo nome não são permitidos para evitar ambigüidades (por exemplo,
"foo / foo").

Por exemplo, com -L $ HOME / .jq um módulo Foo pode ser encontrada em $ HOME / .jq / foo.jq e
$ HOME / .jq / foo / foo.jq.

Se "$ HOME / .jq" for um arquivo, ele é originado no programa principal.

importar StringCaminhoRelativo as NOME [ ];
Importa um módulo encontrado no caminho fornecido em relação a um diretório em um caminho de pesquisa. A ".jq"
sufixo será adicionado à string do caminho relativo. Os símbolos do módulo são prefixados com
"NOME::".

Os metadados opcionais devem ser uma expressão jq constante. Deve ser um objeto com chaves
como "página inicial" e assim por diante. No momento, o jq usa apenas a chave / valor "search" do
metadados. Os metadados também são disponibilizados aos usuários por meio do módulo meta construídas em.

A chave "search" nos metadados, se presente, deve ter uma string ou valor de array (array
de cordas); este é o caminho de pesquisa a ser prefixado ao caminho de pesquisa de nível superior.

incluir StringCaminhoRelativo [ ];
Importa um módulo encontrado no caminho fornecido em relação a um diretório em um caminho de pesquisa como se ele
foram incluídos no local. Um sufixo ".jq" será adicionado à string de caminho relativo. O
os símbolos do módulo são importados para o namespace do chamador como se o conteúdo do módulo tivesse
foram incluídos diretamente.

Os metadados opcionais devem ser uma expressão jq constante. Deve ser um objeto com chaves
como "página inicial" e assim por diante. No momento, o jq usa apenas a chave / valor "search" do
metadados. Os metadados também são disponibilizados aos usuários por meio do módulo meta construídas em.

importar StringCaminhoRelativo as $ NAME [ ];
Importa um arquivo JSON encontrado no caminho fornecido em relação a um diretório em um caminho de pesquisa. UMA
O sufixo ".json" será adicionado à string do caminho relativo. Os dados do arquivo serão
disponível como $ NAME :: NAME.

Os metadados opcionais devem ser uma expressão jq constante. Deve ser um objeto com chaves
como "página inicial" e assim por diante. No momento, o jq usa apenas a chave / valor "search" do
metadados. Os metadados também são disponibilizados aos usuários por meio do módulo meta construídas em.

A chave "search" nos metadados, se presente, deve ter uma string ou valor de array (array
de cordas); este é o caminho de pesquisa a ser prefixado ao caminho de pesquisa de nível superior.

módulo ;
Esta diretiva é totalmente opcional. Não é necessário para o funcionamento adequado. Ele serve
apenas o propósito de fornecer metadados que podem ser lidos com o módulo meta construídas em.

Os metadados devem ser uma expressão jq constante. Deve ser um objeto com chaves como
"pagina inicial". No momento, o jq não usa esses metadados, mas estão disponíveis para os usuários
via módulo meta construídas em.

módulo meta
Recebe um nome de módulo como entrada e produz os metadados do módulo como um objeto, com o
importações do módulo (incluindo metadados) como um valor de array para a chave "deps".

Os programas podem usar isso para consultar os metadados de um módulo, os quais eles podem usar para, para
por exemplo, pesquise, baixe e instale dependências ausentes.

Use jq online usando serviços onworks.net