jq - Online nel cloud

PROGRAMMA:

NOME

jq - Processore JSON da riga di comando

SINOSSI

jq [Opzioni...] filtro [file...]

jq può trasformare JSON in vari modi, selezionando, iterando, riducendo e altro
storpiare documenti JSON. Ad esempio, eseguendo il comando jq ´mappa (.prezzo) | Inserisci volere
prendi un array di oggetti JSON come input e restituisci la somma dei loro campi "prezzo".

jq può accettare anche l'input di testo, ma per impostazione predefinita, jq legge un flusso di entità JSON
(inclusi numeri e altri letterali) da stdin. Gli spazi bianchi sono necessari solo per separare
entità come 1 e 2 e vero e falso. Uno o più file può essere specificato, in cui
Custodie jq leggerà invece l'input da quelli.

I Opzioni sono descritti in INVOCANDO JQ sezione; riguardano principalmente input e output
formattazione. Il filtro è scritto nel linguaggio jq e specifica come trasformare il
file o documento di input.

FILTRI

Un programma jq è un "filtro": prende un input e produce un output. Ci sono molti
filtri incorporati per estrarre un particolare campo di un oggetto o convertire un numero in
una stringa o varie altre attività standard.

I filtri possono essere combinati in vari modi: è possibile convogliare l'uscita di un filtro in
un altro filtro o raccogliere l'output di un filtro in un array.

Alcuni filtri producono più risultati, ad esempio ce n'è uno che produce tutti i
elementi della sua matrice di input. Convogliando quel filtro in un secondo viene eseguito il secondo filtro per
ogni elemento dell'array. Generalmente, cose che verrebbero fatte con cicli e iterazioni
in altre lingue vengono semplicemente incollati insieme i filtri in jq.

È importante ricordare che ogni filtro ha un ingresso e un'uscita. anche letterali
come "ciao" o 42 sono filtri: prendono un input ma producono sempre lo stesso letterale di
produzione. Le operazioni che combinano due filtri, come l'addizione, alimentano generalmente lo stesso input
ad entrambi e combinare i risultati. Quindi, puoi implementare un filtro di media come aggiungere / lunghezza
- alimentare l'array di input sia al aggiungere filtro e il lunghezza filtrare e poi eseguire
la divisione.

Ma questo è anticipare noi stessi. :) Cominciamo con qualcosa di più semplice:

INVOCANDO JQ

I filtri jq vengono eseguiti su un flusso di dati JSON. L'input di jq viene analizzato come una sequenza di
valori JSON separati da spazi che vengono passati attraverso il filtro fornito uno in a
tempo. Le uscite del filtro vengono scritte sull'uscita standard, sempre come una sequenza di
dati JSON separati da spazi.

Nota: è importante tenere a mente le regole di citazione della shell. Come regola generale è meglio
citare sempre (con virgolette singole) il programma jq, in quanto troppi caratteri con
significato speciale per jq sono anche meta-caratteri di shell. Per esempio, jq "foo" fallirà
la maggior parte delle shell Unix perché sarà lo stesso di jq foo, che generalmente fallirà
perché foo is non definito. Quando si utilizza la shell dei comandi di Windows (cmd.exe) è meglio
usa le virgolette intorno al tuo programma jq quando vengono fornite sulla riga di comando (invece di -f
file-programma opzione), ma poi le doppie virgolette nel programma jq richiedono l'escape della barra rovesciata.

Puoi influenzare il modo in cui jq legge e scrive il suo input e output usando una riga di comando
opzioni:

· --versione:

Emetti la versione jq ed esci con zero.

· --segg:

Usa il applicazione/json-seq Schema di tipo MIME per separare i testi JSON nell'input di jq
e uscita. Ciò significa che un carattere ASCII RS (separatore di record) viene stampato prima
ogni valore sull'output e un ASCII LF (line feed) viene stampato dopo ogni output. Ingresso
I testi JSON che non riescono ad analizzare vengono ignorati (ma avvisati), scartando tutto
ingresso successivo fino al successivo RS. Questo più analizza anche l'output di jq senza il
--segg opzione.

· --flusso:

Analizza l'input in modalità streaming, emettendo array di valori di percorso e foglia
(scalari e array vuoti o oggetti vuoti). Per esempio, "un" diventa [[],"un"]e
[[],"a",["b"]] diventa [[0],[]], [[1],"un"]e [[1,0],"b"].

Questo è utile per elaborare input molto grandi. Usalo insieme a
filtraggio e il ridurre ed foreach sintassi per ridurre gli input di grandi dimensioni in modo incrementale.

· --slurp/-s:

Invece di eseguire il filtro per ogni oggetto JSON nell'input, leggi l'intero input
eseguire lo streaming in un array di grandi dimensioni ed eseguire il filtro solo una volta.

· --raw-input/-R:

Non analizzare l'input come JSON. Invece, ogni riga di testo viene passata al filtro come a
corda. Se abbinato a --slurp, quindi l'intero input viene passato al filtro come a
singola lunga stringa.

· --null-input/-n:

Non leggere alcun input! Invece, il filtro viene eseguito una volta utilizzando nullo come ingresso.
Questo è utile quando si utilizza jq come semplice calcolatrice o per costruire dati JSON da
graffiare.

· --uscita compatta / -c:

Per impostazione predefinita, jq stampa graziosamente l'output JSON. L'uso di questa opzione comporterà di più
output compatto mettendo invece ogni oggetto JSON su una singola riga.

· --tab:

Usa una tabulazione per ogni livello di rientro invece di due spazi.

· --rientro n:

Utilizzare il numero di spazi specificato (non più di 8) per il rientro.

· --output-colore / -C ed --uscita monocromatica / -M:

Per impostazione predefinita, jq emette JSON colorato se si scrive su un terminale. Puoi costringerlo a
produrre colore anche se si scrive su una pipe o su un file usando -Ce disabilita il colore con -M.

· --ascii-uscita / -a:

jq di solito emette codepoint Unicode non ASCII come UTF-8, anche se l'input specificato
come sequenze di escape (come "\u03bc"). Usando questa opzione, puoi forzare jq a
produrre un output ASCII puro con ogni carattere non ASCII sostituito con l'equivalente
sequenza di fuga.

· --senza buffer

Svuota l'output dopo che ogni oggetto JSON è stato stampato (utile se stai effettuando un piping lento
sorgente dati in jq e reindirizzare l'output di jq altrove).

· --ordina-tasti / -S:

Emetti i campi di ogni oggetto con le chiavi in ​​ordine.

· --output grezzo / -r:

Con questa opzione, se il risultato del filtro è una stringa, verrà scritto direttamente
all'output standard anziché essere formattata come stringa JSON con virgolette. questo può
essere utile per far dialogare i filtri jq con sistemi non basati su JSON.

· --join-output / -j:

Come -r ma jq non stamperà una nuova riga dopo ogni output.

· -f Nome del file / --dal file Nome del file:

Leggi il filtro dal file piuttosto che da una riga di comando, come l'opzione -f di awk. Voi
può anche usare ´#´ per fare commenti.

· -Ldirectory / -L elenco:

Anteponi elenco all'elenco di ricerca dei moduli. Se questa opzione viene utilizzata, no
viene utilizzato l'elenco di ricerca integrato. Vedere la sezione sui moduli di seguito.

· -e / --exit-stato:

Imposta lo stato di uscita di jq su 0 se l'ultimo valore di uscita non è stato né l'uno né l'altro falso né nullo,
1 se l'ultimo valore di output era uno dei due falso or nullo, o 4 se nessun risultato valido è mai stato
prodotto. Normalmente jq esce con 2 se c'è stato qualche problema di utilizzo o errore di sistema, 3
se c'è stato un errore di compilazione del programma jq, o 0 se il programma jq è stato eseguito.

· --argo Nome APPREZZIAMO:

Questa opzione passa un valore al programma jq come variabile predefinita. Se esegui jq
con --argo foo bar, poi $ foo è disponibile nel programma e ha il valore "bar".
Si noti che APPREZZIAMO sarà trattato come una stringa, quindi --argo foo 123 si legherà $ foo a "123".

· --argjson Nome Testo JSON:

Questa opzione passa un valore con codifica JSON al programma jq come variabile predefinita. Se
corri jq con --argjson foo 123, poi $ foo è disponibile nel programma e ha il
APPREZZIAMO 123.

· --fileslurp nome-variabile Nome del file:

Questa opzione legge tutti i testi JSON nel file denominato e associa un array di
ha analizzato i valori JSON nella variabile globale data. Se esegui jq con --argfile foo bar,
poi $ foo è disponibile nel programma e ha un array i cui elementi corrispondono a
i testi nel file denominato bar.

· --argfile nome-variabile Nome del file:

Non usare. Utilizzo --fileslurp anziché.

(Questa opzione è come --fileslurp, ma quando il file ha un solo testo, allora è
usato, altrimenti viene usato un array di testi come in --fileslurp.)

· --run-test [nome del file]:

Esegue i test nel file specificato o nell'input standard. Questa deve essere l'ultima opzione data
e non onora tutte le opzioni precedenti. L'input è costituito da righe di commento, vuote
righe e righe di programma seguite da una riga di input, tante righe di output quante sono
previsto (uno per output) e una riga vuota di terminazione. Test di mancata compilazione
inizia con una riga contenente solo "%%FAIL", quindi una riga contenente il programma da
compile, quindi una riga contenente un messaggio di errore da confrontare con l'effettivo.

Tieni presente che questa opzione può cambiare in modo incompatibile all'indietro.

BASIC FILTRI

.
Il filtro in assoluto più semplice (e meno interessante) è .. Questo è un filtro che prende il suo
input e lo produce invariato come output.

Poiché jq per impostazione predefinita stampa in modo grazioso tutto l'output, questo banale programma può essere un modo utile di
formattazione dell'output JSON da, ad esempio, arricciare.

jq'.'
"Ciao mondo!"
=> "Ciao, mondo!"

.pippo, .pippo.bar
Il più semplice utile il filtro è .pippo. Quando viene assegnato un oggetto JSON (aka dizionario o hash) come
input, produce il valore alla chiave "pippo", o null se non è presente.

Se la chiave contiene caratteri speciali, devi racchiuderla tra virgolette come
Questo: "pippo$".

Un filtro della forma .pippo.bar è equivalente .foo|.bar.

jq ´.pippo´
{"foo": 42, "bar": "dati meno interessanti"}
=> 42

jq ´.pippo´
{"notfoo": true, "alsonotfoo": false}
=> nullo

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

.pippo?
Proprio come .pippo, ma non emette nemmeno un errore quando . non è un array o un oggetto.

jq ´.pippo?´
{"foo": 42, "bar": "dati meno interessanti"}
=> 42

jq ´.pippo?´
{"notfoo": true, "alsonotfoo": false}
=> nullo

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

jq ´[.pippo?]´
,
=> []

.[ ], .[2], .[10:15]
Puoi anche cercare i campi di un oggetto usando una sintassi come .["pippo"] (.foo sopra è un
versione abbreviata di questo). Questo funziona anche per gli array, se la chiave è un numero intero.
Gli array sono a base zero (come javascript), quindi . [2] restituisce il terzo elemento dell'array.

I .[10:15] la sintassi può essere utilizzata per restituire un sottoarray di un array o una sottostringa di una stringa.
L'array restituito da .[10:15] sarà di lunghezza 5, contenente gli elementi dall'indice 10
(incluso) all'indice 15 (esclusivo). Entrambi gli indici possono essere negativi (nel qual caso conta
indietro dalla fine dell'array), o omesso (nel qual caso si riferisce all'inizio o
fine della matrice).

I . [2] la sintassi può essere utilizzata per restituire l'elemento all'indice dato. Gli indici negativi sono
consentito, con -1 riferito all'ultimo elemento, -2 riferito al penultimo elemento,
e così via.

I .pippo la sintassi funziona solo per chiavi semplici, cioè chiavi che sono tutte caratteri alfanumerici.
.[ ] funziona con chiavi che contengono caratteri speciali come due punti e punti. Per
esempio .["pippo::bar"] ed .["pippo.bar"] lavorare mentre .foo::bar ed .pippo.bar non lo farebbe.

I ? "operatore" può essere utilizzato anche con l'operatore slice, come in .[10:15]?, che emette
valori in cui gli input possono essere suddivisi in sezioni.

jq´.[0]´
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> {"nome":"JSON", "buono":vero}

jq´.[2]´
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> nullo

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 si utilizza il .[indice] sintassi, ma ometti completamente l'indice, tornerà contro tutti i della
elementi di un array. In esecuzione .[] con l'ingresso , produrrà i numeri come tre
risultati separati, piuttosto che come un singolo array.

Puoi anche usarlo su un oggetto e restituirà tutti i valori dell'oggetto.

jq´.[]´
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> {"name":"JSON", "good":true}, {"name":"XML", "good":false}

jq´.[]´
[]
=>

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

.[]?
Come .[], ma non verranno emessi errori se . non è un array o un oggetto.

,
Se due filtri sono separati da una virgola, l'input verrà inserito in entrambi e lì
saranno più output: primo, tutti gli output prodotti dall'espressione a sinistra, e
quindi tutti gli output prodotti dalla destra. Ad esempio, filtro .pippo, .sbarra, produce
entrambi i campi "foo" e "bar" come output separati.

jq ´.foo, .bar´
{"pippo": 42, "bar": "qualcos'altro", "baz": vero}
=> 42, "qualcos'altro"

jq ´.utente, .progetti[]´
{"user":"stedolan", "projects": ["jq", "wikiflow"]}
=> "stedolan", "jq", "wikiflow"

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

|
Il | l'operatore combina due filtri alimentando l'uscita o le uscite di quello a sinistra in
l'ingresso di quello a destra. È più o meno lo stesso del tubo della shell di Unix, se
ci sei abituato.

Se quello a sinistra produce più risultati, quello a destra verrà eseguito per
ciascuno di questi risultati. Quindi, l'espressione .[] | .pippo recupera il campo "foo" di ciascuno
elemento della matrice di input.

jq ´.[] | .nome
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> "JSON", "XML"

TIPI E VALORI

jq supporta lo stesso set di tipi di dati di JSON: numeri, stringhe, booleani, array,
oggetti (che in linguaggio JSON sono hash con solo chiavi stringa) e "null".

Booleani, null, stringhe e numeri sono scritti allo stesso modo di javascript. Proprio come
tutto il resto in jq, questi semplici valori prendono un input e producono un output - 42 è un
un'espressione jq valida che accetta un input, lo ignora e restituisce invece 42.

Italia costruzione - []
Come in JSON, [] è usato per costruire array, come in ,. Gli elementi degli array possono
essere qualsiasi espressione jq. Vengono raccolti tutti i risultati prodotti da tutte le espressioni
in un unico grande array. Puoi usarlo per costruire un array da una quantità nota di valori
(Come in [.pippo, .sbarra, .baz]) o per "raccogliere" tutti i risultati di un filtro in un array (come
in [.articoli[].nome])

Una volta compreso l'operatore ",", puoi guardare la sintassi dell'array di jq in un modo diverso
luce: l'espressione , non utilizza una sintassi integrata per gli array separati da virgole,
ma sta invece applicando il [] (raccogli i risultati) all'espressione 1,2,3 (che
produce tre risultati diversi).

Se hai un filtro X che produce quattro risultati, quindi l'espressione [X] produrrà un file
unico risultato, un array di quattro elementi.

jq ´[.utente, .progetti[]]´
{"user":"stedolan", "projects": ["jq", "wikiflow"]}
=> ["stedolan", "jq", "wikiflow"]

Oggetti - {}
Come JSON, {} serve per costruire oggetti (noti anche come dizionari o hash), come in: {"un": 42
"B": 17}.

Se i tasti sono "sensibili" (tutti i caratteri alfabetici), le virgolette possono essere omesse.
Il valore puòessere qualsiasi espressione (anche se potrebbe essere necessario racchiuderlo tra parentesi seèuguale
complicato), che viene applicato all'input dell'espressione {} (ricorda, tutti i filtri)
avere un ingresso e un'uscita).

{pippo: .bar}

produrrà l'oggetto JSON {"pippo": 42} se dato l'oggetto JSON {"bar":42, "baz":43}.
Puoi usarlo per selezionare particolari campi di un oggetto: se l'input è un oggetto con
campi "utente", "titolo", "id" e "contenuto" e vuoi solo "utente" e "titolo", puoi
scrivere

{utente: .utente, titolo: .titolo}

Poiché è così comune, esiste una sintassi di scelta rapida: {utente, titolo}.

Se una delle espressioni produce più risultati, più dizionari saranno
prodotto. Se l'input è

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

poi l'espressione

{utente, titolo: .titles[]}

produrrà due output:

{"user":"stedolan", "title": "JQ Primer"}
{"user":"stedolan", "title": "Altro JQ"}

Mettere le parentesi intorno alla chiave significa che verrà valutata come un'espressione. Con il
stesso ingresso di cui sopra,

{(.utente): .titoli}

produce

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

jq ´{utente, titolo: .titles[]}´
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
=> {"user":"stedolan", "title": "JQ Primer"}, {"user":"stedolan", "title": "More JQ"}

jq ´{(.utente): .titoli}´
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
=> {"stedolan": ["JQ Primer", "More JQ"]}

COSTRUZIONE OPERATORI E FUNZIONI

Alcuni operatori jq (ad esempio, +) fanno cose diverse a seconda del tipo di loro
argomenti (matrici, numeri, ecc.). Tuttavia, jq non esegue mai conversioni di tipo implicite. Se
se provi ad aggiungere una stringa a un oggetto riceverai un messaggio di errore e nessun risultato.

Aggiunta - +
L'operatore + prende due filtri, li applica entrambi allo stesso input e aggiunge il
risultati insieme. Cosa significa "aggiungere" dipende dai tipi coinvolti:

· numeri vengono aggiunti con la normale aritmetica.

· Array vengono aggiunti concatenandoli in un array più grande.

· String vengono aggiunti unendoli in una stringa più grande.

· Oggetti vengono aggiunti fondendo, cioè inserendo tutte le coppie chiave-valore da entrambi
oggetti in un unico oggetto combinato. Se entrambi gli oggetti contengono un valore per lo stesso
chiave, l'oggetto a destra del + vince. (Per l'unione ricorsiva utilizzare il * operatore.)

nullo può essere aggiunto a qualsiasi valore e restituisce l'altro valore invariato.

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

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

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

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

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

Sottrazione - -
Oltre alla normale sottrazione aritmetica sui numeri, il - l'operatore può essere utilizzato sugli array
per rimuovere tutte le occorrenze degli elementi del secondo array dal primo array.

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

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

Moltiplicazione, divisione, modulo - *, /, ed %
Questi operatori infissi si comportano come previsto quando vengono forniti due numeri. Divisione per zero rilanci
un errore. x % y calcola x modulo y.

Moltiplicare una stringa per un numero produce la concatenazione di quella stringa quel numero
volte. "X" * 0 produce nullo.

Dividere una stringa per un'altra divide la prima usando la seconda come separatore.

Moltiplicare due oggetti li fonderà ricorsivamente: funziona come l'addizione ma se entrambi
gli oggetti contengono un valore per la stessa chiave e i valori sono oggetti, i due vengono uniti
con la stessa strategia.

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}}´
nullo
=> {"k": {"a": 0, "b": 2, "c": 3}}

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

lunghezza
La funzione integrata lunghezza ottiene la lunghezza di diversi tipi di valore:

· La lunghezza di a stringa è il numero di codepoint Unicode che contiene (che sarà
lo stesso della sua lunghezza codificata JSON in byte se è puro ASCII).

· La lunghezza di an schieramento è il numero di elementi.

· La lunghezza di an oggetto è il numero di coppie chiave-valore.

· La lunghezza di nullo è zero.

jq ´.[] | lunghezza´ [[1,2], "stringa", {"a":2}, null] => 2, 6, 1, 0

chiavi, chiavi_non ordinate
La funzione integrata Tasti, quando viene assegnato un oggetto, restituisce le sue chiavi in ​​un array.

Le chiavi sono ordinate "in ordine alfabetico", per ordine di codepoint unicode. Questo non è un ordine
che ha un senso particolare in una lingua particolare, ma puoi contare sul fatto che sia il
lo stesso per due oggetti qualsiasi con lo stesso set di chiavi, indipendentemente dalle impostazioni internazionali.

Quando Tasti viene dato un array, restituisce gli indici validi per quell'array: gli interi
da 0 a lunghezza-1.

I chiavi_non ordinate la funzione è proprio come Tasti, ma se l'input è un oggetto allora i tasti
non verranno ordinate, le chiavi saranno invece approssimativamente nell'ordine di inserimento.

jq 'chiavi'
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["Pippo", "abc", "abcd"]

jq 'chiavi'
,
=> [0,1,2]

ha (chiave)
La funzione integrata ha restituisce se l'oggetto di input ha la chiave data o l'input
array ha un elemento all'indice dato.

ha ($chiave) ha lo stesso effetto del controllo se $chiave è un membro dell'array restituito
by Tasti, Sebbene ha sarà più veloce.

jq ´mappa(ha("pippo"))´
[{"pippo": 42}, {}]
=> [vero, falso]

jq ´mappa(ha(2)´
[[0,1], ["a","b","c"]]
=> [falso, vero]

in
La funzione integrata in restituisce la chiave di input è nell'oggetto dato o l'indice di input
corrisponde a un elemento nell'array specificato. È, essenzialmente, una versione inversa di
ha.

jq ´.[] | in({"pippo": 42})´
["pippo", "bar"]
=> vero, falso

jq ´mappa(in([0,1]))´
[2, 0]
=> [falso, vero]

percorso(espressione_percorso)
Emette rappresentazioni array dell'espressione di percorso data in .. Le uscite sono array di
stringhe (chiavi in ​​object0 e/o numeri (array index.

Le espressioni di percorso sono espressioni jq come .a, ma anche .[]. Ci sono due tipi di percorso
espressioni: quelle che possono corrispondere esattamente e quelle che non possono. Per esempio, .abc offre
espressione del percorso di corrispondenza esatta, mentre .a[].b non è.

percorso(esatto_percorso_espressione) produrrà la rappresentazione dell'array dell'espressione del percorso
anche se non esiste in ., Se . is nullo o un array o un oggetto.

percorso (schema) produrrà rappresentazioni di array dei percorsi corrispondenti modello se l'
i percorsi esistono in ..

Si noti che le espressioni di percorso non sono diverse dalle espressioni normali. L'espressione
percorso(..|select(type=="boolean")) restituisce tutti i percorsi ai valori booleani in ., e solo
quei percorsi.

jq ´percorso(.a[0].b)´
nullo
=> ["a",0,"b"]

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

del(espressione_percorso)
La funzione integrata del rimuove una chiave e il suo valore corrispondente da un oggetto.

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

jq 'del(.[1, 2])'
["pippo", "bar", "baz"]
=> ["pippo"]

a_voci, da_entry, con_voci
Queste funzioni convertono tra un oggetto e un array di coppie chiave-valore. Se a_voci
viene passato un oggetto, quindi per ciascuno k: v voce nell'input, l'array di output include
{"chiave": k, "valore": v}.

da_voci fa la conversione opposta, e con_voci (pippo) è una scorciatoia per
a_voci | mappa (pippo) | da_voci, utile per fare qualche operazione su tutti i tasti e
valori di un oggetto. da_voci accetta chiave, Chiave, Nome, valore e Valore come chiavi.

jq 'a_voci'
{"a": 1, "b": 2}
=> [{"chiave":"a", "valore":1}, {"chiave":"b", "valore":2}]

jq 'da_voci'
[{"chiave":"a", "valore":1}, {"chiave":"b", "valore":2}]
=> {"a": 1, "b": 2}

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

select(espressione_booleana)
La funzione seleziona (pippo) produce il suo input invariato se foo restituisce true per quell'input,
e non produce alcun output altrimenti.

È utile per filtrare gli elenchi: , | mappa(seleziona(. >= 2)) vi darà ,.

jq ´mappa(seleziona(. >= 2))´
,
=> [5,3,7]

jq ´.[] | select(.id == "secondo")´
[{"id": "first", "val": 1}, {"id": "second", "val": 2}]
=> {"id": "secondo", "val": 2}

matrici, oggetti, iterabili, booleani, numeri, normali, finiti, stringhe, nulli, valori,
scalari
Questi built-in selezionano solo input che sono array, oggetti, iterabili (array o
oggetti), booleani, numeri, numeri normali, numeri finiti, stringhe, null, non null
valori e non iterabili, rispettivamente.

jq ´.[]|numeri´
[[],{},1,"pippo",null,vero,falso]
=> 1

vuoto
vuoto non restituisce alcun risultato. Proprio nessuno. Nemmeno nullo.

È utile a volte. saprai se ne hai bisogno :)

jq ´1, vuoto, 2´
nullo
=> 1, 2

jq ´[1,2,vuoto,3]´
nullo
=> [1,2,3]

errore(Messaggio)
Produce un errore, proprio come .a applicato a valori diversi da null e gli oggetti lo farebbero, ma
con il messaggio fornito come valore di errore.

$__località__
Produce un oggetto con una chiave "file" e una chiave "line", con il nome del file e il numero della riga
where $__località__ si verifica, come valori.

jq ´prova errore("\($__loc__)") catch .´
nullo
=> "{\"file\":\" \",\"Linea 1}"

mappa(x), valori_mappa(x)
Per qualsiasi filtro x, mappa(x) eseguirà quel filtro per ogni elemento dell'array di input e
produrre gli output di un nuovo array. mappa(.+1) incrementerà ogni elemento di un array di
numeri.

Analogamente, valori_mappa(x) eseguirà quel filtro per ogni elemento, ma restituirà an
oggetto quando viene passato un oggetto.

mappa(x) è equivalente [.[] | x]. In effetti, è così che viene definito. Allo stesso modo,
valori_mappa(x) è definita come .[] |= x.

jq ´mappa(.+1)´
,
=> [2,3,4]

jq 'valori_mappa(.+1)'
{"a": 1, "b": 2, "c": 3}
=> {"a": 2, "b": 3, "c": 4}

percorsi, percorsi(node_filter), percorsi_foglia
percorsi emette i percorsi a tutti gli elementi nel suo input (tranne che non emette il
lista vuota, che rappresenta . si).

percorsi (f) restituisce i percorsi a qualsiasi valore per cui f è vero. Questo è, percorsi (numeri)
restituisce i percorsi a tutti i valori numerici.

percorsi_foglia è un alias di percorsi (scalari); percorsi_foglia is deprecato e verrà rimosso in
la prossima major release.

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

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

aggiungere
Il filtro aggiungere prende come input un array e produce come output gli elementi dell'array
sommati insieme. Questo potrebbe significare sommato, concatenato o unito a seconda dei tipi di
gli elementi dell'array di input - le regole sono le stesse di quelle per il + operatore
(descritto sopra).

Se l'input è un array vuoto, aggiungere problemi nullo.

jq ´aggiungi´
["a","b","c"]
=> "abc"

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

jq ´aggiungi´
[]
=> nullo

qualunque, qualsiasi (condizione), qualsiasi (generatore; condizione)
Il filtro in qualsiasi prende come input un array di valori booleani e produce vero come output se
uno qualsiasi degli elementi dell'array è vero.

Se l'input è un array vuoto, in qualsiasi problemi falso.

I qualsiasi (condizione) form applica la condizione data agli elementi dell'array di input.

I qualsiasi (generatore; condizione) applica la condizione data a tutte le uscite del
dato generatore.

jq 'qualsiasi'
[vero falso]
=> vero

jq 'qualsiasi'
[falso, falso]
=> falso

jq 'qualsiasi'
[]
=> falso

Tutti, tutto (condizione), tutto(generatore; condizione)
Il filtro contro tutti i prende come input un array di valori booleani e produce vero come output se
tutti gli elementi dell'array sono vero.

I tutto (condizione) form applica la condizione data agli elementi dell'array di input.

I tutto(generatore; condizione) applica la condizione data a tutte le uscite del
dato generatore.

Se l'input è un array vuoto, contro tutti i problemi vero.

jq ´tutti´
[vero falso]
=> falso

jq ´tutti´
[vero vero]
=> vero

jq ´tutti´
[]
=> vero

[Richiede 1.5] appiattire, appiattire (profondità)
Il filtro appiattire prende come input un array di array annidati e produce un flat array in
quale tutti gli array all'interno dell'array originale sono stati sostituiti in modo ricorsivo dai loro valori.
Puoi passargli un argomento per specificare quanti livelli di annidamento appiattire.

appiattire(2) è come appiattire, ma solo fino a due livelli di profondità.

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

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

jq ´appiattire´
[[]]
=> []

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

gamma (fino a), intervallo (da; fino a) intervallo (da; fino a; da)
I gamma la funzione produce un intervallo di numeri. intervallo(4;10) produce 6 numeri, da 4
(incluso) a 10 (esclusivo). I numeri vengono prodotti come output separati. Utilizzo
[intervallo(4;10)] per ottenere un intervallo come array.

La forma a un argomento genera numeri da 0 al numero dato, con un incremento di
1.

La forma a due argomenti genera numeri da da a fino a con un incremento di 1.

La forma a tre argomenti genera numeri da a fino a con un incremento di by.

jq ´intervallo(2;4)´
nullo
=> 2, 3

jq ´[intervallo(2;4)]´
nullo
=> [2,3]

jq '[gamma(4)]´
nullo
=> [0,1,2,3]

jq ´[intervallo(0;10;3)]´
nullo
=> [0,3,6,9]

jq ´[intervallo(0;10;-1)]´
nullo
=> []

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

piano
I piano la funzione restituisce il piano del suo input numerico.

jq ´pavimento´
3.14159
=> 3

sqrt
I sqrt la funzione restituisce la radice quadrata del suo input numerico.

jq 'sqrt'
9
=> 3

numero di iscrizione
I numero di iscrizione la funzione analizza il suo input come un numero. Verrà convertito correttamente formattato
stringhe al loro equivalente numerico, lascia stare i numeri e dà un errore su tutti gli altri
ingresso.

jq ´.[] | numero di tonnellate´
[, "1"]
=> 1, 1

accordare
I accordare la funzione stampa il suo input come una stringa. Le stringhe vengono lasciate invariate e tutto
altri valori sono codificati JSON.

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

Digitare
I Digitare la funzione restituisce il tipo del suo argomento come una stringa, che è uno di null,
booleano, numero, stringa, array o oggetto.

jq ´mappa (tipo)´
[0, falso, [], {}, null, "ciao"]
=> ["numero", "booleano", "array", "oggetto", "null", "stringa"]

infinito, No, è infinito, Isnan, è finito, è normale
Alcune operazioni aritmetiche possono produrre infiniti e valori "non un numero" (NaN). Il
è infinito ritorni incorporati vero se il suo input è infinito. Il isnan ritorni incorporati vero
se il suo input è un NaN. Il infinito builtin restituisce un valore infinito positivo. Il nan
builtin restituisce un NaN. Il è normale builtin restituisce true se il suo input è un numero normale.

Nota che la divisione per zero genera un errore.

Attualmente la maggior parte delle operazioni aritmetiche che operano su infiniti, NaN e subnormali non lo fanno
sollevare errori.

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

jq ´infinito, nan | genere
nullo
=> "numero", "numero"

ordinare, sort_by(percorso_espressione)
I sorta functions ordina il suo input, che deve essere un array. I valori sono ordinati in
seguente ordine:

· nullo

· falso

· vero

· numeri

· stringhe, in ordine alfabetico (per valore di codepoint unicode)

· array, in ordine lessicale

· oggetti

L'ordinamento degli oggetti è un po' complesso: prima vengono confrontati confrontando i loro
set di chiavi (come array in ordine ordinato) e se le loro chiavi sono uguali, i valori sono
confronto chiave per chiave.

sorta può essere utilizzato per ordinare in base a un particolare campo di un oggetto o applicando qualsiasi filtro jq.

sort_by(pippo) confronta due elementi confrontando il risultato di foo su ogni elemento.

jq ´ordina´
[8,3,nullo,6]
=> [nullo,3,6,8]

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

group_by(percorso_espressione)
gruppo_di(.foo) prende come input un array, raggruppa gli elementi aventi lo stesso .pippo campo
in array separati e produce tutti questi array come elementi di un array più grande,
ordinato per il valore di .pippo campo.

Qualsiasi espressione jq, non solo un campo di accesso, può essere usata al posto di .pippo. L'ordinamento
l'ordine è lo stesso descritto nel sorta funzione sopra.

jq 'group_by(.foo)'
[{"pippo":1, "bar":10}, {"pippo":3, "bar":100}, {"pippo":1, "bar":1}]
=> [[{"pippo":1, "bar":10}, {"pippo"::1, "bar":1}], [{"pippo":3, "bar":100}]]

min, max min_by(percorso_exp), max_by(percorso_exp)
Trova l'elemento minimo o massimo dell'array di input.

I min_by(percorso_exp) ed max_by(percorso_exp) le funzioni consentono di specificare un particolare
campo o proprietà da esaminare, ad es min_da(.foo) trova l'oggetto con il più piccolo foo
campo.

jq 'min'
,
=> 2

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

unico, unique_by(percorso_exp)
I unico la funzione prende come input un array e produce un array degli stessi elementi, in
ordinato, con i duplicati rimossi.

I unique_by(percorso_exp) la funzione manterrà un solo elemento per ogni valore ottenuto da
applicando l'argomentazione. Pensalo come creare un array prendendo un elemento da ogni
gruppo prodotto da gruppo.

jq ´unico´
,
=> [1,2,3,5]

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

jq ´unico_di(lunghezza)´
["grosso", "pancetta", "gattino", "cicala", "asparago"]
=> ["pancetta", "grosso", "asparagi"]

invertire
Questa funzione inverte un array.

jq 'inverso'
,
=> [4,3,2,1]

contiene (elemento)
Il filtro contiene (b) produrrà true se b è completamente contenuto nell'input. UN
la stringa B è contenuta in una stringa A se B è una sottostringa di A. Un array B è contenuto in
un array A se tutti gli elementi in B sono contenuti in qualsiasi elemento in A. Un oggetto B è
contenuto nell'oggetto A se tutti i valori in B sono contenuti nel valore in A con il
stessa chiave. Si presume che tutti gli altri tipi siano contenuti l'uno nell'altro se sono uguali.

jq ´contiene("bar")´
"foobar"
=> vero

jq ´contiene(["baz", "bar"])´
["foobar", "foobaz", "blarp"]
=> vero

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

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

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

indici
Emette un array contenente gli indici in . where s si verifica. L'input può essere un array, in
in che caso se s è un array allora l'output degli indici sarà quello in cui tutti gli elementi sono dentro .
abbinare quelli di s.

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

jq´indici(1)´
,
=> [1,3,5]

jq ´indici([1,2])´
,
=> [1,8]

indice(i), indice(i)
Emette l'indice del primo (Index) o l'ultimo (indice) occorrenza di s nell'ingresso.

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

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

interno
Il filtro dentro (b) produrrà vero se l'input è completamente contenuto in b. Esso
è, essenzialmente, una versione inversa di contiene.

jq ´inside("foobar")´
"bar"
=> vero

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

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

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

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

inizia con (str)
Uscite vero Se . inizia con l'argomento stringa dato.

jq ´[.[]|inizia con("pippo")]´
["fo", "pippo", "pippo", "pippo", "pippo"]
=> [falso, vero, falso, vero, falso]

finisce con (str)
Uscite vero Se . termina con l'argomento stringa dato.

jq ´[.[]|termina con("pippo")]´
["foobar", "barfoo"]
=> [falso, vero]

combinazioni, combinazioni(n)
Emette tutte le combinazioni degli elementi degli array nell'array di input. Se dato un
argomento n, emette tutte le combinazioni di n ripetizioni dell'array di input.

jq 'combinazioni'
[[1,2], [3, 4]]
=> [1, 3], [1, 4], [2, 3], [2, 4]

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

ltrimstr(str)
Emette il suo input con la stringa di prefisso data rimossa, se inizia con essa.

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

rtrimstr(str)
Emette il suo input con la stringa di suffisso data rimossa, se termina con essa.

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

esplodere
Converte una stringa di input in un array dei numeri di codepoint della stringa.

jq 'esplodere'
"foobar"
=> [102,111,111,98,97,114]

implodere
L'inverso di esplodere.

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

dividere
Divide una stringa di input sull'argomento separatore.

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

unisciti (str)
Unisce l'array di elementi dati come input, usando l'argomento come separatore. È il
inverso di dividere: cioè correre split("pippo") | unisciti ("pippo") su qualsiasi stringa di input
restituisce detta stringa di input.

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

ascii_downcase, ascii_upcase
Emetti una copia della stringa di input con i suoi caratteri alfabetici (az e AZ) convertiti in
il caso specificato.

mentre(cond; aggiornare)
I mentre(cond; aggiornare) La funzione consente di applicare ripetutamente un aggiornamento a . fino a quando cond
è falso.

Si noti che mentre(cond; aggiornare) è internamente definita come una funzione jq ricorsiva. Ricorsivo
chiama dentro while non consumerà memoria aggiuntiva se update ne produce al massimo uno
uscita per ogni ingresso. Vedi gli argomenti avanzati di seguito.

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

fino a (cond; Il prossimo)
I fino a (cond; Il prossimo) la funzione consente di applicare ripetutamente l'espressione GENERAZIONE,
inizialmente a . poi alla propria uscita, finché cond è vero. Ad esempio, questo può essere usato
per implementare una funzione fattoriale (vedi sotto).

Si noti che fino a (cond; Il prossimo) è internamente definita come una funzione jq ricorsiva. Ricorsivo
chiama dentro fino a() non consumerà memoria aggiuntiva se GENERAZIONE ne produce al massimo uno
uscita per ogni ingresso. Vedi gli argomenti avanzati di seguito.

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

ricorsivo (f), ricorso, ricorsivo(f; condizione), ricorse_down
I ricorsivo (f) la funzione consente di cercare attraverso una struttura ricorsiva ed estrarre
dati interessanti a tutti i livelli. Supponiamo che il tuo input rappresenti un filesystem:

{"nome": "/", "bambini": [
{"nome": "/bidone", "figli": [
{"nome": "/ bin / ls", "figli": []},
{"nome": "/bin/sh", "figli": []}]},
{"nome": "/ Home", "figli": [
{"nome": "/home/stefano", "bambini": [
{"nome": "/home/stephen/jq", "bambini": []}]}]}]}

Supponiamo ora di voler estrarre tutti i nomi di file presenti. Devi recuperare . Nome,
.bambini[].nome, .bambini[].bambini[].nome, e così via. Puoi farlo con:

ricorse(.bambini[]) | .nome

Quando viene chiamato senza argomenti, ricorso è equivalente ricorso(.[]?).

ricorsivo (f) è identico a ricorsivo(f; . != nullo) e può essere utilizzato senza preoccupazioni su
profondità di ricorsione.

ricorsivo(f; condizione) è un generatore che inizia emettendo . e poi emette a sua volta
.|f, .|f|f, .|f|f|f, ... purché il valore calcolato soddisfi la condizione. Per
esempio, per generare tutti gli interi, almeno in linea di principio, si potrebbe scrivere ricorsione(.+1;
vero).

Per motivi di eredità, ricorse_down esiste come alias della chiamata ricorso senza argomenti.
Questo alias è considerato deprecato e verrà rimosso nella prossima major release.

Le chiamate ricorsive in ricorso non consumerà memoria aggiuntiva ogni volta che f produce a
più una singola uscita per ogni ingresso.

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

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

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

..
Scorciatoia per ricorso senza argomenti. Questo è pensato per assomigliare a XPath //
operatore. Notare che ..e non funziona; utilizzo ..|a Invece. Nell'esempio qui sotto usiamo
..|.un? per trovare tutti i valori delle chiavi oggetto "a" in qualsiasi oggetto trovato "sotto" ..

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

ENV
Emette un oggetto che rappresenta l'ambiente di jq.

jq 'env.PAGER'
nullo
=> "meno"

trasporre
Trasporre una matrice possibilmente frastagliata (un array di array). Le righe sono riempite con valori nulli quindi
il risultato è sempre rettangolare.

jq 'trasporre'
[[1], [2,3]]
=> [[1,2],[null,3]]

bricerca(x)
bsearch(x) esegue una ricerca binaria di x nell'array di input. Se l'input è ordinato e
contiene x, quindi bsearch(x) restituirà il suo indice nell'array; altrimenti, se l'array è
ordinato, restituirà (-1 - ix) dove ix è un punto di inserimento tale che l'array lo farebbe
essere ancora ordinato dopo l'inserimento di x in ix. Se l'array non è ordinato, bsearch(x)
restituirà un numero intero che probabilmente non interessa.

jq´bricerca(0)´
,
=> 0

jq´bricerca(0)´
,
=> -1

jq´bricerca(4) come $ix | se $ix < 0 allora .[-(1+$ix)] = 4 else . fine
,
=> [1,2,3,4]

Corda interpolazione - \(pippo)
All'interno di una stringa, puoi inserire un'espressione tra parentesi dopo una barra rovesciata. qualunque cosa
i ritorni dell'espressione verranno interpolati nella stringa.

jq ´"L´input era \(.), che è uno in meno di \(.+1)"´
42
=> "L'input era 42, che è uno in meno di 43"

convertire a da JSON
I tojson ed dajson i valori incorporati scaricano i valori come testi JSON o analizzano i testi JSON in
valori, rispettivamente. L'integrato tojson differisce da tostring in quanto tostring restituisce
stringhe non modificate, mentre tojson codifica le stringhe come stringhe JSON.

jq ´[.[]|tostringa]´
[1, "pippo", ["pippo"]]
=> ["1","pippo","[\"pippo\"]"]

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

jq ´[.[]|tojson|dajson]´
[1, "pippo", ["pippo"]]
=> [1,"pippo",["pippo"]]

Formato stringhe ed fuga
I @pippo la sintassi viene utilizzata per formattare ed eseguire l'escape delle stringhe, utile per creare URL,
documenti in un linguaggio come HTML o XML e così via. @pippo può essere usato come filtro su
proprio, le possibili fughe sono:

@testo:

Bandi accordare, vedere quella funzione per i dettagli.

@json:

Serializza l'input come JSON.

@html:

Applica l'escape HTML/XML, mappando i caratteri <>&´" alla loro entità
equivalenti <, >, &, ', ".

@uri:

Applica la codifica percentuale, mappando tutti i caratteri URI riservati su a %XX sequenza.

@csv:

L'input deve essere un array e viene visualizzato come CSV con virgolette doppie per
stringhe e virgolette sfuggite alla ripetizione.

@tsv:

L'input deve essere un array e viene visualizzato come TSV (valori separati da tabulazioni). Ogni
l'array di input verrà stampato come una singola riga. I campi sono separati da una singola scheda
(asci 0x09). avanzamento riga caratteri di input (ascii 0x0a), ritorno a capo (ascii
0x0d), scheda (ascii 0x09) e barra rovesciata (ascii 0x5c) verrà emesso come escape
sequenze \n, \r, \t, \\ rispettivamente.

@SH:

L'input è un escape adatto per l'uso in una riga di comando per una shell POSIX. Se la
input è un array, l'output sarà una serie di stringhe separate da spazi.

@base64:

L'input viene convertito in base64 come specificato da RFC 4648.

Questa sintassi può essere combinata in modo utile con l'interpolazione di stringhe. Puoi seguire un
@pippo token con una stringa letterale. Il contenuto della stringa letterale will non essere sfuggito.
Tuttavia, tutte le interpolazioni effettuate all'interno di quel valore letterale stringa verranno sfuggite. Ad esempio,

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

produrrà il seguente output per l'input {"ricerca": "cosa? is jq?"}:

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

Nota che le barre, il punto interrogativo, ecc. nell'URL non sono sfuggiti, poiché erano parte
del letterale stringa.

jq ´@html´
"Funziona se x < y"
=> "Funziona se x < y"

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

Date
jq fornisce alcune funzionalità di base per la gestione della data, con alcune di alto e basso livello
incorporati. In tutti i casi questi builtin si occupano esclusivamente dell'ora in UTC.

I dadateiso8601 builtin analizza datetime nel formato ISO 8601 in un numero di secondi
dall'epoca di Unix (1970-01-01T00:00:00Z). Il oggiiso8601 builtin fa l'inverso.

I dadata builtin analizza le stringhe datetime. Attualmente dadata supporta solo ISO 8601
stringhe datetime, ma in futuro tenterà di analizzare le stringhe datetime in più
formati.

I ad oggi builtin è un alias per oggiiso8601.

I adesso builtin emette l'ora corrente, in secondi dall'epoca di Unix.

Sono inoltre fornite interfacce jq di basso livello per le funzioni temporali della libreria C: strptime,
strftime, mktimee gmtime. Fare riferimento alla documentazione del sistema operativo host per il
stringhe di formato usate da strptime ed strftime. Nota: non sono necessariamente stabili
interfacce in jq, in particolare per quanto riguarda la loro funzionalità di localizzazione.

I gmtime builtin consuma un numero di secondi dall'epoca di Unix ed emette un "rotto
down time" rappresentazione del tempo come un array di numeri che rappresentano (in questo ordine): il
anno, mese (in base zero), giorno del mese, ora del giorno, minuto del
l'ora, il secondo del minuto, il giorno della settimana e il giorno dell'anno -- all
a base uno salvo diversa indicazione.

I mktime builtin consuma le rappresentazioni del "tempo interrotto" dell'output del tempo di gmtime
ed strptime.

I strptime(fmt) builtin analizza le stringhe di input che corrispondono a FMT discussione. L'uscita è in
la rappresentazione del "tempo spezzato" consumata da gmtime e uscita da mktime.

I strftime(fmt) builtin formatta una volta con il formato specificato.

Le stringhe di formato per strptime ed strftime sono descritti nella tipica libreria C
documentazione. La stringa di formato per la data e l'ora ISO 8601 è "%Y-%m-%dT%H:%M:%SZ".

jq potrebbe non supportare alcune o tutte queste funzionalità di data su alcuni sistemi.

jq ´dalla 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

CONDIZIONALI E CONFRONTI

==, !=
L'espressione ´a == b´ produrrà ´vero´ se il risultato di a e b sono uguali (cioè,
se rappresentano documenti JSON equivalenti) e "false" in caso contrario. In particolare, le stringhe
non sono mai considerati uguali ai numeri. Se vieni da Javascript, jq´s == è come
=== di Javascript - considerando i valori uguali solo quando hanno lo stesso tipo e anche
lo stesso valore.

!= è "non uguale", e ´a != b´ restituisce il valore opposto di ´a == b´

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

se-allora-altro
if A poi B altro C fine agirà come B if A produce un valore diverso da false o
nullo, ma agisci come C altrimenti.

Il controllo di false o nulle è una nozione di "verità" più semplice di quella che si trova in Javascript
o Python, ma significa che a volte dovrai essere più esplicito sulla condizione
vuoi: non puoi verificare se, ad esempio, una stringa è vuota usando if . Nome poi A altro B fine,
ti servirà qualcosa di più simile if (.nome | lunghezza) > 0 poi A altro B fine anziché.

Se la condizione A produce più risultati, è considerata "vera" se uno di questi
risultati non è falso o nullo. Se produce zero risultati, è considerato falso.

È possibile aggiungere più casi a un se si utilizza Elif A poi B sintassi.

jq ´se . == 0 allora

elifa "zero". == 1 poi "uno" else "molti" end´ 2 => "molti"

>, >=, <=, <
Gli operatori di confronto >, >=, <=, < restituisce se il loro argomento di sinistra è maggiore di,
maggiore o uguale a, minore o uguale o minore del loro argomento corretto
(rispettivamente).

L'ordine è lo stesso di quello descritto per sorta, sopra.

jq ´. < 5´
2
=> vero

e/o/no
jq supporta i normali operatori booleani e/o/o. Hanno lo stesso standard di verità
come se le espressioni - false e null fossero considerate "valori falsi", e qualsiasi altra cosa fosse a
"vero valore".

Se un operando di uno di questi operatori produce più risultati, l'operatore stesso
produrrà un risultato per ogni input.

non è infatti una funzione incorporata piuttosto che un operatore, quindi viene chiamato come filtro per
quali cose possono essere reindirizzate piuttosto che con una sintassi speciale, come in .pippo ed .sbarra | non.

Questi tre producono solo i valori "vero" e "falso", e quindi sono utili solo per genuini
Operazioni booleane, piuttosto che il comune idioma Perl/Python/Ruby di
"value_that_may_be_null o default". Se vuoi usare questa forma di "o", scegliendo tra
due valori anziché valutare una condizione, vedere l'operatore "//" di seguito.

jq ´42 e "una stringa"´
nullo
=> vero

jq ´(vero, falso) o falso´
nullo
=> vero, falso

jq ´(vero, vero) e (vero, falso)´
nullo
=> vero, falso, vero, falso

jq ´[vero, falso | non
nullo
=> [falso, vero]

Alternative operatore - //
Un filtro della forma a // b produce gli stessi risultati di a, Se a produce risultati altro
di falso ed nullo. Altrimenti, a // b produce gli stessi risultati di b.

Questo è utile per fornire le impostazioni predefinite: .pippo // 1 valuterà a 1 se non c'è .pippo
elemento in ingresso. È simile a come or è talvolta usato in Python (jq´s or operatore
è riservato alle operazioni strettamente booleane).

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

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

prova a prendere
Gli errori possono essere rilevati utilizzando prova EXP prendere EXP. Viene eseguita la prima espressione e se
fallisce quindi il secondo viene eseguito con il messaggio di errore. L'output del gestore, se
any, viene emesso come se fosse stato l'output dell'espressione da provare.

I prova EXP forma usa vuoto come gestore di eccezioni.

jq ´prova .a cattura ". non è un oggetto"´
vero
=> ".non è un oggetto"

jq ´[.[]|prova .a]´
[{}, vero, {"a":1}]
=> [nullo, 1]

jq ´prova errore ("qualche eccezione") catch .´
vero
=> "qualche eccezione"

Rottura su of di controllo strutture
Un uso conveniente di try/catch è quello di rompere le strutture di controllo come ridurre, foreach,
while, E così via.

Per esempio:

# Ripeti un'espressione finché non solleva "break" come an
# errore, quindi smetti di ripetere senza sollevare nuovamente l'errore.
# Ma se l'errore rilevato non è "break", allora rilancia nuovamente.
prova a ripetere (exp) catch .=="break" quindi svuota else errore;

jq ha una sintassi per le etichette lessicali denominate da "rompere" o "andare (indietro) a":

etichetta $out | ... scoppia $ fuori ...

I rompere $nome_etichetta espressione farà sì che il programma agisca come se fosse il più vicino
(A sinistra) etichetta $nome_etichetta prodotta vuoto.

La relazione tra il rompere e corrispondente etichetta è lessicale: l'etichetta deve essere
"visibile" dalla rottura.

Per uscire da a ridurre, Per esempio:

etichetta $out | riduci .[] come $item (null; if .==false allora spezza $out else ... end)

Il seguente programma jq produce un errore di sintassi:

rompere $fuori

perché nessuna etichetta $fuori è visibile.

? operatore
I ? operatore, usato come ESP?, è una scorciatoia per prova EXP.

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

REGOLARE ESPRESSIONI (PCRE)

jq utilizza la libreria di espressioni regolari Oniguruma, così come php, ruby, TextMate, Sublime Text,
ecc, quindi la descrizione qui si concentrerà sulle specifiche jq.

I filtri jq regex sono definiti in modo che possano essere utilizzati utilizzando uno di questi modelli:

STRING | FILTRO ( REGEX )
STRING | FILTRO( REGEX; BANDIERE )
STRING | FILTRO( [REGEX] )
STRING | FILTRO( [REGEX, BANDIERE])

dove: * STRING, REGEX e FLAGS sono stringhe jq e soggette a interpolazione di stringhe jq; *
REGEX, dopo l'interpolazione di stringhe, dovrebbe essere un'espressione regolare PCRE valida; * FILTER è uno dei test,
stile, o catturare, come descritto sotto.

FLAGS è una stringa costituita da uno o più flag supportati:

· g - Ricerca globale (trova tutte le corrispondenze, non solo la prima)

· i - Ricerca senza distinzione tra maiuscole e minuscole

· m - Modalità multi riga (´.´ corrisponderà alle nuove righe)

· n - Ignora le corrispondenze vuote

· p - Entrambe le modalità s e m sono abilitate

· s - Modalità riga singola (´^´ -> ´\A´, ´$´ -> ´\Z´)

· l - Trova le corrispondenze più lunghe possibili

· x - Formato regex esteso (ignora spazi bianchi e commenti)

Per far corrispondere gli spazi bianchi in un modello x usa un escape come \s, ad es

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

Nota che alcuni flag possono anche essere specificati all'interno di REGEX, ad es

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

valuta: vero, vero, falso, falso.

[Richiede 1.5] prova (val), prova(regex; bandiere)
Come stile, ma non restituisce solo oggetti corrispondenti vero or falso per se o no
regex corrisponde all'input.

jq ´test("pippo")´
"foo"
=> vero

jq ´.[] | test("abc # gli spazi vengono ignorati"; "ix")´
["xabcd", "ABC"]
=> vero, vero

[Richiede 1.5] corrispondenza (val), corrispondenza(espressione regolare; bandiere)
stile emette un oggetto per ogni corrispondenza trovata. Le corrispondenze hanno i seguenti campi:

· offset - offset in codepoint UTF-8 dall'inizio dell'input

· lunghezza - lunghezza in codepoint UTF-8 della partita

· stringa - la stringa che corrispondeva

· cattura - un array di oggetti che rappresentano i gruppi di cattura.

Gli oggetti di gruppo di acquisizione hanno i seguenti campi:

· offset - offset in codepoint UTF-8 dall'inizio dell'input

· lunghezza - lunghezza in codepoint UTF-8 di questo gruppo di acquisizione

· stringa - la stringa che è stata catturata

· Nome - il nome del gruppo di acquisizione (o nullo se era senza nome)

L'acquisizione di gruppi che non corrispondono a nulla restituisce un offset di -1

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

jq ´match("pippo")´
"pippo bar pippo"
=> {"offset": 0, "length": 3, "string": "foo", "captures": []}

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

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

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

[Richiede 1.5] cattura (val), cattura(regex; bandiere)
Raccoglie le acquisizioni denominate in un oggetto JSON, con il nome di ciascuna acquisizione come chiave,
e la stringa corrispondente come valore corrispondente.

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

[Richiede 1.5] scansione (regex), scan (regex; bandiere)
Emetti un flusso delle sottostringhe non sovrapposte dell'input che corrispondono alla regex in
secondo le bandiere, se ne sono state specificate. Se non c'è corrispondenza, il flusso è
vuoto. Per catturare tutte le corrispondenze per ogni stringa di input, usa l'idioma [ espr ], per esempio [
scansione (regex) ].

dividere(regex; bandiere)
Per la retrocompatibilità, dividere si divide su una stringa, non su una regex.

[Richiede 1.5] divide (regex), divide(regex; bandiere)
Questi forniscono gli stessi risultati dei loro dividere controparti, ma come un flusso invece di an
Vettore.

[Richiede 1.5] sub(espressione regolare; accordare) sub(espressione regolare; stringa; bandiere)
Emetti la stringa ottenuta sostituendo la prima corrispondenza di regex nella stringa di input con
accordare, dopo l'interpolazione. accordare dovrebbe essere una stringa jq e potrebbe contenere riferimenti
a catture nominate. Le catture nominate sono, in effetti, presentate come un oggetto JSON (come
costruito da catturare) A accordare, quindi un riferimento a una variabile catturata denominata "x" sarebbe
assumere la forma: "(.x)".

[Richiede 1.5] gsub(espressione regolare; corda), gsub(espressione regolare; stringa; bandiere)
gsub è come sotto ma tutte le occorrenze non sovrapposte della regex sono sostituite dalla
stringa, dopo l'interpolazione.

AVANZATE CARATTERISTICHE

Le variabili sono una necessità assoluta nella maggior parte dei linguaggi di programmazione, ma sono relegate
a una "funzione avanzata" in jq.

Nella maggior parte delle lingue, le variabili sono l'unico mezzo per passare i dati. Se calcoli a
value e vuoi usarlo più di una volta, dovrai memorizzarlo in una variabile. a
passa un valore a un'altra parte del programma, avrai bisogno di quella parte del programma per
definire una variabile (come parametro di funzione, membro oggetto o altro) in cui posizionare
i dati.

È anche possibile definire funzioni in jq, sebbene questa sia una caratteristica il cui più grande
uso sta definendo la libreria standard di jq (molte funzioni jq come carta geografica ed Find sono in effetti
scritto in jq).

jq ha operatori di riduzione, che sono molto potenti ma un po' complicati. Di nuovo, questi sono
usato principalmente internamente, per definire alcuni bit utili della libreria standard di jq.

Potrebbe non essere ovvio all'inizio, ma jq riguarda solo i generatori (sì, come spesso si trova in
altre lingue). Alcune utilità sono fornite per aiutare a gestire i generatori.

Un minimo di supporto I/O (oltre alla lettura di JSON dall'input standard e alla scrittura di JSON in
uscita standard) è disponibile.

Infine, c'è un modulo/sistema libreria.

Variabili
In jq, tutti i filtri hanno un ingresso e un'uscita, quindi l'impianto idraulico manuale non è necessario per
passare un valore da una parte di un programma alla successiva. Molte espressioni, per esempio a + b,
passare il loro input a due distinte sottoespressioni (qui a ed b sono passati entrambi allo stesso modo
input), quindi le variabili di solito non sono necessarie per usare un valore due volte.

Ad esempio, calcolare il valore medio di un array di numeri richiede alcuni
variabili nella maggior parte delle lingue - almeno una per contenere l'array, forse una per ogni elemento
o per un contatore di loop. In jq, è semplicemente aggiungere / lunghezza - il aggiungere l'espressione è data da
array e produce la sua somma, e il lunghezza all'espressione viene assegnato l'array e produce il suo
lunghezza.

Quindi, generalmente c'è un modo più pulito per risolvere la maggior parte dei problemi in jq rispetto alla definizione delle variabili.
Tuttavia, a volte semplificano le cose, quindi jq ti consente di definire le variabili usando
espressione as $ variabile. Tutti i nomi delle variabili iniziano con $. Ecco una versione leggermente più brutta
dell'esempio di media dell'array:

lunghezza come $array_length | aggiungi / $array_length

Avremo bisogno di un problema più complicato per trovare una situazione in cui utilizzare le variabili effettivamente
ci semplifica la vita.

Supponiamo di avere una serie di post del blog, con i campi "autore" e "titolo", e un altro
oggetto che viene utilizzato per mappare i nomi utente degli autori ai nomi reali. Il nostro input è simile a:

{"posts": [{"title": "Frist psot", "author": "anon"},
{"title": "Un articolo ben scritto", "author": "person1"}],
"realnames": {"anon": "Codardo anonimo",
"person1": "Persona McPherson"}}

Vogliamo produrre i post con il campo dell'autore contenente un nome reale, come in:

{"title": "Frist psot", "author": "Anonymous Coward"}
{"title": "Un articolo ben scritto", "author": "Persona McPherson"}

Usiamo una variabile, $names, per memorizzare l'oggetto realnames, in modo che possiamo farvi riferimento in seguito
quando si cercano i nomi utente degli autori:

.nomi reali come $nomi | .post[] | {titolo, autore: $nomi[.autore]}

L'espressione exp as $x | ... significa: per ogni valore di espressione exp, esegui il resto
la pipeline con l'intero input originale e con $x impostato su quel valore. così as
funziona come una sorta di ciclo foreach.

Come {pippo} è un modo pratico di scrivere {pippo: .foo}, Così {$pippo} è un modo pratico di scrivere
{pippo:$pippo}.

È possibile dichiarare più variabili utilizzando una sola as espressione fornendo un modello
che corrisponda alla struttura dell'input (questo è noto come "destrutturazione"):

. come {reali nomi: $nomi, post: [$primo, $secondo]} | ...

Le dichiarazioni delle variabili nei modelli di array (ad es. . as [$prima, $secondo]) si legano al
elementi dell'array dall'elemento all'indice zero in su, in ordine. Quando non c'è
valore all'indice per un elemento del modello di matrice, nullo è legato a quella variabile.

Le variabili hanno lo scope sul resto dell'espressione che le definisce, quindi

.nomi reali come $nomi | (.posts[] | {titolo, autore: $nomi[.autore]})

funzionerà, ma

(.realnames come $names | .posts[]) | {titolo, autore: $nomi[.autore]}

non lo farà.

Per i teorici del linguaggio di programmazione, è più accurato dire che le variabili jq sono
vincoli lessicali. In particolare non c'è modo di modificare il valore di un'associazione;
si può solo impostare una nuova associazione con lo stesso nome, ma che non sarà visibile dove
era quello vecchio.

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

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

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

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

Definizione funzioni
Puoi dare un nome a un filtro usando la sintassi "def":

def incremento: . + 1;

Da allora in poi, incremento è utilizzabile come filtro proprio come una funzione incorporata (in effetti, questo
è come sono definiti alcuni dei builtin). Una funzione può prendere argomenti:

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

Gli argomenti vengono passati come filtri, non come valori. Si può fare riferimento allo stesso argomento
più volte con input diversi (qui f viene eseguito per ogni elemento dell'array di input).
Gli argomenti per una funzione funzionano più come callback che come argomenti di valore. Questo è
importante capire. Tener conto di:

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

Il risultato sarà 20 perché f is .*2, e durante la prima invocazione di f . saranno 5,
e la seconda volta sarà 10 (5 * 2), quindi il risultato sarà 20. Argomenti della funzione
sono filtri e i filtri si aspettano un input quando vengono invocati.

Se vuoi il comportamento dell'argomento valore per definire funzioni semplici, puoi semplicemente usare a
variabili:

def valore aggiunto(f): f come $f | mappa(. + $f);

Oppure usa la stenografia:

def valore aggiunto($f): ...;

Con entrambe le definizioni, valore aggiunto (.foo) aggiungerà gli input correnti .pippo campo a ciascuno
elemento della matrice.

Sono consentite più definizioni che utilizzano lo stesso nome di funzione. Ogni ridefinizione sostituisce
la precedente per lo stesso numero di argomenti della funzione, ma solo per i riferimenti da
funzioni (o programma principale) successive alla ridefinizione.

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

jq ´def valore aggiunto(f): f come $x | mappa(. + $x); valore aggiunto(.[0])´
[[1,2], [10,20]]
=> [[1,2,1,2], [10,20,1,2]]

Riduce
I ridurre la sintassi in jq ti consente di combinare tutti i risultati di un'espressione con
accumulandoli in un'unica risposta. Ad esempio, passeremo , a questo
espressione:

riduci .[] come $elemento (0; . + $elemento)

Per ogni risultato che .[] produce, . + $oggetto viene eseguito per accumulare un totale parziale,
a partire da 0. In questo esempio, .[] produce i risultati 3, 2 e 1, quindi l'effetto è
simile all'esecuzione di qualcosa del genere:

0 | (3 come $elemento | . + $elemento) |
(2 come $elemento | . + $elemento) |
(1 come $elemento | . + $elemento)

jq ´riduci .[] come $elemento (0; . + $elemento)´
,
=> 20

limite(n; esp)
I limitare la funzione estrae fino a n uscite da exp.

jq ´[limite(3;.[])]´
,
=> [0,1,2]

prima (espr), ultimo(espr), ennesimo(n; espr)
I primo (espr) ed ultimo (espr) le funzioni estraggono il primo e l'ultimo valore da espr,
rispettivamente.

I ennesimo(n; espr) la funzione estrae l'ennesimo valore in uscita da espr. Questo può essere definito come
def ennesimo(n; espr): ultimo(limite(n + 1; espr));. Nota che ennesimo(n; espr) non supporta
valori negativi di n.

jq ´[primo(intervallo(.)), ultimo(intervallo(.)), nesimo(./2; intervallo(.))]´
10
=> [0,9,5]

primo, ultimo, ennesimo(n)
I prima di tutto ed ultimo le funzioni estraggono il primo e l'ultimo valore da qualsiasi array in ..

I ennesimo(n) la funzione estrae l'ennesimo valore di qualsiasi array in ..

jq ´[intervallo(.)]|[primo, ultimo, ennesimo(5)]´
10
=> [0,9,5]

foreach
I foreach la sintassi è simile a ridurre, ma destinato a consentire la costruzione di limitare
e riduttori che producono risultati intermedi (vedi esempio).

Il modulo è foreach EXP as $var (DENTRO; AGGIORNARE; ESTRATTO). Come ridurre, INIT viene valutato
una volta per produrre un valore di stato, quindi ogni uscita di EXP è vincolato a $var, AGGIORNAMENTO is
valutato per ogni output di EXP con lo stato attuale e con $var visibile. Ogni valore
prodotto da AGGIORNAMENTO sostituisce lo stato precedente. Finalmente, ESTRATTO viene valutato per ogni nuovo
stato per estrarre un output di foreach.

Questo è per lo più utile solo per la costruzione ridurre- E limitare-funzioni simili. Ma è
molto più generale, in quanto consente riduzioni parziali (vedi esempio sotto).

jq ´[foreach .[] as $item ([[],[]]; if $item == null allora [[],.[0]] else [(.[0] + [$item]),[ ]] end; if $item == null then .[1] else empty end)]´
[1,2,3,4,nullo,"a","b",nullo]
=> [[1,2,3,4],["a","b"]]

Ricorsione
Come descritto sopra, ricorso usa la ricorsione e qualsiasi funzione jq può essere ricorsiva. Il
while builtin è implementato anche in termini di ricorsione.

Le chiamate di coda sono ottimizzate ogni volta che l'espressione a sinistra degli output di chiamata ricorsiva
il suo ultimo valore. In pratica questo significa che l'espressione a sinistra della ricorsiva
la chiamata non dovrebbe produrre più di un output per ogni input.

Per esempio:

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

def while(cond; aggiornamento):
def _mentre:
if cond then ., (update | _while) else vuoto end;
_mentre;

def ripetizione (exp):
def _ripeti:
exp, _ripeti;
_ripetere;

Generatori ed iteratori
Alcuni operatori e funzioni jq sono in realtà generatori in quanto possono produrre zero,
uno o più valori per ogni input, proprio come ci si potrebbe aspettare in un'altra programmazione
lingue che hanno generatori. Per esempio, .[] genera tutti i valori nel suo input
(che deve essere un array o un oggetto), intervallo(0; 10) genera gli interi compresi tra 0 e
10, e così via.

Anche l'operatore virgola è un generatore, generando prima i valori generati dal
espressione a sinistra della virgola, quindi per ciascuna di esse, i valori generati da
espressione a destra della virgola.

I vuoto builtin è il generatore che produce zero output. Il vuoto incorporato
torna all'espressione generatrice precedente.

Tutte le funzioni jq possono essere generatori semplicemente utilizzando generatori incorporati. È anche possibile
per definire nuovi generatori usando solo la ricorsione e l'operatore virgola. Se il ricorsivo
call(s) is(are) "in tail position", allora il generatore sarà efficiente. Nell'esempio
sotto la chiamata ricorsiva di _gamma a se stesso è in posizione di coda. L'esempio si vede
tre argomenti avanzati: ricorsione in coda, costruzione del generatore e funzioni secondarie.

jq ´def range(init; upto; by): def _range: if (by > 0 and . < upto) or (by < 0 and . > upto) then ., ((.+by)|_range) else . fine; if by == 0 then init else init|_range end | select((di > 0 e . < fino a) o (di < 0 e . > fino a)); intervallo(0; 10; 3)´
nullo
=> 0, 3, 6, 9

jq ´def while(cond; update): def _while: if cond then ., (update | _while) else vuoto end; _mentre; [while(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

MATEMATICA

jq attualmente supporta solo numeri in virgola mobile a doppia precisione (754 bit) IEEE64.

Oltre a semplici operatori aritmetici come +, jq ha anche la maggior parte delle funzioni matematiche standard
dalla libreria di matematica C. Funzioni matematiche C che accettano un singolo argomento di input (ad es. senza ())
sono disponibili come funzioni jq senza argomenti. Funzioni matematiche C che accettano due input
argomenti (es. pow ()) sono disponibili come funzioni jq a due argomenti che ignorano ..

La disponibilità delle funzioni matematiche standard dipende dalla disponibilità del corrispondente
funzioni matematiche nel sistema operativo e nella libreria matematica C. Funzioni matematiche non disponibili
sarà definito ma genererà un errore.

I / O

In questo momento jq ha un supporto minimo per l'I/O, principalmente sotto forma di controllo su quando
gli ingressi vengono letti. Per questo sono fornite due funzioni integrate, ingresso ed Ingressi, che leggi
dalle stesse fonti (es. stdin, file denominati sulla riga di comando) come jq stesso. Queste
due builtin e le azioni di lettura di jq possono essere intercalati tra loro.

Un integrato fornisce capacità di output minime, mettere a punto. (Ricorda che un programma jq
i valori di output vengono sempre emessi come testi JSON attivi stdout.) Il mettere a punto built-in può avere
comportamento specifico dell'applicazione, come per gli eseguibili che utilizzano l'API C di libjq ma non lo sono
l'eseguibile jq stesso.

ingresso
Emette un nuovo input.

Ingressi
Emette tutti gli input rimanenti, uno per uno.

Ciò è utile principalmente per le riduzioni sugli input di un programma.

mettere a punto
Provoca la produzione di un messaggio di debug in base al valore di input. L'eseguibile jq si avvolge
il valore di input con ["DEBUG:", ] e stampa quello e una nuova riga su stderr,
compattamente. Questo potrebbe cambiare in futuro.

nome_file di input
Restituisce il nome del file il cui input è attualmente filtrato. Nota che questo sarà
non funziona bene a meno che jq non sia in esecuzione in una locale UTF-8.

input_line_number
Restituisce il numero di riga dell'input attualmente filtrato.

STREAMING

Grazie alla --flusso l'opzione jq può analizzare i testi di input in modalità streaming, consentendo jq
programmi per avviare l'elaborazione di testi JSON di grandi dimensioni immediatamente anziché dopo l'analisi
completa. Se disponi di un singolo testo JSON di 1 GB, lo streaming te lo consentirà
per elaborarlo molto più rapidamente.

Tuttavia, lo streaming non è facile da gestire come avrà il programma jq [ ,
] (e poche altre forme) come input.

Sono forniti diversi built-in per semplificare la gestione dei flussi.

Gli esempi seguenti utilizzano la forma in streaming di [0, [1]], Che ha
[[0],0],[[1,0],1],[[1,0]],[[1]].

I moduli di streaming includono [ , ] (per indicare qualsiasi valore scalare, array vuoto,
o oggetto vuoto), e [ ] (per indicare la fine di un array o di un oggetto). Futuro
versioni di jq eseguite con --flusso ed -seq può produrre moduli aggiuntivi come ["errore
Messaggio"] quando un testo di input non riesce ad analizzare.

troncare_stream(stream_expression)
Utilizza un numero come input e tronca il numero corrispondente di elementi del percorso da
a sinistra degli output dell'espressione di streaming data.

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

fromstream(espressione_stream)
Emette i valori corrispondenti agli output dell'espressione del flusso.

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

in streaming
I in streaming builtin emette la forma in streaming del suo input.

jq ´. come $punto|fromstream($punto|tostream)|.==$punto´
[0,[1,{"a":1},{"b":2}]]
=> vero

ASSEGNAZIONE

L'assegnazione funziona in modo leggermente diverso in jq rispetto alla maggior parte dei linguaggi di programmazione. jq non lo fa
distinguere tra riferimenti e copie di qualcosa: due oggetti o array sono
uguale o non uguale, senza alcuna ulteriore nozione di essere "lo stesso oggetto" o "non
lo stesso oggetto”.

Se un oggetto ha due campi che sono array, .pippo ed .sbarra, e aggiungi qualcosa a
.pippo, poi .sbarra non diventerà più grande. Anche se hai appena impostato .sbarra = .pippo. Se sei abituato
alla programmazione in linguaggi come Python, Java, Ruby, Javascript, ecc. allora puoi pensare
di esso come se jq facesse una copia profonda completa di ogni oggetto prima di eseguire l'assegnazione
(per le prestazioni, in realtà non lo fa, ma questa è l'idea generale).

Tutti gli operatori di assegnazione in jq hanno espressioni di percorso sul lato sinistro.

=
Il filtro .pippo = 1 prenderà come input un oggetto e produrrà come output un oggetto con il
Campo "pippo" impostato su 1. Non c'è alcuna nozione di "modifica" o "cambiamento" di qualcosa in jq -
tutti i valori jq sono immutabili. Ad esempio,

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

non avrà l'effetto collaterale di impostare .bar.baz su 1, in quanto dall'aspetto simile
programma in Javascript, Python, Ruby o altri linguaggi. A differenza di queste lingue (ma
come Haskell e alcuni altri linguaggi funzionali), non vi è alcuna nozione di due array o
gli oggetti sono "lo stesso array" o "lo stesso oggetto". Possono essere uguali o non uguali, ma
se cambiamo uno di loro in nessun caso cambierà l'altro alle nostre spalle.

Ciò significa che è impossibile costruire valori circolari in jq (come un array il cui
il primo elemento è se stesso). Questo è abbastanza intenzionale e garantisce che qualsiasi cosa sia un jq
programma può produrre può essere rappresentato in JSON.

Nota che il lato sinistro di ´=´ si riferisce a un valore in .. così $var.pippo = 1 non funzionerà
come previsto ($var.pippo non è un'espressione di percorso valida o utile in .); utilizzo $var | .pippo = 1
anziché.

Se il lato destro di ´=´ produce più valori, allora per ciascuno di questi valori jq sarà
imposta i percorsi sul lato sinistro al valore e quindi emetterà il modificato ..
Per esempio, (.a,.b)=gamma(2) uscite {"a":0,"b":0}, poi {"a":1,"b":1}. L'aggiornamento"
i moduli di assegnazione (vedi sotto) non lo fanno.

Nota anche quello .a,.b=0 non si imposta .a ed .b, ma (.a,.b)=0 imposta entrambi.

|=
Oltre all'operatore di assegnazione ´=´, jq fornisce l'operatore di "aggiornamento" ´|=´, che
prende un filtro sul lato destro e calcola il nuovo valore per la proprietà di .
essere assegnato a eseguendo il vecchio valore tramite questa espressione. Ad esempio, .foo |=
.+1 costruirà un oggetto con il campo "pippo" impostato sull'input "pippo" più 1.

Questo esempio dovrebbe mostrare la differenza tra ´=´ e ´|=´:

Fornire l'input ´{"a": {"b": 10}, "b": 20}´ ai programmi:

.a = .b .a |= .b

Il primo imposterà il campo "a" dell'input al campo "b" dell'input e produrrà
l'output {"a": 20}. Quest'ultimo imposterà il campo "a" dell'input al campo "a"
campo "b", producendo {"a": 10}.

Il lato sinistro può essere qualsiasi espressione di percorso generale; vedere il percorso().

Nota che il lato sinistro di ´|=´ si riferisce a un valore in .. così $var.pippo |= . + 1 non voglio
funzionare come previsto ($var.pippo non è un'espressione di percorso valida o utile in .); utilizzo $var | .pippo
|= . + 1 anziché.

Se il lato destro emette più valori, verrà utilizzato solo l'ultimo.

jq ´(..|select(type=="boolean")) |= if . poi 1 altro 0 end´
[vero,falso,[5,vero,[vero,[falso]],falso]]
=> [1,0,[5,1,[1,[0]],0]]

+=, -=, *=, /=, %=, // =
jq ha alcuni operatori della forma a op= b, che sono tutti equivalenti a a |= . op b. Così,
+= 1 può essere utilizzato per incrementare i valori.

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

Complesso assegnazioni
Sono consentite molte più cose sul lato sinistro di un compito jq rispetto alla maggior parte
le lingue. Abbiamo già visto semplici accessi al campo sul lato sinistro, ed è no
sorprende che gli accessi all'array funzionino altrettanto bene:

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

Ciò che può sorprendere è che l'espressione a sinistra può produrre più
risultati, facendo riferimento a diversi punti del documento di input:

.post[].commenti |= . + ["è fantastico"]

Quell'esempio aggiunge la stringa "questo è fantastico" all'array "commenti" di ogni post in
l'input (dove l'input è un oggetto con un campo "post" che è un array di post).

Quando jq incontra un'assegnazione come ´a = b´, registra il "percorso" preso per selezionare a
parte del documento di input durante l'esecuzione a. Questo percorso viene quindi utilizzato per trovare quale parte di
l'input da modificare durante l'esecuzione dell'assegnazione. Qualsiasi filtro può essere utilizzato sul
lato sinistro di un uguale - qualunque percorso selezioni dall'input sarà dove il
l'incarico viene eseguito.

Questa è un'operazione molto potente. Supponiamo di voler aggiungere un commento ai post del blog, usando
lo stesso input "blog" sopra. Questa volta vogliamo solo commentare i post scritti da
"stedola". Possiamo trovare quei post usando la funzione "seleziona" descritta in precedenza:

.post[] | select(.autore == "stedolan")

I percorsi forniti da questa operazione puntano a ciascuno dei post che "stedolan" ha scritto, e
possiamo commentare ciascuno di essi nello stesso modo in cui lo facevamo prima:

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

MODULI

jq ha un sistema di librerie/moduli. I moduli sono file i cui nomi finiscono con .jq.

I moduli importati da un programma vengono cercati in un percorso di ricerca predefinito (vedi sotto). Il
importare ed includere le direttive consentono all'importatore di modificare questo percorso.

I percorsi in un percorso di ricerca sono soggetti a varie sostituzioni.

Per i percorsi che iniziano con "~/", la directory home dell'utente viene sostituita da "~".

Per i percorsi che iniziano con "$ORIGIN/", il percorso dell'eseguibile jq viene sostituito da
"$ORIGINE".

Per i percorsi che iniziano con "./" o i percorsi che sono ".", il percorso del file incluso è
sostituito da ".". Per i programmi di primo livello forniti dalla riga di comando, il corrente
viene utilizzata la directory.

Le direttive di importazione possono facoltativamente specificare un percorso di ricerca a cui viene aggiunto il valore predefinito.

Il percorso di ricerca predefinito è il percorso di ricerca assegnato al -L opzione della riga di comando, altrimenti
["~/.jq", "$ORIGIN/../lib/jq", "$ORIGINE/../ lib"].

Gli elementi del percorso di stringa null e vuoti interrompono l'elaborazione del percorso di ricerca.

Una dipendenza con percorso relativo "foo/bar" verrebbe cercata in "foo/bar.jq" e
"foo/bar/bar.jq" nel percorso di ricerca indicato. Questo ha lo scopo di consentire il posizionamento dei moduli
in una directory insieme, ad esempio, ai file di controllo della versione, ai file README e così via,
ma anche per consentire moduli a file singolo.

I componenti consecutivi con lo stesso nome non sono consentiti per evitare ambiguità (ad es.
"pippo/pippo").

Ad esempio, con -L$CASA/.jq un modulo foo può essere trovato in $HOME/.jq/pippo.jq ed
$HOME/.jq/pippo/pippo.jq.

Se "$HOME/.jq" è un file, viene prelevato dal programma principale.

importare StringaPercorsoRelativo as NOME [ ];
Importa un modulo trovato nel percorso specificato rispetto a una directory in un percorso di ricerca. Un ".jq"
il suffisso verrà aggiunto alla stringa del percorso relativo. I simboli dei moduli sono preceduti da
"NOME::".

I metadati facoltativi devono essere un'espressione jq costante. Dovrebbe essere un oggetto con le chiavi
come "home page" e così via. In questo momento jq usa solo la chiave/valore "cerca" di
metadati. I metadati sono messi a disposizione degli utenti anche tramite il modulometa incorporato.

La chiave "cerca" nei metadati, se presente, dovrebbe avere un valore stringa o array (array
di stringhe); questo è il percorso di ricerca da anteporre al percorso di ricerca di livello superiore.

includere StringaPercorsoRelativo [ ];
Importa un modulo trovato nel percorso indicato rispetto a una directory in un percorso di ricerca come se fosse
sono stati inseriti in sede. Verrà aggiunto un suffisso ".jq" alla stringa del percorso relativo. Il
i simboli del modulo vengono importati nello spazio dei nomi del chiamante come se il contenuto del modulo avesse
stato incluso direttamente.

I metadati facoltativi devono essere un'espressione jq costante. Dovrebbe essere un oggetto con le chiavi
come "home page" e così via. In questo momento jq usa solo la chiave/valore "cerca" di
metadati. I metadati sono messi a disposizione degli utenti anche tramite il modulometa incorporato.

importare StringaPercorsoRelativo as $NOME [ ];
Importa un file JSON trovato nel percorso specificato rispetto a una directory in un percorso di ricerca. UN
Il suffisso ".json" verrà aggiunto alla stringa del percorso relativo. I dati del file saranno
disponibile come $NOME::NOME.

I metadati facoltativi devono essere un'espressione jq costante. Dovrebbe essere un oggetto con le chiavi
come "home page" e così via. In questo momento jq usa solo la chiave/valore "cerca" di
metadati. I metadati sono messi a disposizione degli utenti anche tramite il modulometa incorporato.

La chiave "cerca" nei metadati, se presente, dovrebbe avere un valore stringa o array (array
di stringhe); questo è il percorso di ricerca da anteporre al percorso di ricerca di livello superiore.

modulo ;
Questa direttiva è del tutto facoltativa. Non è necessario per il corretto funzionamento. Serve
solo allo scopo di fornire metadati che possono essere letti con il modulometa incorporato.

I metadati devono essere un'espressione jq costante. Dovrebbe essere un oggetto con chiavi come
"home page". Al momento jq non utilizza questi metadati, ma è reso disponibile agli utenti
tramite modulometa incorporato.

modulometa
Prende il nome di un modulo come input ed emette i metadati del modulo come oggetto, con il
le importazioni del modulo (inclusi i metadati) come valore dell'array per la chiave "deps".

I programmi possono usarlo per interrogare i metadati di un modulo, che potrebbero quindi utilizzare per, per
ad esempio, cerca, scarica e installa le dipendenze mancanti.

Usa jq online utilizzando i servizi onworks.net