jq - En ligne dans le Cloud

PROGRAMME:

Nom

jq - Processeur JSON en ligne de commande

SYNOPSIS

jq [Options...] une fonction filtre [fichiers...]

jq peut transformer JSON de diverses manières, en sélectionnant, itérant, réduisant et autrement
déformer les documents JSON. Par exemple, en exécutant la commande jq ´carte(.prix) | ajouter sera
prendre un tableau d'objets JSON en entrée et renvoyer la somme de leurs champs "prix".

jq peut également accepter la saisie de texte, mais par défaut, jq lit un flux d'entités JSON
(y compris les nombres et autres littéraux) de Stdin. L'espace blanc n'est nécessaire que pour séparer
entités telles que 1 et 2, et vrai et faux. Un ou plus fichiers peut être spécifié, dans lequel
maisons jq liront les entrées de ceux-ci à la place.

La Options sont décrits dans le INVOQUER JQ section; ils concernent principalement les entrées et les sorties
mise en page. le une fonction filtre est écrit en langage jq et précise comment transformer le
fichier ou document d'entrée.

FILTRES

Un programme jq est un "filtre" : il prend une entrée et produit une sortie. Il y a beaucoup de
filtres intégrés pour extraire un champ particulier d'un objet ou convertir un nombre en
une chaîne ou diverses autres tâches standard.

Les filtres peuvent être combinés de différentes manières - vous pouvez diriger la sortie d'un filtre vers
un autre filtre, ou collecter la sortie d'un filtre dans un tableau.

Certains filtres produisent plusieurs résultats, par exemple il y en a un qui produit tous les
éléments de son tableau d'entrée. La canalisation de ce filtre dans un deuxième exécute le deuxième filtre pour
chaque élément du tableau. Généralement, les choses qui seraient faites avec des boucles et des itérations
dans d'autres langues, il suffit de coller des filtres ensemble dans jq.

Il est important de se rappeler que chaque filtre a une entrée et une sortie. Même les littéraux
comme "hello" ou 42 sont des filtres - ils prennent une entrée mais produisent toujours le même littéral que
sortir. Les opérations qui combinent deux filtres, comme l'addition, alimentent généralement la même entrée
aux deux et combiner les résultats. Ainsi, vous pouvez implémenter un filtre de moyenne comme ajouter / longueur
- alimenter le tableau d'entrée à la fois vers le ajouter filtre et le longueur filtrer puis effectuer
la division.

Mais cela nous dépasse. :) Commençons par quelque chose de plus simple :

INVOQUER JQ

les filtres jq s'exécutent sur un flux de données JSON. L'entrée de jq est analysée comme une séquence de
valeurs JSON séparées par des espaces qui sont passées à travers le filtre fourni un à un
temps. La ou les sorties du filtre sont écrites sur la sortie standard, encore une fois sous la forme d'une séquence de
données JSON séparées par des espaces.

Remarque : il est important de respecter les règles de citation du shell. En règle générale, il est préférable de
citer toujours (avec des guillemets simples) le programme jq, car trop de caractères avec
une signification particulière de jq sont également des méta-caractères du shell. Par exemple, jq "toto" échouera le
la plupart des shells Unix car ce sera la même chose que jq foo, qui échouera généralement
car foo is ne sauraient défini. Lorsque vous utilisez le shell de commande Windows (cmd.exe), il est préférable de
utilisez des guillemets doubles autour de votre programme jq lorsqu'il est donné sur la ligne de commande (au lieu du -f
fichier-programme option), mais les guillemets doubles dans le programme jq doivent s'échapper par une barre oblique inverse.

Vous pouvez affecter la façon dont jq lit et écrit ses entrées et sorties à l'aide d'une ligne de commande
options:

· --version:

Sortez la version jq et quittez avec zéro.

· --séq:

Utilisez l'option application/json-seq Schéma de type MIME pour séparer les textes JSON dans l'entrée de jq
et sortie. Cela signifie qu'un caractère ASCII RS (séparateur d'enregistrements) est imprimé avant
chaque valeur en sortie et un ASCII LF (saut de ligne) est imprimé après chaque sortie. Saisir
Les textes JSON qui ne parviennent pas à être analysés sont ignorés (mais avertis), éliminant tous
entrée suivante jusqu'à la prochaine RS. Cela analyse plus également la sortie de jq sans le
--séq option.

· --flux:

Analyser l'entrée en mode streaming, produisant des tableaux de valeurs de chemin et de feuille
(scalaires et tableaux vides ou objets vides). Par exemple, "une" devient [[],"une"]et
[[],"un B"]] devient [[0],[]], [[1],"un"]et [[1,0],"b"].

Ceci est utile pour le traitement d'entrées très volumineuses. Utilisez-le en conjonction avec
filtrage et le réduire ainsi que foreach syntaxe pour réduire les entrées volumineuses de manière incrémentielle.

· --slurp/-s:

Au lieu d'exécuter le filtre pour chaque objet JSON dans l'entrée, lisez l'intégralité de l'entrée
diffuser dans un grand tableau et exécuter le filtre une seule fois.

· --entrée brute/-R:

N'analysez pas l'entrée en tant que JSON. Au lieu de cela, chaque ligne de texte est transmise au filtre en tant que
chaîne de caractères. Si combiné avec --slurp, alors la totalité de l'entrée est transmise au filtre en tant que
longue chaîne unique.

· --null-entrée/-n:

Ne lisez aucune entrée ! Au lieu de cela, le filtre est exécuté une fois en utilisant nul comme entrée.
Ceci est utile lorsque vous utilisez jq comme simple calculatrice ou pour construire des données JSON à partir de
rayure.

· --sortie compacte / -c:

Par défaut, jq jolie-imprime la sortie JSON. L'utilisation de cette option se traduira par plus
sortie compacte en mettant à la place chaque objet JSON sur une seule ligne.

· --languette:

Utilisez une tabulation pour chaque niveau d'indentation au lieu de deux espaces.

· --indentation n:

Utilisez le nombre d'espaces donné (pas plus de 8) pour l'indentation.

· --couleur-sortie / -C ainsi que --monochrome-sortie / -M:

Par défaut, jq génère un JSON coloré si vous écrivez dans un terminal. Vous pouvez le forcer à
produire de la couleur même si vous écrivez dans un tube ou un fichier en utilisant -C, et désactivez la couleur avec -M.

· --ascii-sortie / -a:

jq génère généralement des points de code Unicode non ASCII au format UTF-8, même si l'entrée spécifiée
en tant que séquences d'échappement (comme "\u03bc"). En utilisant cette option, vous pouvez forcer jq à
produire une sortie ASCII pure avec chaque caractère non ASCII remplacé par l'équivalent
séquence d'échappement.

· --sans tampon

Videz la sortie après l'impression de chaque objet JSON (utile si vous
source de données dans jq et canaliser la sortie de jq ailleurs).

· --clés-de-tri / -S:

Sortez les champs de chaque objet avec les clés dans l'ordre trié.

· --sortie brute / -r:

Avec cette option, si le résultat du filtre est une chaîne alors il sera écrit directement
à la sortie standard plutôt que d'être formaté comme une chaîne JSON avec des guillemets. Ceci peut
être utile pour faire parler les filtres jq avec des systèmes non basés sur JSON.

· --join-sortie / -j:

Comme -r mais jq n'imprimera pas de nouvelle ligne après chaque sortie.

· -f nom de fichier / --from-fichier nom de fichier:

Lire le filtre à partir du fichier plutôt qu'à partir d'une ligne de commande, comme l'option -f d'awk. Tu
pouvez également utiliser ´#´ pour faire des commentaires.

· -Lrépertoire / -L annuaire:

Préfixer annuaire à la liste de recherche de modules. Si cette option est utilisée, alors non
la liste de recherche intégrée est utilisée. Voir la section sur les modules ci-dessous.

· -e / --exit-statut:

Définit l'état de sortie de jq à 0 si les dernières valeurs de sortie n'étaient ni l'un ni l'autre non ni nul,
1 si la dernière valeur de sortie était soit non or nul, ou 4 si aucun résultat valide n'a jamais été
produit. Normalement, jq quitte avec 2 s'il y a eu un problème d'utilisation ou une erreur système, 3
s'il y a eu une erreur de compilation du programme jq, ou 0 si le programme jq s'est exécuté.

· --arg prénom Plus-value:

Cette option transmet une valeur au programme jq en tant que variable prédéfinie. Si tu lances jq
avec --arg foo barre, puis $foo est disponible dans le programme et a la valeur "bar".
Notez que Plus-value sera traité comme une chaîne, donc --arg foo 123 va lier $foo à "123".

· --argjson prénom JSON-texte:

Cette option transmet une valeur codée JSON au programme jq en tant que variable prédéfinie. Si
tu lances jq avec --argjson foo 123, puis $foo est disponible dans le programme et a le
Plus-value 123.

· --slurpfile Nom de variable nom de fichier:

Cette option lit tous les textes JSON dans le fichier nommé et lie un tableau des
les valeurs JSON analysées à la variable globale donnée. Si vous exécutez jq avec --argfile foo barre,
puis $foo est disponible dans le programme et possède un tableau dont les éléments correspondent à
les textes dans le fichier nommé barre.

· --argfile Nom de variable nom de fichier:

Ne pas utiliser. Utilisation --slurpfile à la place.

(Cette option est comme --slurpfile, mais lorsque le fichier n'a qu'un seul texte, alors c'est
utilisé, sinon un tableau de textes est utilisé comme dans --slurpfile.)

· --run-tests [nom de fichier]:

Exécute les tests dans le fichier donné ou l'entrée standard. Cela doit être la dernière option donnée
et n'honore pas toutes les options précédentes. L'entrée se compose de lignes de commentaires, vides
lignes et lignes de programme suivies d'une ligne d'entrée, autant de lignes de sortie qu'il y en a
attendu (un par sortie) et une ligne vide de fin. Tests d'échec de compilation
commencer par une ligne contenant uniquement "%%FAIL", puis une ligne contenant le programme à
compiler, puis une ligne contenant un message d'erreur à comparer au réel.

Soyez averti que cette option peut changer vers l'arrière de manière incompatible.

BASIQUE FILTRES

.
Le filtre le plus simple (et le moins intéressant) est .. C'est un filtre qui prend son
entrée et le produit inchangé en sortie.

Puisque jq par défaut affiche joliment toutes les sorties, ce programme trivial peut être un moyen utile de
formatage de la sortie JSON à partir, disons, boucle.

jq ´.´
"Bonjour le monde!"
=> "Bonjour tout le monde !"

.foo, .foo.bar
Le plus simple incontournable le filtre est .foo. Lorsqu'on lui donne un objet JSON (alias dictionnaire ou hachage) en tant que
input, il produit la valeur à la clé "foo", ou null s'il n'y en a pas.

Si la clé contient des caractères spéciaux, vous devez l'entourer de guillemets doubles comme
ce: ."foo$".

Un filtre de la forme .foo.bar équivaut à .foo|.bar.

jq '.foo'
{"foo": 42, "bar": "données moins intéressantes"}
=> 42

jq '.foo'
{"notfoo": vrai, "aussinotfoo": false}
=> nul

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

.foo ?
Tout comme .foo, mais ne génère même pas d'erreur lorsque . n'est pas un tableau ou un objet.

jq '.foo?'
{"foo": 42, "bar": "données moins intéressantes"}
=> 42

jq '.foo?'
{"notfoo": vrai, "aussinotfoo": false}
=> nul

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

jq '[.foo?]'

=> []

.[ ], .[2], .[10:15]
Vous pouvez également rechercher les champs d'un objet en utilisant une syntaxe telle que .["toto"] (.foo ci-dessus est un
version abrégée de ceci). Celui-ci fonctionne également pour les tableaux, si la clé est un entier.
Les tableaux sont basés sur zéro (comme javascript), donc . [2] renvoie le troisième élément du tableau.

La .[10:15] La syntaxe peut être utilisée pour renvoyer un sous-tableau d'un tableau ou une sous-chaîne d'une chaîne.
Le tableau renvoyé par .[10:15] sera de longueur 5, contenant les éléments de l'index 10
(inclus) à l'indice 15 (exclusif). L'un ou l'autre des indices peut être négatif (auquel cas il compte
en arrière à partir de la fin du tableau), ou omis (auquel cas il fait référence au début ou
fin du tableau).

La . [2] La syntaxe peut être utilisée pour renvoyer l'élément à l'index donné. Les indices négatifs sont
autorisé, avec -1 faisant référence au dernier élément, -2 faisant référence à l'avant-dernier élément,
etc.

La .foo la syntaxe ne fonctionne que pour les clés simples, c'est-à-dire les clés qui sont toutes des caractères alphanumériques.
.[ ] fonctionne avec des touches contenant des caractères spéciaux tels que des deux points et des points. Pour
exemple .["toto::bar"] ainsi que .["foo.bar"] travailler pendant que .foo :: bar ainsi que .foo.bar ne le ferait pas.

La ? "operator" peut également être utilisé avec l'opérateur slice, comme dans .[10:15] ?, qui sort
valeurs où les entrées peuvent être découpées.

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

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

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

.[]
Si vous utilisez le .[indice] syntaxe, mais omettez complètement l'index, il renverra TOUTE des
éléments d'un tableau. Fonctionnement .[] avec l'entrée produira les nombres comme trois
résultats séparés, plutôt que comme un seul tableau.

Vous pouvez également l'utiliser sur un objet, et il renverra toutes les valeurs de l'objet.

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

.[] ?
Comme .[], mais aucune erreur ne sera générée si . n'est pas un tableau ou un objet.

,
Si deux filtres sont séparés par une virgule, alors l'entrée sera introduite dans les deux et là
sera des sorties multiples : d'abord, toutes les sorties produites par l'expression de gauche, et
puis toutes les sorties produites par la droite. Par exemple, filtrez .foo, .Café, produit
les champs "foo" et "bar" en tant que sorties séparées.

jq '.foo, .bar'
{"foo": 42, "bar": "quelque chose d'autre", "baz": true}
=> 42, "autre chose"

jq '.user, .projects[]'
{"user":"stedolan", "projects": ["jq", "wikiflow"]}
=> "stedolan", "jq", "wikiflow"

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

|
Le | l'opérateur combine deux filtres en alimentant la ou les sorties de celui de gauche dans
l'entrée de celui de droite. C'est à peu près la même chose que le tuyau du shell Unix, si
vous êtes habitué à ça.

Si celui de gauche produit plusieurs résultats, celui de droite sera exécuté pendant
chacun de ces résultats. Ainsi, l'expression .[] | .foo récupère le champ "foo" de chaque
élément du tableau d'entrée.

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

TYPES ET VALEURS

jq prend en charge le même ensemble de types de données que JSON - nombres, chaînes, booléens, tableaux,
objets (qui, en langage JSON, sont des hachages avec uniquement des clés de chaîne) et "null".

Les booléens, null, les chaînes et les nombres s'écrivent de la même manière qu'en javascript. Juste comme
tout le reste dans jq, ces valeurs simples prennent une entrée et produisent une sortie - 42 est une
expression jq valide qui prend une entrée, l'ignore et renvoie 42 à la place.

tableau construction - []
Comme en JSON, [] est utilisé pour construire des tableaux, comme dans . Les éléments des tableaux peuvent
être n'importe quelle expression jq. Tous les résultats produits par toutes les expressions sont collectés
dans un grand tableau. Vous pouvez l'utiliser pour construire un tableau à partir d'une quantité connue de valeurs
(Comme dans l' [.foo, .bar, .baz]) ou de "collecter" tous les résultats d'un filtre dans un tableau (comme
in [.items[].nom])

Une fois que vous avez compris l'opérateur ",", vous pouvez regarder la syntaxe du tableau de jq dans un autre
lumière : l'expression n'utilise pas de syntaxe intégrée pour les tableaux séparés par des virgules,
mais applique plutôt le [] opérateur (collecte des résultats) à l'expression 1,2,3 (qui
produit trois résultats différents).

Si vous avez un filtre X qui produit quatre résultats, alors l'expression [X] produira un
résultat unique, un tableau de quatre éléments.

jq '[.utilisateur, .projets[]]'
{"user":"stedolan", "projects": ["jq", "wikiflow"]}
=> ["stedolan", "jq", "wikiflow"]

Objets - {}
Comme JSON, {} est pour la construction d'objets (alias dictionnaires ou hachages), comme dans : {"une": 42
"b": 17}.

Si les touches sont "sensibles" (tous les caractères alphabétiques), alors les guillemets peuvent être omis.
La valeur peut être n'importe quelle expression (bien que vous deviez peut-être l'envelopper entre parenthèses s'il s'agit d'une
compliqué), qui est appliqué à l'entrée de l'expression {} (rappelez-vous, tous les filtres
avoir une entrée et une sortie).

{foo : .bar}

produira l'objet JSON {"toto": 42} si on lui donne l'objet JSON {"bar":42, "baz":43}.
Vous pouvez l'utiliser pour sélectionner des champs particuliers d'un objet : si l'entrée est un objet avec
les champs "user", "title", "id" et "content" et vous voulez juste "user" et "title", vous pouvez
écrire

{utilisateur : .user, titre : .title}

Parce que c'est si courant, il y a une syntaxe de raccourci : {utilisateur, Titre}.

Si l'une des expressions produit plusieurs résultats, plusieurs dictionnaires seront
produit. Si l'entrée est

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

alors l'expression

{utilisateur, titre : .titles[]}

produira deux sorties :

{"user":"stedolan", "title": "JQ Primer"}
{"user":"stedolan", "title": "Plus de JQ"}

Mettre des parenthèses autour de la clé signifie qu'elle sera évaluée comme une expression. Avec le
même entrée que ci-dessus,

{(.user): .titres}

produit

{"stedolan": ["Amorce JQ", "Plus de JQ"]}

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

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

BÂTI LES OPÉRATEURS ET FONCTIONS

Certains opérateurs jq (par exemple, +) font des choses différentes selon le type de leur
arguments (tableaux, nombres, etc.). Cependant, jq ne fait jamais de conversions de types implicites. Si
vous essayez d'ajouter une chaîne à un objet, vous obtiendrez un message d'erreur et aucun résultat.

Addition - +
L'opérateur + prend deux filtres, les applique tous les deux à la même entrée et ajoute le
résultats ensemble. Ce que signifie « ajouter » dépend des types impliqués :

· Nombres sont additionnés par l'arithmétique normale.

· Arrays sont ajoutés en étant concaténés dans un tableau plus grand.

· String sont ajoutés en étant joints dans une chaîne plus grande.

· Objets sont ajoutés par fusion, c'est-à-dire en insérant toutes les paires clé-valeur des deux
objets en un seul objet combiné. Si les deux objets contiennent une valeur pour le même
clé, l'objet à droite de la + gagne. (Pour la fusion récursive, utilisez le * opérateur.)

nul peut être ajouté à n'importe quelle valeur et renvoie l'autre valeur inchangée.

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

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

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

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

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

Soustraction - -
En plus de la soustraction arithmétique normale sur les nombres, la - l'opérateur peut être utilisé sur les tableaux
pour supprimer toutes les occurrences des éléments du deuxième tableau du premier tableau.

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

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

Multiplication, division, forme - *, /, ainsi que %
Ces opérateurs infixes se comportent comme prévu lorsqu'on leur donne deux nombres. Division par zéro relance
une erreur. x % y calcule x modulo y.

La multiplication d'une chaîne par un nombre produit la concaténation de cette chaîne que plusieurs
fois. "X" * 0 produit nul.

Diviser une chaîne par une autre divise la première en utilisant la seconde comme séparateur.

Multiplier deux objets les fusionnera récursivement : cela fonctionne comme l'addition mais si les deux
les objets contiennent une valeur pour la même clé, et les valeurs sont des objets, les deux sont fusionnés
avec la même stratégie.

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

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

longueur
La fonction intégrée longueur obtient la longueur de différents types de valeurs :

· La longueur d'un un magnifique est le nombre de points de code Unicode qu'il contient (qui sera
la même que sa longueur codée en JSON en octets s'il s'agit d'ASCII pur).

· La longueur d'un tableau est le nombre d'éléments.

· La longueur d'un objet est le nombre de paires clé-valeur.

· La longueur de nul est zéro.

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

touches, clés_non triées
La fonction intégrée clés, lorsqu'on lui donne un objet, renvoie ses clés dans un tableau.

Les clés sont triées "par ordre alphabétique", par ordre de point de code unicode. Ceci n'est pas une commande
cela a un sens particulier dans n'importe quelle langue, mais vous pouvez compter que c'est le
même chose pour deux objets avec le même jeu de clés, quels que soient les paramètres régionaux.

Quand clés reçoit un tableau, il renvoie les indices valides pour ce tableau : les entiers
de 0 à longueur-1.

La clés_non triées la fonction est comme clés, mais si l'entrée est un objet alors les touches
ne seront pas triés, à la place les clés seront à peu près dans l'ordre d'insertion.

jq « clés »
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["Foo", "abc", "abcd"]

jq « clés »

=> [0,1,2]

a (clé)
La fonction intégrée a renvoie si l'objet d'entrée a la clé donnée, ou l'entrée
array a un élément à l'index donné.

a($clé) a le même effet que de vérifier si $clé est un membre du tableau renvoyé
by clés, Bien que a sera plus rapide.

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

jq ´carte(a(2))´
[[0,1], ["a","b","c"]]
=> [faux, vrai]

in
La fonction intégrée in renvoie la clé d'entrée est dans l'objet donné, ou l'index d'entrée
correspond à un élément du tableau donné. Il s'agit essentiellement d'une version inversée de
a.

jq ´.[] | dans({"foo": 42})´
["foo", "bar"]
=> vrai, faux

jq ´map(dans([0,1]))´
[2, 0]
=> [faux, vrai]

chemin(expression_chemin)
Affiche des représentations matricielles de l'expression de chemin donnée dans .. Les sorties sont des tableaux de
chaînes (clés dans objects0 et/ou nombres (indices de tableau.

Les expressions de chemin sont des expressions jq comme .aMais c'est aussi .[]. Il existe deux types de chemin
expressions : celles qui peuvent correspondre exactement et celles qui ne le peuvent pas. Par exemple, .abc est un
expression de chemin de correspondance exacte, tandis que .un B n'est pas.

chemin (expression_chemin_exact) produira la représentation matricielle de l'expression du chemin
même s'il n'existe pas dans ., Si . is nul ou un tableau ou un objet.

chemin (motif) produira des représentations matricielles des chemins correspondant modèle si le
des chemins existent dans ..

Notez que les expressions de chemin ne sont pas différentes des expressions normales. L'expression
chemin(..|select(type=="boolean")) affiche tous les chemins vers les valeurs booléennes dans ., et seulement
ces chemins.

jq 'chemin(.a[0].b)'
nul
=> ["a",0,"b"]

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

del(expression_chemin)
La fonction intégrée de la supprime une clé et sa valeur correspondante d'un objet.

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

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

aux_entrées, de_entrées, avec_entrées
Ces fonctions convertissent entre un objet et un tableau de paires clé-valeur. Si to_entries
est passé un objet, puis pour chaque k: v entrée dans l'entrée, le tableau de sortie comprend
{"clé": k, "valeur": v}.

de_entrées fait la conversion inverse, et avec_entrées(foo) est un raccourci pour
to_entries | carte (toto) | de_entrées, utile pour effectuer des opérations sur toutes les touches et
valeurs d'un objet. de_entrées accepte la clé, la clé, le nom, la valeur et la valeur comme clés.

jq 'vers_entrées'
{"a": 1, "b": 2}
=> [{"key":"a", "value":1}, {"key":"b", "value":2}]

jq 'de_entrées'
[{"key":"a", "value":1}, {"key":"b", "value":2}]
=> {"a": 1, "b": 2}

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

select(expression_booléenne)
La fonction sélectionner (toto) produit son entrée inchangée si foo renvoie vrai pour cette entrée,
et ne produit aucune sortie autrement.

C'est utile pour filtrer les listes : | carte(sélectionner(. >= 2)) te donnera .

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

=> [5,3,7]

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

tableaux, objets, itérables, booléens, Nombres, normales, finis, cordes, nuls, valeurs,
scalaires
Ces éléments intégrés sélectionnent uniquement les entrées qui sont des tableaux, des objets, des itérables (tableaux ou
objets), booléens, nombres, nombres normaux, nombres finis, chaînes, null, non null
valeurs et non itérables, respectivement.

jq ´.[]|nombres´
[[],{},1,"foo",null,true,false]
=> 1

vide
vide ne renvoie aucun résultat. Pas du tout. Pas même nul.

C'est utile à l'occasion. Vous saurez si vous en avez besoin :)

jq '1, vide, 2'
nul
=> 1, 2

jq '[1,2,vide,3]'
nul
=> [1,2,3]

erreur(un message)
Produit une erreur, tout comme .a appliqué aux valeurs autres que null et les objets le feraient, mais
avec le message donné comme valeur d'erreur.

$__loc__
Produit un objet avec une clé "fichier" et une clé "ligne", avec le nom du fichier et le numéro de ligne
De $__loc__ se produit, en tant que valeurs.

jq ´essayez error("\($__loc__)") catch .´
nul
=> "{\"fichier\":\" \",\"ligne 1}"

carte(x), map_values(x)
Pour tout filtre x, carte(x) exécutera ce filtre pour chaque élément du tableau d'entrée, et
produire les sorties un nouveau tableau. carte(.+1) incrémentera chaque élément d'un tableau de
chiffres.

De même, le map_values(x) exécutera ce filtre pour chaque élément, mais il renverra un
objet lorsqu'un objet est passé.

carte(x) équivaut à [.[] | x]. En fait, c'est ainsi que cela se définit. De la même manière,
map_values(x) est défini comme étant .[] |= x.

jq 'carte(.+1)'

=> [2,3,4]

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

chemins, chemins(node_filter), chemin_feuille
chemins affiche les chemins vers tous les éléments dans son entrée (sauf qu'il ne sort pas le
liste vide, représentant . lui-même).

chemins(f) affiche les chemins vers toutes les valeurs pour lesquelles f est vrai. C'est-à-dire, chemins (nombres)
affiche les chemins vers toutes les valeurs numériques.

chemin_feuille est un alias de chemins (scalaires); chemin_feuille is obsolète et sera supprimé dans
la prochaine version majeure.

jq '[chemins]'
[1,[[],{"a":2}]]
=> [[0],[1],[1,0],[1,1],[1,1,"a"]]

jq '[chemins(scalaires)]'
[1,[[],{"a":2}]]
=> [[0],[1,1,"a"]]

ajouter
Le filtre ajouter prend en entrée un tableau, et produit en sortie les éléments du tableau
additionnés. Cela peut signifier additionné, concaténé ou fusionné selon les types de
les éléments du tableau d'entrée - les règles sont les mêmes que celles pour le + opérateur
(décrit ci-dessus).

Si l'entrée est un tableau vide, ajouter Retours nul.

jq "ajouter"
["abc"]
=> "abc"

jq "ajouter"
[1, 2, 3]
=> 6

jq "ajouter"
[]
=> nul

tout, toute (condition), tout(générateur ; état)
Le filtre tous prend en entrée un tableau de valeurs booléennes, et produit oui en sortie si
l'un des éléments du tableau est oui.

Si l'entrée est un tableau vide, tous Retours non.

La toute (condition) form applique la condition donnée aux éléments du tableau d'entrée.

La tout(générateur ; état) forme applique la condition donnée à toutes les sorties du
générateur donné.

jq "tout"
[vrai faux]
=> vrai

jq "tout"
[faux, faux]
=> faux

jq "tout"
[]
=> faux

tous, tout (état), tout(générateur; état)
Le filtre TOUTE prend en entrée un tableau de valeurs booléennes, et produit oui en sortie si
tous les éléments du tableau sont oui.

La tout (état) form applique la condition donnée aux éléments du tableau d'entrée.

La tout(générateur; état) forme applique la condition donnée à toutes les sorties du
générateur donné.

Si l'entrée est un tableau vide, TOUTE Retours oui.

jq "tout"
[vrai faux]
=> faux

jq "tout"
[vrai vrai]
=> vrai

jq "tout"
[]
=> vrai

[A besoin 1.5] aplatir, aplatir (profondeur)
Le filtre aplatir prend en entrée un tableau de tableaux imbriqués et produit un tableau plat dans
où tous les tableaux à l'intérieur du tableau d'origine ont été remplacés de manière récursive par leurs valeurs.
Vous pouvez lui transmettre un argument pour spécifier le nombre de niveaux d'imbrication à aplatir.

aplatir(2) c'est comme aplatir, mais n'allant que jusqu'à deux niveaux de profondeur.

jq "aplatir"
[1, [2], [[3]]]
=> [1, 2, 3]

jq 'aplatir(1
[1, [2], [[3]]]
=> [1, 2, [3]]

jq "aplatir"
[[]]
=> []

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

gamme (jusqu'à), plage (de;jusqu'à) plage(de;jusqu'à;par)
La gamme fonction produit une plage de nombres. plage (4;10) produit 6 nombres, à partir de 4
(inclus) à 10 (exclusif). Les nombres sont produits en tant que sorties séparées. Utilisation
[plage(4;10)] pour obtenir une plage sous forme de tableau.

La forme à un argument génère des nombres de 0 au nombre donné, avec un incrément de
1.

La forme à deux arguments génère des nombres à partir de de à Jusqu'à avec un incrément de 1.

La forme à trois arguments génère des nombres de à Jusqu'à avec un incrément de by.

jq 'plage(2;4)'
nul
=> 2, 3

jq '[plage(2;4)]'
nul
=> [2,3]

jq '[gamme(4)]´
nul
=> [0,1,2,3]

jq '[plage(0;10;3)]'
nul
=> [0,3,6,9]

jq ´[plage(0;10;-1)]´
nul
=> []

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

sol
La sol La fonction renvoie le plancher de son entrée numérique.

jq 'étage'
3.14159
=> 3

sqrt
La sqrt La fonction renvoie la racine carrée de son entrée numérique.

jq 'sqrt'
9
=> 3

numéroter
La numéroter La fonction analyse son entrée comme un nombre. Il convertira correctement formaté
chaînes à leur équivalent numérique, laissez les nombres seuls et donnez une erreur sur tous les autres
contribution.

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

tostring
La tostring La fonction imprime son entrée sous forme de chaîne. Les chaînes restent inchangées et toutes
les autres valeurs sont encodées JSON.

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

type
La type la fonction renvoie le type de son argument sous forme de chaîne, qui est l'un des null,
booléen, nombre, chaîne, tableau ou objet.

jq 'map(type)'
[0, faux, [], {}, nul, "bonjour"]
=> ["number", "boolean", "array", "object", "null", "string"]

infini, non, est infini, Isnan, est fini, Est normal
Certaines opérations arithmétiques peuvent donner des valeurs infinies et "pas un nombre" (NaN). Les
est infini retours intégrés oui si son entrée est infinie. Les Isnan retours intégrés oui
si son entrée est un NaN. Les infinis Builtin renvoie une valeur infinie positive. Les nan
La fonction intégrée renvoie un NaN. Les Est normal Builtin renvoie true si son entrée est un nombre normal.

Notez que la division par zéro génère une erreur.

Actuellement, la plupart des opérations arithmétiques fonctionnant sur des infinis, des NaN et des sous-normes ne
soulever des erreurs.

jq ´.[] | (infini * .) < 0´
[-Onze]
=> vrai, faux

jq ´infini, nan | taper
nul
=> "nombre", "nombre"

Trier, sort_by(expression_chemin)
La sort fonctions trie son entrée, qui doit être un tableau. Les valeurs sont triées dans le
ordre suivant :

· nul

· non

· oui

· Nombres

· chaînes, par ordre alphabétique (par valeur de point de code unicode)

· tableaux, dans l'ordre lexical

· objets

L'ordre des objets est un peu complexe : ils sont d'abord comparés en comparant leurs
ensembles de clés (sous forme de tableaux dans l'ordre trié), et si leurs clés sont égales, les valeurs sont
comparé clé par clé.

sort peut être utilisé pour trier par un champ particulier d'un objet, ou en appliquant n'importe quel filtre jq.

trier_par(foo) compare deux éléments en comparant le résultat de foo sur chaque élément.

jq « trier »
[8,3,nulle,6]
=> [nulle,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(expression_chemin)
group_by(.foo) prend en entrée un tableau, regroupe les éléments ayant le même .foo champ
en tableaux séparés, et produit tous ces tableaux en tant qu'éléments d'un tableau plus grand,
trié par la valeur du .foo champ.

Toute expression jq, pas seulement un accès à un champ, peut être utilisée à la place de .foo. Le tri
l'ordre est le même que celui décrit dans le sort fonction ci-dessus.

jq 'group_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(chemin_exp), max_by(chemin_exp)
Trouvez l'élément minimum ou maximum du tableau d'entrée.

La min_by(chemin_exp) ainsi que max_by(chemin_exp) les fonctions vous permettent de spécifier un
champ ou propriété à examiner, par ex. min_by(.foo) trouve l'objet avec le plus petit foo
champ.

jq "min"

=> 2

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

unique, unique_by(chemin_exp)
La unique La fonction prend en entrée un tableau et produit un tableau des mêmes éléments, en
ordre trié, avec les doublons supprimés.

La unique_by(chemin_exp) fonction ne gardera qu'un élément pour chaque valeur obtenue par
appliquer l'argument. Pensez-y comme faire un tableau en prenant un élément de chaque
groupe produit par groupe.

jq 'unique'

=> [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(longueur)'
["gros", "bacon", "chaton", "cigale", "asperge"]
=> ["bacon", "gros", "asperges"]

inverser
Cette fonction inverse un tableau.

jq "inverse"

=> [4,3,2,1]

contient (élément)
Le filtre contient (b) produira vrai si b est complètement contenu dans l'entrée. UNE
la chaîne B est contenue dans une chaîne A si B est une sous-chaîne de A. Un tableau B est contenu dans
un tableau A si tous les éléments de B sont contenus dans n'importe quel élément de A. Un objet B est
contenu dans l'objet A si toutes les valeurs de B sont contenues dans la valeur de A avec le
même clé. Tous les autres types sont supposés être contenus les uns dans les autres s'ils sont égaux.

jq ´contient("barre")´
"foobar"
=> vrai

jq ´contient(["baz", "bar"])´
["foobar", "foobaz", "blarp"]
=> vrai

jq ´contient(["bazzzzz", "bar"])´
["foobar", "foobaz", "blarp"]
=> faux

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

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

indices
Affiche un tableau contenant les indices dans . De s se produit. L'entrée peut être un tableau, dans
quel cas si s est un tableau, alors les indices de sortie seront ceux où tous les éléments de .
correspondent à ceux de s.

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

jq 'indices(1

=> [1,3,5]

jq 'indices([1,2])'

=> [1,8]

indice(s), index(s)
Affiche l'index du premier (indice) ou dernier (réindexer) apparition de s dans l'entrée.

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

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

à l'intérieur
Le filtre à l'intérieur (b) produira vrai si l'entrée est complètement contenue dans b. Ce
est essentiellement une version inversée de contient.

jq 'à l'intérieur("foobar")'
"bar"
=> vrai

jq ´intérieur(["foobar", "foobaz", "blarp"])´
["baz", "bar"]
=> vrai

jq ´intérieur(["foobar", "foobaz", "blarp"])´
["bazzzzz", "barre"]
=> faux

jq ´intérieur({"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]})´
{"foo": 12, "bar": [{"barp": 12}]}
=> vrai

jq ´intérieur({"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]})´
{"foo": 12, "bar": [{"barp": 15}]}
=> faux

commencepar(str)
Sortie oui si . commence par l'argument de chaîne donné.

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

se termine par(str)
Sortie oui si . se termine par l'argument de chaîne donné.

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

combinaisons, combinaisons(n)
Affiche toutes les combinaisons des éléments des tableaux dans le tableau d'entrée. Si on lui donne un
argument n, il sort toutes les combinaisons de n répétitions du tableau d'entrée.

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

jq 'комбинации(2
[0, 1]
=> [0, 0], [0, 1], [1, 0], [1, 1]

ltrimstr(str)
Affiche son entrée avec la chaîne de préfixe donnée supprimée, si elle commence par elle.

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

rtrimstr(str)
Affiche son entrée avec la chaîne de suffixe donnée supprimée, si elle se termine par elle.

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

exploser
Convertit une chaîne d'entrée en un tableau des numéros de point de code de la chaîne.

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

imploser
L'inverse d'exploser.

jq "imploser"
[65, 66, 67]
=> "ABC"

scission
Divise une chaîne d'entrée sur l'argument séparateur.

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

joindre(str)
Joint le tableau d'éléments donné en entrée, en utilisant l'argument comme séparateur. C'est le
inverse de scission: c'est-à-dire courir split("foo") | join("foo") sur n'importe quelle chaîne d'entrée
renvoie ladite chaîne d'entrée.

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

ascii_downcase, ascii_upcase
Émettre une copie de la chaîne d'entrée avec ses caractères alphabétiques (az et AZ) convertis en
le cas spécifié.

tandis que(cond; mettre à jour)
La tandis que(cond; mettre à jour) fonction vous permet d'appliquer à plusieurs reprises une mise à jour à . jusqu'à cond
c'est faux.

Notez que tandis que(cond; mettre à jour) est défini en interne comme une fonction jq récursive. récursif
appels au sein tout en ne consommera pas de mémoire supplémentaire si Mise à jour produit au plus un
sortie pour chaque entrée. Voir les sujets avancés ci-dessous.

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

jusqu'à (cond; prochain)
La jusqu'à (cond; prochain) fonction vous permet d'appliquer à plusieurs reprises l'expression next,
initialement à . puis à sa propre sortie, jusqu'à cond est vrai. Par exemple, cela peut être utilisé
pour implémenter une fonction factorielle (voir ci-dessous).

Notez que jusqu'à (cond; prochain) est défini en interne comme une fonction jq récursive. récursif
appels au sein jusqu'à() ne consommera pas de mémoire supplémentaire si next produit au plus un
sortie pour chaque entrée. Voir les sujets avancés ci-dessous.

jq ´[.,1]|jusqu'à(.[0] < 1; [.[0] - 1, .[1] * .[0]])|.[1]´
4
=> 24

récursif(f), récidive, récursif(f; état), recurse_down
La récurer(f) La fonction vous permet de rechercher dans une structure récursive et d'extraire
des données intéressantes à tous les niveaux. Supposons que votre entrée représente un système de fichiers :

{"nom": "/", "enfants": [
{"Nom": "/ bin", "enfants": [
{"Nom": "/bin/ls", "enfants": []},
{"Nom": "/ Bin / sh", "enfants": []}]},
{"Nom": "/ home", "enfants": [
{"name": "/home/stephen", "children": [
{"name": "/home/stephen/jq", "children": []}]}]}]}

Supposons maintenant que vous vouliez extraire tous les noms de fichiers présents. Vous devez récupérer . Nom,
.enfants[].nom, .enfants[].enfants[].nom, etc. Vous pouvez le faire avec :

recurse(.children[]) | .Nom

Lorsqu'il est appelé sans argument, recurse équivaut à recursive(.[]?).

récurer(f) est identique à récursif(f; . != nul) et peut être utilisé sans souci de
profondeur de récursivité.

récursif(f; état) est un générateur qui commence par émettre . puis émet à son tour
.|f, .|f|f, .|f|f|f, ... tant que la valeur calculée satisfait la condition. Pour
exemple, pour générer tous les entiers, au moins en principe, on pourrait écrire récurrence(.+1 ;
vrai).

Pour des raisons patrimoniales, recurse_down existe en tant qu'alias pour appeler recurse sans argumentation.
Cet alias est considéré obsolète et sera supprimé dans la prochaine version majeure.

Les appels récursifs recurse ne consommera pas de mémoire supplémentaire à chaque fois f produit à
la plupart une seule sortie pour chaque entrée.

jq 'recurse(.foo[])'
{"foo":[{"foo": []}, {"foo":[{"foo":[]}]}]}
=> {"foo":[{"foo":[]},{"foo":[{"foo":[]}]}]}, {"foo":[]}, {"foo": [{"foo":[]}]}, {"foo":[]}

jq "récurseur"
{"a":0,"b":[1]}
=> {"a":0,"b":[1]}, 0, [1], 1

jq 'recurse(. * .; . < 20)'
2
=> 2, 4, 16

..
Raccourci pour recurse sans argument. Ceci est destiné à ressembler au XPath //
opérateur. Noter que ..et ne marche pas; utilisation ..|un au lieu. Dans l'exemple ci-dessous, nous utilisons
..|.un? pour trouver toutes les valeurs des clés d'objet "a" dans n'importe quel objet trouvé "en-dessous" ..

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

env
Affiche un objet représentant l'environnement de jq.

jq 'env.PAGER'
nul
=> "moins"

transposer
Transposer une matrice éventuellement déchiquetée (un tableau de tableaux). Les lignes sont remplies de valeurs NULL afin que le
le résultat est toujours rectangulaire.

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

brecherche(x)
bsearch(x) effectue une recherche binaire de x dans le tableau d'entrée. Si l'entrée est triée et
contient x, alors bsearch(x) renverra son index dans le tableau ; sinon, si le tableau est
trié, il renverra (-1 - ix) où ix est un point d'insertion tel que le tableau serait
toujours être trié après l'insertion de x à ix. Si le tableau n'est pas trié, bsearch(x)
renverra un entier qui n'a probablement aucun intérêt.

jq 'brecherche(0

=> 0

jq 'brecherche(0

=> -1

jq 'brecherche(4) comme $ix | si $ix < 0 alors .[-(1+$ix)] = 4 else . finir

=> [1,2,3,4]

Chaîne interpolation - \(toto)
À l'intérieur d'une chaîne, vous pouvez mettre une expression entre parenthèses après une barre oblique inverse. Quel que soit le
Les retours d'expression seront interpolés dans la chaîne.

jq ´"L'entrée était \(.), qui est un de moins que \(.+1)"´
42
=> "L'entrée était 42, soit un de moins que 43"

Convertir vers / depuis JSON
La tojson ainsi que dejson les valeurs de vidage intégrées sous forme de textes JSON ou d'analyse de textes JSON dans
valeurs, respectivement. La fonction intégrée tojson diffère de tostring en ce que tostring renvoie
chaînes non modifiées, tandis que tojson encode les chaînes en tant que chaînes JSON.

jq ´[.[]|tochaîne]´
[1, "foo", ["foo"]]
=> ["1","foo","[\"foo\"]"]

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

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

Format instruments à cordes ainsi que échapper
La @foo la syntaxe est utilisée pour formater et échapper les chaînes, ce qui est utile pour créer des URL,
documents dans un langage comme HTML ou XML, et ainsi de suite. @foo peut être utilisé comme filtre sur
le sien, les échappées possibles sont :

@texte:

Appels tostring, voir cette fonction pour plus de détails.

@json:

Sérialise l'entrée au format JSON.

@html:

Applique l'échappement HTML/XML, en mappant les caractères <>&´" à leur entité
équivalents <, >, et, ', ".

@uri:

Applique un codage en pourcentage, en mappant tous les caractères URI réservés à un % XX séquence.

@csv:

L'entrée doit être un tableau, et il est rendu au format CSV avec des guillemets doubles pour
les chaînes et les guillemets échappés par répétition.

@tsv:

L'entrée doit être un tableau et elle est rendue sous forme de TSV (valeurs séparées par des tabulations). Chaque
le tableau d'entrée sera imprimé sur une seule ligne. Les champs sont séparés par un seul onglet
(ascii Assistance ). Caractères d'entrée saut de ligne (ASCII 0x0a), retour chariot (ascii
0x0d), onglet (ascii Assistance ) et une barre oblique inverse (ascii 0x5c) sera affiché en tant qu'échappement
séquences \n, \r, \t, \\ respectivement.

@sh:

L'entrée est échappée et peut être utilisée dans une ligne de commande pour un shell POSIX. Si la
input est un tableau, la sortie sera une série de chaînes séparées par des espaces.

@base64:

L'entrée est convertie en base64 comme spécifié par la RFC 4648.

Cette syntaxe peut être combinée avec l'interpolation de chaîne de manière utile. Vous pouvez suivre un
@foo jeton avec un littéral de chaîne. Le contenu de la chaîne littérale sera ne sauraient être échappé.
Cependant, toutes les interpolations effectuées à l'intérieur de ce littéral de chaîne seront échappées. Par exemple,

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

produira la sortie suivante pour l'entrée {"search":"quoi is jq ?"}:

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

Notez que les barres obliques, le point d'interrogation, etc. dans l'URL ne sont pas échappés, car ils faisaient partie
du littéral de chaîne.

jq '@html'
"Cela fonctionne si x < y"
=> "Cela fonctionne si x < y"

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

Dates
jq fournit des fonctionnalités de base de gestion des dates, avec des fonctionnalités de haut et de bas niveau
intégrés. Dans tous les cas, ces fonctions intégrées traitent exclusivement de l'heure en UTC.

La dudateiso8601 Builtin analyse les datetimes au format ISO 8601 en un certain nombre de secondes
depuis l'époque Unix (1970-01-01T00:00:00Z). Les à ce jouriso8601 Builtin fait l'inverse.

La partir de la date Builtin analyse les chaînes datetime. Actuellement partir de la date prend uniquement en charge ISO 8601
chaînes datetime, mais à l'avenir, il tentera d'analyser les chaînes datetime dans plus
formats.

La à ce jour Builtin est un alias pour à ce jouriso8601.

La maintenant Builtin affiche l'heure actuelle, en secondes depuis l'époque Unix.

Des interfaces jq de bas niveau vers les fonctions temporelles de la bibliothèque C sont également fournies : l'heure du strp,
strftime, mktimeet heure de gm. Reportez-vous à la documentation de votre système d'exploitation hôte pour
chaînes de format utilisées par l'heure du strp ainsi que strftime. Remarque: ceux-ci ne sont pas nécessairement stables
interfaces dans jq, notamment en ce qui concerne leur fonctionnalité de localisation.

La heure de gm Builtin consomme un certain nombre de secondes depuis l'époque Unix et génère un "cassé
temps d'arrêt" représentation du temps sous la forme d'un tableau de nombres représentant (dans cet ordre) :
l'année, le mois (base zéro), le jour du mois, l'heure du jour, la minute du
l'heure, la seconde de la minute, le jour de la semaine et le jour de l'année -- tous
à base unique, sauf indication contraire.

La mktime Builtin consomme des représentations de "temps d'arrêt" du temps de sortie par heure de gm
ainsi que l'heure du strp.

La strptime(fmt) Builtin analyse les chaînes d'entrée correspondant à la fmt argument. La sortie est en
la représentation du "temps de panne" consommée par heure de gm et sortie par mktime.

La heure strf(fmt) Builtin formate une fois avec le format donné.

Les chaînes de format pour l'heure du strp ainsi que strftime sont décrits dans la bibliothèque C typique
Documentation. La chaîne de format pour la date/heure ISO 8601 est "%Y-%m-%dT%H:%M:%SZ".

jq peut ne pas prendre en charge tout ou partie de cette fonctionnalité de date sur certains systèmes.

jq 'à partir de la date'
"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

CONDITIONNELS ET COMPARAISON

==, !=
L'expression « a == b » produira « vrai » si les résultats de a et b sont égaux (c'est-à-dire,
s'ils représentent des documents JSON équivalents) et 'false' sinon. En particulier, les chaînes
ne sont jamais considérés comme égaux à des nombres. Si vous venez de Javascript, jq's == est comme
Javascript´s === - considérer les valeurs égales uniquement lorsqu'elles ont le même type ainsi que
la même valeur.

!= n'est "pas égal", et ´a != b´ renvoie la valeur opposée de ´a == b´

jq ´.[] == 1´
[1, 1.0, "1", "banane"]
=> vrai, vrai, faux, faux

si-alors-sinon
if A puis B d'autre C fin agira de la même manière que B if A produit une valeur autre que faux ou
nul, mais agit de la même manière que C autrement.

La vérification de faux ou de null est une notion de "vérité" plus simple que celle trouvée dans Javascript
ou Python, mais cela signifie que vous devrez parfois être plus explicite sur la condition
vous voulez : vous ne pouvez pas tester si, par exemple, une chaîne est vide en utilisant if . Nom puis A d'autre B fin,
vous aurez besoin de quelque chose comme if (.Nom | longueur) > 0 puis A d'autre B fin à la place.

Si la condition A produit plusieurs résultats, elle est considérée comme « vraie » si l'un de ces
résultats n'est pas faux ou nul. S'il ne produit aucun résultat, il est considéré comme faux.

Plus de cas peuvent être ajoutés à un si vous utilisez Elif A puis B syntaxe.

jq 'si . == 0 alors

"zéro" elif. == 1 then "un" sinon "plusieurs" fin´ 2 => "plusieurs"

>, >=, <=, <
Les opérateurs de comparaison >, >=, <=, < renvoie si leur argument de gauche est supérieur à,
supérieur ou égal à, inférieur ou égal ou inférieur à leur argument de droite
(respectivement).

La commande est la même que celle décrite pour sort, au dessus.

jq '. < 5'
2
=> vrai

et/ou/pas
jq prend en charge les opérateurs booléens normaux et/ou/non. Ils ont le même standard de vérité
comme si les expressions - false et null sont considérées comme des " fausses valeurs ", et tout le reste est un
"vraie valeur".

Si un opérande de l'un de ces opérateurs produit plusieurs résultats, l'opérateur lui-même
produira un résultat pour chaque entrée.

ne sauraient est en fait une fonction intégrée plutôt qu'un opérateur, il est donc appelé comme un filtre pour
quelles choses peuvent être redirigées plutôt qu'avec une syntaxe spéciale, comme dans .foo ainsi que .Café | ne sauraient .

Ces trois ne produisent que les valeurs « vrai » et « faux », et ne sont donc utiles que pour les véritables
Opérations booléennes, plutôt que l'idiome Perl/Python/Ruby commun de
"value_that_may_be_null ou default". Si vous souhaitez utiliser cette forme de "ou", choisissez entre
deux valeurs plutôt que d'évaluer une condition, voir l'opérateur "//" ci-dessous.

jq ´42 et "une ficelle"´
nul
=> vrai

jq '(vrai, faux) ou faux'
nul
=> vrai, faux

jq '(vrai, vrai) et (vrai, faux)'
nul
=> vrai, faux, vrai, faux

jq ´[vrai, faux | ne pas
nul
=> [faux, vrai]

Alternative opérateur - //
Un filtre de la forme a // b produit les mêmes résultats que a, Si a produit des résultats autre
que non ainsi que nul. Autrement, a // b produit les mêmes résultats que b.

Ceci est utile pour fournir des valeurs par défaut : .foo // 1 évaluera à 1 s'il n'y a pas .foo
élément dans l'entrée. C'est similaire à la façon dont or est parfois utilisé en Python (jq´s or opérateur
est réservé aux opérations strictement booléennes).

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

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

essayer-attraper
Les erreurs peuvent être détectées en utilisant Essai EXP capture EXP. La première expression est exécutée, et si
il échoue puis le second est exécuté avec le message d'erreur. La sortie du gestionnaire, si
any, est affiché comme s'il s'agissait de la sortie de l'expression à essayer.

La Essai EXP forme utilise vide comme gestionnaire d'exceptions.

jq 'essayez .a catch ". n'est pas un objet"'
oui
=> ". n'est pas un objet"

jq '[.[]|essayez .a]'
[{}, vrai, {"a":1}]
=> [nulle, 1]

jq ´essayez l'erreur("une exception") catch .´
oui
=> "quelques exceptions"

Rupture ande of des bactéries structures
Une utilisation pratique de try/catch est de sortir des structures de contrôle comme réduire, foreach,
tout en, Et ainsi de suite.

Par exemple :

# Répétez une expression jusqu'à ce qu'elle lève "break" comme un
# erreur, puis arrêtez de répéter sans relancer l'erreur.
# Mais si l'erreur détectée n'est pas « break », alors relancez-la.
essayez repeat(exp) catch .=="break" puis vide else erreur ;

jq a une syntaxe pour les étiquettes lexicales nommées à "casser" ou "aller (retour) à":

étiquette $out | ... casser $out ...

La pause $nom_étiquette expression fera agir le programme comme si la plus proche
(À gauche) étiquette $nom_étiquette produit vide.

La relation entre le pause et correspondant étiquette est lexical : l'étiquette doit être
« visible » depuis la pause.

Pour sortir d'un réduire, Par exemple:

étiquette $out | réduire .[] comme $item (null ; if .==false then break $out else ... end)

Le programme jq suivant produit une erreur de syntaxe :

casser $out

car pas d'étiquette $out est visible.

? opérateur
La ? opérateur, utilisé comme EXP ?, est un raccourci pour Essai EXP.

jq '[.[]|(.a)?]'
[{}, vrai, {"a":1}]
=> [nulle, 1]

ORDINAIRE EXPRESSIONS (PCRE)

jq utilise la bibliothèque d'expressions régulières Oniguruma, tout comme php, ruby, TextMate, Sublime Text,
etc, donc la description ici se concentrera sur les spécificités de jq.

Les filtres jq regex sont définis de manière à pouvoir être utilisés à l'aide de l'un de ces modèles :

CHAINE | FILTRE( REGEX )
CHAINE | FILTRE( REGEX; DRAPEAUX )
CHAINE | FILTRE( [REGEX] )
CHAINE | FILTRE( [REGEX, DRAPEAUX] )

où : * STRING, REGEX et FLAGS sont des chaînes jq et soumises à une interpolation de chaîne jq ; *
REGEX, après interpolation de chaîne, doit être une regex PCRE valide ; * FILTRE est l'un des tester,
rencontreou capturer, comme décrit ci-dessous.

FLAGS est une chaîne composée d'un ou plusieurs des drapeaux pris en charge :

· g - Recherche globale (trouver toutes les correspondances, pas seulement la première)

· i - Recherche insensible à la casse

· m - Mode multi-ligne (´.´ correspondra aux nouvelles lignes)

· n - Ignorer les correspondances vides

· p - Les modes s et m sont activés

· s - Mode ligne simple (´^´ -> ´\A´, ´$´ -> ´\Z´)

· l - Trouver les matchs les plus longs possibles

· x - Format regex étendu (ignorer les espaces et les commentaires)

Pour faire correspondre les espaces blancs dans un motif x, utilisez un échappement tel que \s, par exemple

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

Notez que certains drapeaux peuvent également être spécifiés dans REGEX, par exemple

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

évalue à : vrai, vrai, faux, faux.

[A besoin 1.5] essai(val), test(expression régulière; drapeaux)
Comme rencontre, mais ne renvoie pas d'objets de correspondance, uniquement oui or non pour savoir si le
regex correspond à l'entrée.

jq ´test("foo")´
"toto"
=> vrai

jq ´.[] | test("abc # espaces sont ignorés"; "ix")´
["xabcd", "ABC"]
=> vrai, vrai

[A besoin 1.5] match(val), correspond(regex; drapeaux)
rencontre génère un objet pour chaque correspondance trouvée. Les correspondances ont les champs suivants :

· compenser - décalage en points de code UTF-8 à partir du début de l'entrée

· longueur - longueur en points de code UTF-8 du match

· un magnifique - la chaîne à laquelle elle correspond

· captures - un tableau d'objets représentant des groupes de capture.

Les objets de groupe de capture ont les champs suivants :

· compenser - décalage en points de code UTF-8 à partir du début de l'entrée

· longueur - longueur en points de code UTF-8 de ce groupe de capture

· un magnifique - la chaîne qui a été capturée

· prénom - le nom du groupe de capture (ou nul s'il n'était pas nommé)

La capture de groupes qui ne correspondent à rien renvoie un décalage de -1

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

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

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

jq ´match("foo (? bar)? 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")] | longueur
"abc"
=> 3

[A besoin 1.5] capturer(val), capture (expression régulière ; drapeaux)
Collecte les captures nommées dans un objet JSON, avec le nom de chaque capture comme clé,
et la chaîne correspondante comme valeur correspondante.

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

[A besoin 1.5] scan (regex), scan (expression régulière ; drapeaux)
Émettre un flux de sous-chaînes non chevauchantes de l'entrée qui correspondent à l'expression régulière dans
conformément aux drapeaux, le cas échéant. S'il n'y a pas de correspondance, le flux est
vide. Pour capturer toutes les correspondances pour chaque chaîne d'entrée, utilisez l'idiome [ expr ], par exemple [
scan (regex) ].

diviser(regex; drapeaux)
Pour une compatibilité descendante, scission se divise sur une chaîne, pas une regex.

[A besoin 1.5] divise (regex), fractionne (regex; drapeaux)
Ceux-ci donnent les mêmes résultats que leurs scission homologues, mais comme un flux au lieu d'un
Tableau.

[A besoin 1.5] sous (expression régulière ; tostring) sous (expression régulière ; ficelle; drapeaux)
Émettez la chaîne obtenue en remplaçant la première correspondance de regex dans la chaîne d'entrée par
tostring, après interpolation. tostring doit être une chaîne jq et peut contenir des références
aux captures nommées. Les captures nommées sont, en effet, présentées comme un objet JSON (comme
construit par capturer) À tostring, donc une référence à une variable capturée nommée "x" serait
prendre la forme : "(.x)".

[A besoin 1.5] gsub(regex ; chaîne de caractères), gsub(regex ; ficelle; drapeaux)
gsub c'est comme dessous mais toutes les occurrences non chevauchantes de la regex sont remplacées par le
chaîne, après interpolation.

Avancé CARACTERISTIQUES

Les variables sont une nécessité absolue dans la plupart des langages de programmation, mais elles sont reléguées
à une "fonctionnalité avancée" dans jq.

Dans la plupart des langues, les variables sont le seul moyen de faire circuler les données. Si vous calculez un
value, et que vous souhaitez l'utiliser plus d'une fois, vous devrez la stocker dans une variable. À
passer une valeur à une autre partie du programme, vous aurez besoin de cette partie du programme pour
définir une variable (en tant que paramètre de fonction, membre d'objet ou autre) dans laquelle placer
les données.

Il est également possible de définir des fonctions dans jq, bien que ce soit une fonctionnalité dont la plus grande
l'utilisation définit la bibliothèque standard de jq (de nombreuses fonctions jq telles que Localisation ainsi que trouver sont en fait
écrit en jq).

jq a des opérateurs de réduction, qui sont très puissants mais un peu délicats. Encore une fois, ce sont
principalement utilisé en interne, pour définir quelques éléments utiles de la bibliothèque standard de jq.

Ce n'est peut-être pas évident au début, mais jq concerne les générateurs (oui, comme on le trouve souvent dans
autres langues). Certains services publics sont fournis pour aider à faire face aux générateurs.

Une prise en charge minimale des E/S (en plus de lire JSON à partir d'une entrée standard et d'écrire JSON sur
sortie standard) est disponible.

Enfin, il existe un système module/bibliothèque.

Variables
Dans jq, tous les filtres ont une entrée et une sortie, donc la plomberie manuelle n'est pas nécessaire pour
passer une valeur d'une partie d'un programme à la suivante. De nombreuses expressions, par exemple a + b,
passer leur entrée à deux sous-expressions distinctes (ici a ainsi que b sont tous les deux passés de la même manière
input), donc les variables ne sont généralement pas nécessaires pour utiliser une valeur deux fois.

Par exemple, le calcul de la valeur moyenne d'un tableau de nombres nécessite quelques
variables dans la plupart des langues - au moins une pour contenir le tableau, peut-être une pour chaque élément
ou pour un compteur de boucle. Dans jq, c'est simplement ajouter / longueur - la ajouter l'expression est donnée la
tableau et produit sa somme, et le longueur expression reçoit le tableau et produit son
longueur.

Ainsi, il existe généralement un moyen plus propre de résoudre la plupart des problèmes dans jq que de définir des variables.
Pourtant, parfois, ils facilitent les choses, donc jq vous permet de définir des variables en utilisant
expression as $ variable. Tous les noms de variables commencent par $. Voici une version un peu plus moche
de l'exemple de moyenne de tableau :

longueur comme $array_length | ajouter / $tableau_longueur

Nous aurons besoin d'un problème plus compliqué pour trouver une situation où l'utilisation de variables
nous facilite la vie.

Supposons que nous ayons un tableau d'articles de blog, avec des champs "auteur" et "titre", et un autre
objet qui est utilisé pour mapper les noms d'utilisateur des auteurs aux noms réels. Notre entrée ressemble à:

{"posts": [{"title": "Frist psot", "author": "anon"},
{"title": "Un article bien écrit", "author": "person1"}],
"realnames": {"anon": "Lâche anonyme",
"person1": "Person McPherson"}}

Nous voulons produire les articles avec le champ auteur contenant un vrai nom, comme dans :

{"title": "Frist psot", "author": "Lâche anonyme"}
{"title": "Un article bien écrit", "author": "Person McPherson"}

Nous utilisons une variable, $names, pour stocker l'objet realnames, afin que nous puissions nous y référer plus tard
lors de la recherche des noms d'utilisateurs des auteurs :

.realnames comme $names | .posts[] | {titre, auteur : $names[.author]}

L'expression exp as $x | signifie : pour chaque valeur d'expression exp, exécutez le reste de
le pipeline avec l'intégralité de l'entrée d'origine, et avec $x mis à cette valeur. Ainsi as
fonctionne comme une boucle foreach.

De même que {foo} est une façon pratique d'écrire {toto : .foo}, De sorte {$foo} est une façon pratique d'écrire
{foo :$foo}.

Plusieurs variables peuvent être déclarées en utilisant un seul as expression en fournissant un modèle
qui correspond à la structure de l'entrée (c'est ce qu'on appelle la "déstructuration") :

. comme {vrais noms : $noms, messages : [$premier, $second]} | ...

Les déclarations de variables dans les modèles de tableau (par exemple, . as [$d'abord, $seconde]) lier au
éléments du tableau à partir de l'élément à l'index zéro vers le haut, dans l'ordre. Quand il n'y a pas
valeur à l'index d'un élément de modèle de tableau, nul est lié à cette variable.

Les variables sont étendues sur le reste de l'expression qui les définit, donc

.realnames comme $names | (.posts[] | {titre, auteur : $names[.author]})

fonctionnera, mais

(.realnames as $names | .posts[]) | {titre, auteur : $names[.author]}

habitude.

Pour les théoriciens du langage de programmation, il est plus précis de dire que les variables jq sont
les liaisons à portée lexicale. En particulier, il n'y a aucun moyen de changer la valeur d'une liaison ;
on ne peut configurer qu'une nouvelle liaison avec le même nom, mais qui ne sera pas visible où
l'ancien était.

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

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

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

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

Définir Les fonctions
Vous pouvez donner un nom à un filtre en utilisant la syntaxe "def":

incrément de def : . + 1 ;

À partir de maintenant, incrément est utilisable comme filtre tout comme une fonction intégrée (en fait, cette
est la façon dont certaines des fonctions intégrées sont définies). Une fonction peut prendre des arguments :

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

Les arguments sont passés en tant que filtres, pas en tant que valeurs. Le même argument peut être référencé
plusieurs fois avec des entrées différentes (ici f est exécuté pour chaque élément du tableau d'entrée).
Les arguments d'une fonction fonctionnent plus comme des rappels que comme des arguments de valeur. C'est
important de comprendre. Envisager:

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

Le résultat sera 20 car f is .*2, et lors de la première invocation de f . sera 5,
et la deuxième fois ce sera 10 (5 * 2), donc le résultat sera 20. Arguments de fonction
sont des filtres, et les filtres attendent une entrée lorsqu'ils sont appelés.

Si vous voulez le comportement valeur-argument pour définir des fonctions simples, vous pouvez simplement utiliser un
variable:

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

Ou utilisez le raccourci :

def valeur ajoutée($f) : ... ;

Avec l'une ou l'autre définition, ajouter de la valeur (.foo) ajoutera l'entrée actuelle .foo champ à chacun
élément du tableau.

Plusieurs définitions utilisant le même nom de fonction sont autorisées. Chaque redéfinition remplace
la précédente pour le même nombre d'arguments de fonction, mais uniquement pour les références de
fonctions (ou programme principal) postérieures à la redéfinition.

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

jq ´def valeur ajoutée(f): f comme $x | carte(. + $x); valeur ajoutée(.[0])´
[[1,2], [10,20]]
=> [[1,2,1,2], [10,20,1,2]]

Réduire
La réduire la syntaxe dans jq vous permet de combiner tous les résultats d'une expression en
les accumulant en une seule réponse. A titre d'exemple, nous passerons à cette
expression:

réduire .[] comme $item (0; . + $item)

Pour chaque résultat qui .[] produit, . + $élément est exécuté pour accumuler un total cumulé,
à partir de 0. Dans cet exemple, .[] produit les résultats 3, 2 et 1, donc l'effet est
similaire à exécuter quelque chose comme ceci:

0 | (3 comme $item | . + $item) |
(2 comme $item | . + $item) |
(1 comme $item | . + $item)

jq 'reduce .[] as $item (0; . + $item)'

=> 20

limite(n; exp)
La limite la fonction extrait jusqu'à n sorties de exp.

jq '[limite(3;.[])]'

=> [0,1,2]

premier(expr), dernier(expression), nième(n; expression)
La premier(expression) ainsi que dernier(expression) les fonctions extraient la première et la dernière valeur de expr,
respectivement.

La nième(n; expression) la fonction extrait la nième valeur sortie par expr. Cela peut être défini comme
def nième(n; expression): dernier(limite(n + 1; expr));. Noter que nième(n; expression) ne supporte pas
valeurs négatives de n.

jq ´[premier(plage(.)), dernier(plage(.)), nième(./2;plage(.))]´
10
=> [0,9,5]

premier, dernier, nième(n)
La premier ainsi que dernier les fonctions extraient les première et dernière valeurs de n'importe quel tableau à ..

La nième(n) la fonction extrait la nième valeur de n'importe quel tableau à ..

jq ´[plage(.)]|[premier, dernier, n(5)]´
10
=> [0,9,5]

foreach
La foreach la syntaxe est similaire à réduire, mais destiné à permettre la construction de limite
et des réducteurs qui produisent des résultats intermédiaires (voir exemple).

La forme est foreach EXP as $var (INIT ; METTRE À JOUR; EXTRAIT). Comme réduire, INIT est évalué
une fois pour produire une valeur d'état, puis chaque sortie de EXP est lié à $var, MISE À JOUR is
évalué pour chaque sortie de EXP avec l'état actuel et avec $var visible. Chaque valeur
sortie par MISE À JOUR remplace l'état précédent. Finalement, EXTRAIT est évalué pour chaque nouveau
état pour extraire une sortie de foreach.

Ceci est surtout utile uniquement pour la construction réduire- Et limite-comme des fonctions. Mais il est
beaucoup plus général, car il permet des réductions partielles (voir l'exemple ci-dessous).

jq ´[foreach .[] as $item ([[],[]]; if $item == null then [[],.[0]] else [(.[0] + [$item]),[ ]] fin ; si $item == null alors .[1] sinon fin vide)]´
[1,2,3,4,null,"a","b",null]
=> [[1,2,3,4],["a","b"]]

Récursivité
Comme décrit ci-dessus, recurse utilise la récursivité, et toute fonction jq peut être récursive. Les
tout en Builtin est également implémenté en termes de récursivité.

Les appels de queue sont optimisés chaque fois que l'expression à gauche des sorties d'appel récursif
sa dernière valeur. En pratique, cela signifie que l'expression à gauche de la récursive
call ne doit pas produire plus d'une sortie pour chaque entrée.

Par exemple :

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

def while(cond; mise à jour):
def _while :
if cond then ., (update | _while) else vide end;
_tandis que;

def répéter (exp):
def _répéter :
exp, _repeat ;
_répéter;

Générateurs ainsi que itérateurs
Certains opérateurs et fonctions jq sont en fait des générateurs en ce sens qu'ils peuvent produire zéro,
une ou plusieurs valeurs pour chaque entrée, comme on pourrait s'y attendre dans d'autres programmes
langages qui ont des générateurs. Par exemple, .[] génère toutes les valeurs dans son entrée
(qui doit être un tableau ou un objet), plage(0; 10) génère les entiers compris entre 0 et
10, et ainsi de suite.

Même l'opérateur virgule est un générateur, générant d'abord les valeurs générées par le
à gauche de la virgule, puis pour chacune d'elles, les valeurs générées par le
expression à droite de la virgule.

La vide Builtin est le générateur qui produit des sorties nulles. le vide builtin
revient à l'expression génératrice précédente.

Toutes les fonctions jq peuvent être des générateurs simplement en utilisant des générateurs intégrés. Il est également possible
pour définir de nouveaux générateurs en utilisant uniquement la récursivité et l'opérateur virgule. Si le récursif
appel(s) est (sont) "en position de queue" alors le générateur sera efficace. Dans l'exemple
en dessous de l'appel récursif par _gamme à lui-même est en position de queue. L'exemple montre
trois sujets avancés : la récursivité de la queue, la construction du générateur et les sous-fonctions.

jq ´def range(init; upto; by): def _range: if (by > 0 et . < upto) or (by < 0 and . > upto) then ., ((.+by)|_range) else . finir; if by == 0 then init else init|_range end | select((par > 0 et . < jusqu'à) ou (par < 0 et . > jusqu'à)); plage (0; 10; 3)´
nul
=> 0, 3, 6, 9

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

MATH

jq ne prend actuellement en charge que les nombres à virgule flottante double précision (754 bits) IEEE64.

Outre les opérateurs arithmétiques simples tels que +, jq possède également la plupart des fonctions mathématiques standard
de la bibliothèque mathématique C. Fonctions mathématiques C qui prennent un seul argument d'entrée (par exemple, sans ())
sont disponibles en tant que fonctions jq sans argument. Fonctions mathématiques C qui prennent deux entrées
arguments (par exemple, Pow ()) sont disponibles en tant que fonctions jq à deux arguments qui ignorent ..

La disponibilité des fonctions mathématiques standard dépend de la disponibilité des
fonctions mathématiques dans votre système d'exploitation et la bibliothèque mathématique C. Fonctions mathématiques non disponibles
sera défini mais générera une erreur.

I / O

À l'heure actuelle, jq a une prise en charge minimale des E/S, principalement sous la forme d'un contrôle sur le moment
les entrées sont lues. Deux fonctions intégrées sont fournies pour cela, contribution ainsi que entrées, qui lit
provenant des mêmes sources (par exemple, Stdin, fichiers nommés sur la ligne de commande) en tant que jq lui-même. Ces
deux fonctions intégrées et les propres actions de lecture de jq peuvent être imbriquées les unes dans les autres.

Un intégré fournit des capacités de sortie minimales, déboguer. (Rappelez-vous qu'un programme jq
les valeurs de sortie sont toujours sorties sous forme de textes JSON sur Stdout.) Le déboguer intégré peut avoir
comportement spécifique à l'application, comme pour les exécutables qui utilisent l'API libjq C mais ne le sont pas
l'exécutable jq lui-même.

contribution
Sort une nouvelle entrée.

entrées
Sort toutes les entrées restantes, une par une.

Ceci est principalement utile pour les réductions sur les entrées d'un programme.

déboguer
Provoque la production d'un message de débogage basé sur la valeur d'entrée. L'exécutable jq s'enroule
la valeur d'entrée avec ["DÉBOGUER:", ] et imprime cela et une nouvelle ligne sur stderr,
de manière compacte. Cela peut changer à l'avenir.

nom_fichier_entrée
Renvoie le nom du fichier dont l'entrée est actuellement filtrée. Notez que cela va
ne fonctionne pas bien à moins que jq ne s'exécute dans une locale UTF-8.

numéro_ligne_entrée
Renvoie le numéro de ligne de l'entrée en cours de filtrage.

STREAMING

Avec la --flux l'option jq peut analyser les textes d'entrée en mode streaming, permettant à jq
programmes pour commencer à traiter de gros textes JSON immédiatement plutôt qu'après l'analyse
complète. Si vous avez un seul texte JSON d'une taille de 1 Go, le diffuser vous permettra
pour le traiter beaucoup plus rapidement.

Cependant, le streaming n'est pas facile à gérer car le programme jq aura [ ,
] (et quelques autres formes) comme entrées.

Plusieurs fonctions intégrées sont fournies pour faciliter la gestion des flux.

Les exemples ci-dessous utilisent la forme en streaming de [0, [1]], lequel est
[[0],0],[[1,0],1],[[1,0]],[[1]].

Les formulaires de streaming incluent [ , ] (pour indiquer n'importe quelle valeur scalaire, tableau vide,
ou objet vide), et [ ] (pour indiquer la fin d'un tableau ou d'un objet). Futur
versions de jq exécutées avec --flux ainsi que -séq peut produire des formulaires supplémentaires tels que ["Erreur
message"] lorsqu'un texte d'entrée ne parvient pas à analyser.

truncate_stream(stream_expression)
Consomme un nombre en entrée et tronque le nombre correspondant d'éléments de chemin de
la gauche des sorties de l'expression de streaming donnée.

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

fromstream(expression_flux)
Affiche les valeurs correspondant aux sorties de l'expression de flux.

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

ruisseler
La ruisseler Builtin génère la forme diffusée en continu de son entrée.

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

AFFECTATION

L'affectation fonctionne un peu différemment dans jq que dans la plupart des langages de programmation. j'ai pas
faire la distinction entre les références et les copies de quelque chose - deux objets ou tableaux sont
soit égal ou non égal, sans aucune autre notion d'être "le même objet" ou "pas
le même objet".

Si un objet a deux champs qui sont des tableaux, .foo ainsi que .Café, et vous ajoutez quelque chose à
.foo, puis .Café ne grossira pas. Même si vous venez de définir .Café = .foo. Si vous êtes habitué
à la programmation dans des langages comme Python, Java, Ruby, Javascript, etc. alors vous pouvez penser
de celui-ci comme si jq faisait une copie complète et profonde de chaque objet avant de faire l'affectation
(pour la performance, ça ne fait pas ça, mais c'est l'idée générale).

Tous les opérateurs d'affectation dans jq ont des expressions de chemin sur le côté gauche.

=
Le filtre .foo = 1 prendra en entrée un objet et produira en sortie un objet avec le
champ "foo" défini sur 1. Il n'y a aucune notion de "modifier" ou de "changer" quelque chose dans jq -
toutes les valeurs jq sont immuables. Par exemple,

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

n'aura pas pour effet secondaire de définir .bar.baz sur 1, car le
programme en Javascript, Python, Ruby ou d'autres langages. Contrairement à ces langues (mais
comme Haskell et certains autres langages fonctionnels), il n'y a pas de notion de deux tableaux ou
objets étant "le même tableau" ou "le même objet". Ils peuvent être égaux ou non, mais
si nous changeons l'un d'eux en aucun cas, l'autre ne changera dans notre dos.

Cela signifie qu'il est impossible de construire des valeurs circulaires dans jq (comme un tableau dont
le premier élément est lui-même). Ceci est tout à fait intentionnel et garantit que tout ce qui a un jq
programme peut produire peut être représenté en JSON.

Notez que le côté gauche de ´=´ fait référence à une valeur dans .. Ainsi $var.foo = 1 ne fonctionnera pas
comme prévu ($var.foo n'est pas une expression de chemin valide ou utile dans .); utilisation $var | .foo = 1
à la place.

Si le côté droit de ´=´ produit plusieurs valeurs, alors pour chacune de ces valeurs jq sera
définissez les chemins sur le côté gauche à la valeur, puis il affichera la modification ..
Par exemple, (.a,.b)=gamme(2) sorties {"a":0,"b":0}, puis {"a":1,"b":1}. La mise à jour"
les formulaires d'affectation (voir ci-dessous) ne le font pas.

Notez aussi que .a,.b=0 ne définit pas .a ainsi que .b, mais (.a,.b)=0 définit les deux.

|=
En plus de l'opérateur d'affectation ´=´, jq fournit l'opérateur de « mise à jour » ´|=´, qui
prend un filtre sur le côté droit et calcule la nouvelle valeur pour la propriété de .
affecté en exécutant l'ancienne valeur via cette expression. Par exemple, .foo |=
.+1 construira un objet avec le champ "foo" défini sur "foo" plus 1.

Cet exemple devrait montrer la différence entre ´=´ et ´|=´ :

Fournissez l'entrée ´{"a": {"b": 10}, "b": 20}´ aux programmes :

.a = .b .a |= .b

Le premier définira le champ "a" de l'entrée sur le champ "b" de l'entrée et produira
la sortie {"a": 20}. Ce dernier définira le champ "a" de l'entrée sur le champ "a"
champ "b", produisant {"a": 10}.

Le côté gauche peut être n'importe quelle expression de chemin général ; voir chemin().

Notez que le côté gauche de ´|=´ fait référence à une valeur dans .. Ainsi $var.foo |= . + 1 habitude
fonctionne comme prévu ($var.foo n'est pas une expression de chemin valide ou utile dans .); utilisation $var | .foo
|= . + 1 à la place.

Si le côté droit génère plusieurs valeurs, seule la dernière sera utilisée.

jq ´(..|select(type=="boolean")) |= si . puis 1 autre 0 fin´
[vrai,faux,[5,vrai,[vrai,[faux]],faux]]
=> [1,0,[5,1,[1,[0]],0]]

+=, -=, *=, /=, %=, // =
jq a quelques opérateurs de la forme a op= b, qui sont tous équivalents à a |= . op b. Alors,
+= 1 peut être utilisé pour incrémenter des valeurs.

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

Complexe missions
Beaucoup plus de choses sont autorisées sur le côté gauche d'une affectation jq que dans la plupart
langues. Nous avons déjà vu des accès aux champs simples sur le côté gauche, et ce n'est pas
surprise que les accès aux tableaux fonctionnent aussi bien :

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

Ce qui peut surprendre, c'est que l'expression de gauche peut produire plusieurs
résultats, se référant à différents points du document d'entrée :

.posts[].comments |= . + ["c'est super"]

Cet exemple ajoute la chaîne « c'est génial » au tableau « commentaires » de chaque message dans
l'entrée (où l'entrée est un objet avec un champ "posts" qui est un tableau de posts).

Lorsque jq rencontre une affectation comme « a = b », il enregistre le « chemin » emprunté pour sélectionner un
partie du document d'entrée lors de l'exécution a. Ce chemin est ensuite utilisé pour trouver quelle partie de
l'entrée à modifier lors de l'exécution de l'affectation. N'importe quel filtre peut être utilisé sur le
côté gauche d'un égal - les chemins qu'il sélectionne à partir de l'entrée seront l'endroit où le
l'affectation est effectuée.

C'est une opération très puissante. Supposons que nous voulions ajouter un commentaire aux articles de blog, en utilisant
la même entrée "blog" ci-dessus. Cette fois, nous voulons seulement commenter les articles écrits par
"stédolan". Nous pouvons trouver ces messages en utilisant la fonction « sélectionner » décrite précédemment :

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

Les chemins fournis par cette opération pointent vers chacun des messages que "stedolan" a écrit, et
nous pouvons commenter chacun d'eux de la même manière que nous l'avons fait auparavant :

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

MODULES

jq a un système de bibliothèque/module. Les modules sont des fichiers dont les noms se terminent par .jq.

Les modules importés par un programme sont recherchés dans un chemin de recherche par défaut (voir ci-dessous). Les
importer ainsi que comprendre Les directives permettent à l'importateur de modifier ce chemin.

Les chemins dans un chemin de recherche sont sujets à diverses substitutions.

Pour les chemins commençant par "~/", le répertoire personnel de l'utilisateur est remplacé par "~".

Pour les chemins commençant par "$ORIGIN/", le chemin de l'exécutable jq est remplacé par
"$ORIGINE".

Pour les chemins commençant par "./" ou les chemins qui sont ".", le chemin du fichier inclus est
remplacé par ".". Pour les programmes de niveau supérieur donnés sur la ligne de commande, le
répertoire est utilisé.

Les directives d'importation peuvent éventuellement spécifier un chemin de recherche auquel la valeur par défaut est ajoutée.

Le chemin de recherche par défaut est le chemin de recherche donné au -L option de ligne de commande, sinon
["~/.jq", "$ORIGINE/../lib/jq", "$ORIGINE/../ lib"].

Les éléments de chemin de chaîne nuls et vides terminent le traitement du chemin de recherche.

Une dépendance avec le chemin relatif "foo/bar" serait recherchée dans "foo/bar.jq" et
"foo/bar/bar.jq" dans le chemin de recherche donné. Ceci est destiné à permettre aux modules d'être placés
dans un répertoire avec, par exemple, des fichiers de contrôle de version, des fichiers README, etc.
mais aussi pour permettre des modules à fichier unique.

Les composants consécutifs portant le même nom ne sont pas autorisés pour éviter les ambiguïtés (par exemple,
"foo/foo").

Par exemple, avec -L$HOME/.jq un module foo peuvent être trouvés dans $HOME/.jq/foo.jq ainsi que
$HOME/.jq/foo/foo.jq.

Si "$HOME/.jq" est un fichier, il provient du programme principal.

importer Chaîne de chemin relatif as Nom [ ] ;
Importe un module trouvé au chemin donné par rapport à un répertoire dans un chemin de recherche. Un ".jq"
suffixe sera ajouté à la chaîne de chemin relatif. Les symboles du module sont préfixés par
"NOM::".

Les métadonnées facultatives doivent être une expression jq constante. Ce devrait être un objet avec des clés
comme "page d'accueil" et ainsi de suite. Pour le moment, jq n'utilise que la clé/valeur de "recherche" du
métadonnées. Les métadonnées sont également mises à disposition des utilisateurs via le moduleméta intégré.

La clé « recherche » dans les métadonnées, si elle est présente, doit avoir une valeur de chaîne ou de tableau (tableau
de cordes); il s'agit du chemin de recherche à préfixer au chemin de recherche de niveau supérieur.

comprendre Chaîne de chemin relatif [ ] ;
Importe un module trouvé au chemin donné par rapport à un répertoire dans un chemin de recherche comme s'il
ont été inclus en place. Un suffixe ".jq" sera ajouté à la chaîne de chemin relatif. le
les symboles du module sont importés dans l'espace de noms de l'appelant comme si le contenu du module avait
été inclus directement.

Les métadonnées facultatives doivent être une expression jq constante. Ce devrait être un objet avec des clés
comme "page d'accueil" et ainsi de suite. Pour le moment, jq n'utilise que la clé/valeur de "recherche" du
métadonnées. Les métadonnées sont également mises à disposition des utilisateurs via le moduleméta intégré.

importer Chaîne de chemin relatif as $NOM [ ] ;
Importe un fichier JSON trouvé au chemin donné par rapport à un répertoire dans un chemin de recherche. UNE
Le suffixe ".json" sera ajouté à la chaîne de chemin relatif. Les données du fichier seront
disponible en $NOM::NOM.

Les métadonnées facultatives doivent être une expression jq constante. Ce devrait être un objet avec des clés
comme "page d'accueil" et ainsi de suite. Pour le moment, jq n'utilise que la clé/valeur de "recherche" du
métadonnées. Les métadonnées sont également mises à disposition des utilisateurs via le moduleméta intégré.

La clé « recherche » dans les métadonnées, si elle est présente, doit avoir une valeur de chaîne ou de tableau (tableau
de cordes); il s'agit du chemin de recherche à préfixer au chemin de recherche de niveau supérieur.

module ;
Cette directive est entièrement facultative. Ce n'est pas nécessaire pour un bon fonctionnement. Ça sert
uniquement dans le but de fournir des métadonnées qui peuvent être lues avec le moduleméta intégré.

Les métadonnées doivent être une expression jq constante. Ce devrait être un objet avec des clés comme
"page d'accueil". Pour le moment, jq n'utilise pas ces métadonnées, mais elles sont mises à la disposition des utilisateurs
via le moduleméta intégré.

moduleméta
Prend un nom de module en entrée et génère les métadonnées du module en tant qu'objet, avec le
les importations du module (y compris les métadonnées) en tant que valeur de tableau pour la clé "deps".

Les programmes peuvent l'utiliser pour interroger les métadonnées d'un module, qu'ils pourraient ensuite utiliser pour, par
par exemple, recherchez, téléchargez et installez les dépendances manquantes.

Utiliser jq en ligne en utilisant les services onworks.net