jq-クラウドでのオンライン

プログラム：

NAME

jq -コマンドラインJSONプロセッサ

SYNOPSIS

jq [オプション...] filter [ファイル...]

jq 選択、反復、削減など、さまざまな方法でJSONを変換できます
JSONドキュメントのマングリング。 たとえば、コマンドを実行します jq ´map（.price） | 追加 意志
JSONオブジェクトの配列を入力として受け取り、それらの「価格」フィールドの合計を返します。

jq テキスト入力も受け入れることができますが、デフォルトでは、 jq JSONエンティティのストリームを読み取ります
（数字やその他のリテラルを含む）から stdin。 空白は分離するためにのみ必要です
1や2などのエンティティ、およびtrueとfalse。 XNUMXつ以上 ファイル 指定することができます
場合 jq 代わりにそれらからの入力を読み取ります。

　 オプション で説明されています 呼び出し JQ セクション; それらは主に入力と出力に関係します
フォーマット。 ザ・ filter jq言語で書かれており、変換方法を指定します
入力ファイルまたはドキュメント。

FILTERS

jqプログラムは「フィルター」です。入力を受け取り、出力を生成します。 がたくさんあります
オブジェクトの特定のフィールドを抽出したり、数値をに変換したりするための組み込みフィルター
文字列、またはその他のさまざまな標準タスク。

フィルタはさまざまな方法で組み合わせることができます-XNUMXつのフィルタの出力をパイプで接続できます
別のフィルター、またはフィルターの出力を配列に収集します。

一部のフィルターは複数の結果を生成します。たとえば、すべてのフィルターを生成するフィルターがあります。
その入力配列の要素。 そのフィルターをXNUMX番目にパイプすると、XNUMX番目のフィルターが実行されます。
配列の各要素。 一般的に、ループと反復で行われること
他の言語では、jqでフィルターを接着するだけで実行できます。

すべてのフィルターには入力と出力があることを覚えておくことが重要です。 リテラルでさえ
「hello」や42はフィルターです。入力を受け取りますが、常に同じリテラルを生成します。
出力。 加算のようにXNUMXつのフィルターを組み合わせる操作は、通常、同じ入力をフィードします
両方に、結果を組み合わせます。 したがって、平均化フィルターを次のように実装できます。 加えます / 長さ
-入力配列を両方にフィー​​ドします 加えます フィルターと 長さ フィルタしてから実行する
分裂。

しかし、それは私たちより進んでいます。 :)もっと簡単なものから始めましょう：

呼び出し JQ

jqフィルターはJSONデータのストリームで実行されます。 jqへの入力は、次のシーケンスとして解析されます。
提供されたフィルターをXNUMXつずつ通過する空白で区切られたJSON値
時間。 フィルタの出力は、次のシーケンスとして標準出力に書き込まれます。
空白で区切られたJSONデータ。

注：シェルの引用ルールに注意することが重要です。 原則として、
jqプログラムは常に引用符で囲みます（一重引用符で囲みます）。
jqの特別な意味は、シェルのメタ文字でもあります。 例えば、 jq 「フー」 失敗します
ほとんどのUnixシェルは、 jq foo、一般的に失敗します
なぜなら foo is 定義済みの。 Windowsコマンドシェル（cmd.exe）を使用する場合は、
コマンドラインで指定する場合は、jqプログラムを二重引用符で囲みます（ -f
プログラムファイル オプション）、ただし、jqプログラムの二重引用符は円記号をエスケープする必要があります。

コマンドラインを使用して、jqが入力と出力を読み書きする方法に影響を与えることができます
オプション：

· - バージョン:

jqバージョンを出力し、ゼロで終了します。

· --seq:

アプリケーション/ json-seq jqの入力でJSONテキストを分離するためのMIMEタイプスキーム
と出力。 これは、ASCII RS（レコード区切り文字）文字が前に印刷されることを意味します
出力の各値とASCIILF（改行）は、すべての出力の後に出力されます。 入力
解析に失敗したJSONテキストは無視され（ただし警告されます）、すべて破棄されます
次のRSまでの後続の入力。 これにより、jqの出力も解析されます。
--seq オプションを選択します。

· - ストリーム:

ストリーミング方式で入力を解析し、パスとリーフの値の配列を出力します
（スカラーと空の配列または空のオブジェクト）。 例えば、 「あ」 になる [[]、 "a"],
[[]、 "a"、["b"]] になる [[0]、[]], [[1]、 "a"], [[1,0]、 "b"].

これは、非常に大きな入力を処理する場合に役立ちます。 これをと組み合わせて使用​​します
フィルタリングと 減らします & foreachの 大きな入力を段階的に減らす構文。

· - 啜る/-s:

入力内の各JSONオブジェクトに対してフィルターを実行する代わりに、入力全体を読み取ります
大きな配列にストリーミングし、フィルターをXNUMX回だけ実行します。

· --生入力/-R:

入力をJSONとして解析しないでください。 代わりに、テキストの各行がフィルターに渡されます。
ストリング。 と組み合わせる場合 - 啜る、次に、入力全体がフィルターに渡されます。
単一の長い文字列。

· --null-入力/-n:

入力をまったく読まないでください！ 代わりに、フィルターはを使用して一度実行されます ヌル 入力として。
これは、jqを単純な計算機として使用する場合、またはからJSONデータを構築する場合に役立ちます。
スクラッチ。

· --コンパクト出力 / -c:

デフォルトでは、jqはJSON出力をきれいに印刷します。 このオプションを使用すると、より多くの結果が得られます
代わりに、各JSONオブジェクトをXNUMX行に配置することでコンパクトな出力を実現します。

· - タブ:

XNUMXつのスペースではなく、インデントレベルごとにタブを使用します。

· - インデント n:

インデントには、指定された数のスペース（8以下）を使用します。

· -- 色出力 / -C & -モノクロ出力 / -M:

デフォルトでは、jqは端末に書き込む場合、色付きのJSONを出力します。 あなたはそれを強制することができます
を使用してパイプやファイルに書き込んでも色を生成します -C、で色を無効にします -M.

· --ascii-出力 / -a:

jqは通常、指定された入力であっても、非ASCIIUnicodeコードポイントをUTF-8として出力します。
それらをエスケープシーケンスとして（ "\ u03bc"など）。 このオプションを使用すると、jqを強制的に
すべての非ASCII文字が同等のものに置き換えられた純粋なASCII出力を生成します
エスケープシーケンス。

· -バッファなし

各JSONオブジェクトが印刷された後に出力をフラッシュします（低速のパイプを使用している場合に便利です）
データソースをjqに接続し、jqの出力を他の場所にパイプします）。

· --ソートキー / -S:

各オブジェクトのフィールドを、ソートされた順序でキーとともに出力します。

· --生出力 / -r:

このオプションを使用すると、フィルターの結果が文字列の場合、直接書き込まれます
引用符付きのJSON文字列としてフォーマットされるのではなく、標準出力に変換されます。 これはできます
jqフィルターを非JSONベースのシステムと通信させるのに役立ちます。

· --結合出力 / -j:

いいね -r ただし、jqは各出力の後に改行を出力しません。

· -f ファイル名 / --from-ファイル ファイル名:

awkの-fオプションのように、コマンドラインからではなくファイルからフィルターを読み取ります。 君
´＃´を使用してコメントすることもできます。

· -Lディレクトリ / -L ディレクトリにジョブを開始します。:

プリペンド ディレクトリにジョブを開始します。 モジュールの検索リストに移動します。 このオプションを使用する場合は、
組み込みの検索リストが使用されます。 以下のモジュールに関するセクションを参照してください。

· -e / -終了ステータス:

最後の出力値がどちらでもなかった場合、jqの終了ステータスを0に設定します false また ヌル,
最後の出力値がいずれかであった場合は1 false or ヌル、または有効な結果がなかった場合は4
生産。 通常、使用上の問題やシステムエラーが発生した場合、jqは2で終了します。3
jqプログラムのコンパイルエラーが発生した場合は0、jqプログラムが実行された場合はXNUMX。

· --arg 名 値:

このオプションは、事前定義された変数として値をjqプログラムに渡します。 jqを実行する場合
　 --arg foo バーをタップし、その後、 $ foo プログラムで利用可能であり、価値があります "バー".
注意してください 値 文字列として扱われるので、 --arg foo 123 バインドします $ foo 〜へ "123".

· --argjson 名 JSONテキスト:

このオプションは、JSONでエンコードされた値を事前定義された変数としてjqプログラムに渡します。 もしも
jqを実行します --argjson foo 123をタップし、その後、 $ foo プログラムで利用可能であり、
値 123.

· --slurpfile 変数名 ファイル名:

このオプションは、指定されたファイル内のすべてのJSONテキストを読み取り、の配列をバインドします
指定されたグローバル変数に解析されたJSON値。 jqを実行する場合 --argfile foo バー,
その後 $ foo プログラムで利用可能であり、要素が対応する配列を持っています
名前の付いたファイル内のテキスト バー.

· --argfile 変数名 ファイル名:

使用禁止。 つかいます --slurpfile を代わりにお使いください。

（このオプションは次のようなものです --slurpfile、ただし、ファイルにテキストがXNUMXつしかない場合、それは
使用される場合、それ以外の場合はテキストの配列が次のように使用されます --slurpfile.)

· -- テストの実行 [ファイル名]:

指定されたファイルまたは標準入力でテストを実行します。 これは与えられた最後のオプションでなければなりません
また、前述のすべてのオプションを尊重するわけではありません。 入力はコメント行で構成され、空です
行、およびプログラム行とそれに続くXNUMXつの入力行、出力の行と同じ数
期待される（出力ごとにXNUMXつ）、および終了する空の行。 コンパイル失敗テスト
「%% FAIL」のみを含む行で開始し、次にプログラムを含む行を
コンパイルしてから、実際と比較するためのエラーメッセージを含む行。

このオプションは逆方向に変更される可能性があることに注意してください-互換性がありません。

BASIC FILTERS

.
絶対的に最も単純な（そして最も興味のない）フィルターは .。 これは、
入力し、出力として変更せずに生成します。

jqはデフォルトですべての出力をきれいに出力するので、この簡単なプログラムは次のような便利な方法になります。
たとえば、からのJSON出力のフォーマット curl.

jq´.´
"こんにちは世界！"
=>「Hello、world！」

.foo、 .foo.bar
もっとも単純な 便利 フィルターは .foo。 JSONオブジェクト（別名辞書またはハッシュ）を次のように指定した場合
入力の場合、キー「foo」で値を生成します。存在しない場合はnullを生成します。

キーに特殊文字が含まれている場合は、次のように二重引用符で囲む必要があります。
この： 。 "foo $".

フォームのフィルター .foo.bar に相当します .foo | .bar.

jq´.foo´
{"foo"：42、 "bar"： "あまり面白くないデータ"}
=> 42

jq´.foo´
{"notfoo"：true、 "alsonotfoo"：false}
=> null

jq´。["foo"] ´
{"foo"：42}
=> 42

.foo？
と同じように .foo、ただし、エラーが発生しても出力されない場合 . 配列またはオブジェクトではありません。

jq´.foo？ ´
{"foo"：42、 "bar"： "あまり面白くないデータ"}
=> 42

jq´.foo？ ´
{"notfoo"：true、 "alsonotfoo"：false}
=> null

jq´。["foo"]？ ´
{"foo"：42}
=> 42

jq´ [。foo？] ´
【1,2]
=> []

。[ ]、 。[2]、 。[10:15]
次のような構文を使用して、オブジェクトのフィールドを検索することもできます。 。["foo"] （上記の.fooは
これの短縮版）。 キーが整数の場合、これは配列でも機能します。
配列は（javascriptのように）ゼロベースなので、 [2] 配列のXNUMX番目の要素を返します。

　 。[10:15] 構文を使用して、配列のサブ配列または文字列のサブ文字列を返すことができます。
によって返される配列 。[10:15] インデックス5の要素を含む長さ10になります
（包括的）インデックス15（排他的）。 どちらのインデックスも負の値になる可能性があります（この場合、カウントされます
配列の最後から逆方向に）、または省略されます（この場合、開始または
配列の終わり）。

　 [2] 構文を使用して、指定されたインデックスの要素を返すことができます。 負の指数は
許可され、-1は最後の要素を参照し、-2は最後からXNUMX番目の要素を参照します。
などがあります。

　 .foo 構文は、単純なキー、つまりすべて英数字のキーに対してのみ機能します。
。[ ] コロンやドットなどの特殊文字を含むキーで機能します。 にとって
例 。["foo :: bar"] & 。["foo.bar"] 働きながら .foo :: bar & .foo.bar しないでしょう。

　 ? 「演算子」は、次のようにスライス演算子と一緒に使用することもできます。 。[10:15]？、出力
入力がスライス可能な値。

jq´。[0] ´
[{"name"： "JSON"、 "good"：true}、{"name"： "XML"、 "good"：false}]
=> {"name"： "JSON"、 "good"：true}

jq´。[2] ´
[{"name"： "JSON"、 "good"：true}、{"name"： "XML"、 "good"：false}]
=> null

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] ´
【1,2,3]
=> 2

。[]
あなたが使用している場合 。[索引] 構文ですが、インデックスを完全に省略した場合、 を
配列の要素。 ランニング 。[] 入力で 【1,2,3] 数字はXNUMXつになります
単一の配列としてではなく、個別の結果。

これをオブジェクトで使用することもでき、オブジェクトのすべての値を返します。

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

。[]？
いいね 。[]、ただし、の場合はエラーは出力されません。 配列またはオブジェクトではありません。

,
XNUMXつのフィルターがコンマで区切られている場合、入力は両方に入力されます。
複数の出力になります。最初に、左の式によって生成されたすべての出力、および
次に、右によって生成されたすべての出力。 たとえば、フィルター .foo、 。バー、生産する
「foo」フィールドと「bar」フィールドの両方を別々の出力として。

jq´.foo、.bar´
{"foo"：42、 "bar"： "something other"、 "baz"：true}
=> 42、「何か他のもの」

jq´.user、.projects [] ´
{"user"： "stedolan"、 "projects"：["jq"、 "wikiflow"]}
=> "stedolan"、 "jq"、 "wikiflow"

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

|
| オペレーターは、左側のフィルターの出力をにフィードすることにより、XNUMXつのフィルターを組み合わせます
右側のものの入力。 それは、Unixシェルのパイプとほとんど同じです。
あなたはそれに慣れています。

左側のものが複数の結果を生成する場合、右側のものは
それらの結果のそれぞれ。 だから、式 。[] | .foo それぞれの「foo」フィールドを取得します
入力配列の要素。

jq´。[] | 。名前
[{"name"： "JSON"、 "good"：true}、{"name"： "XML"、 "good"：false}]
=> "JSON"、 "XML"

TYPES そして VALUES

jqは、JSONと同じデータ型のセット（数値、文字列、ブール値、配列、
オブジェクト（JSONで言えば、文字列キーのみのハッシュ）、および「null」。

ブール値、null、文字列、および数値は、javascriptと同じ方法で記述されます。 と同じように
jqの他のすべて、これらの単純な値は入力を受け取り、出力を生成します- 42 　
入力を受け取り、それを無視し、代わりに42を返す有効なjq式。

配列 建設 - []
JSONの場合と同様に、 [] のように、配列を構築するために使用されます 【1,2,3]。 配列の要素は
任意のjq式である。 すべての式によって生成されたすべての結果が収集されます
XNUMXつの大きな配列に。 これを使用して、既知の量の値から配列を作成できます
（のような [.foo、 。バー、 .バズ]）または、フィルターのすべての結果を配列に「収集」します（
in [.items []。name])

「、」演算子を理解すると、jqの配列構文を別の方法で確認できます。
光：表現 【1,2,3] カンマ区切りの配列に組み込みの構文を使用していません。
しかし、代わりに適用しています [] 式1,2,3（これは
XNUMXつの異なる結果が生成されます）。

フィルタをお持ちの場合 X これはXNUMXつの結果を生成し、次に式 [X] を生成します
単一の結果、XNUMXつの要素の配列。

jq´ [。user、.projects []] ´
{"user"： "stedolan"、 "projects"：["jq"、 "wikiflow"]}
=> ["stedolan"、 "jq"、 "wikiflow"]

オブジェクト - {}
JSONのように、 {} 次のように、オブジェクト（別名辞書またはハッシュ）を作成するためのものです。 {"a"： 42、
「b」： 17/XNUMX/XNUMX}.

キーが「賢明」（すべてアルファベット文字）の場合、引用符は省略できます。
値は任意の式にすることができます（ただし、それが
複雑なもの）、これは{}式の入力に適用されます（すべてのフィルターを覚えておいてください）
入力と出力があります）。

{foo：.bar}

JSONオブジェクトを生成します {"foo"： 42/XNUMX/XNUMX} JSONオブジェクトが与えられた場合 {"バー"：42、 "baz"：43}.
これを使用して、オブジェクトの特定のフィールドを選択できます。入力がオブジェクトである場合
「user」、「title」、「id」、「content」の各フィールドで、「user」と「title」だけが必要な場合は、次のことができます。
書きます

{ユーザー：.user、タイトル：.title}

これは非常に一般的であるため、ショートカット構文があります。 {ユーザー、 題名}.

式のXNUMXつが複数の結果を生成する場合、複数の辞書は次のようになります。
生産。 入力の場合

{"user"： "stedolan"、 "titles"：["JQ Primer"、 "More JQ"]}

それから式

{ユーザー、タイトル：.titles []}

XNUMXつの出力を生成します。

{"user"： "stedolan"、 "title"： "JQ Primer"}
{"user"： "stedolan"、 "title"： "More JQ"}

キーを括弧で囲むと、式として評価されます。 とともに
上記と同じ入力、

{（.user）：. titles}

生産する

{"stedolan"：["JQ Primer"、 "More JQ"]}

jq´ {user、title：.titles []} ´
{"user"： "stedolan"、 "titles"：["JQ Primer"、 "More JQ"]}
=> {"user"： "stedolan"、 "title"： "JQ Primer"}、{"user"： "stedolan"、 "title"： "More JQ"}

jq´ {（。user）：. titles} ´
{"user"： "stedolan"、 "titles"：["JQ Primer"、 "More JQ"]}
=> {"stedolan"：["JQ Primer"、 "More JQ"]}

ビルティン オペレーター そして 関数

一部のjq演算子（たとえば、 +）彼らのタイプに応じて異なることをする
引数（配列、数値など）。 ただし、jqは暗黙的な型変換を行いません。 もしも
オブジェクトに文字列を追加しようとすると、エラーメッセージが表示され、結果は得られません。

追加 - +
オペレーター + XNUMXつのフィルターを取り、両方を同じ入力に適用し、
一緒に結果。 「追加」の意味は、関係するタイプによって異なります。

· 数字 通常の算術で追加されます。

· 配列 より大きな配列に連結されることによって追加されます。

· 弦 より大きな文字列に結合することで追加されます。

· オブジェクト マージ、つまり、両方からすべてのキーと値のペアを挿入することによって追加されます
オブジェクトを単一の結合されたオブジェクトに。 両方のオブジェクトに同じ値が含まれている場合
キー、右側のオブジェクト + 勝ちます。 （再帰的マージの場合は、 * オペレーター。）

ヌル 任意の値に追加でき、他の値は変更されずに返されます。

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} ´
ヌル
=> {"a"：42、 "b"：2、 "c"：3}

引き算 - -
数値の通常の算術減算と同様に、 - 演算子は配列で使用できます
最初の配列からXNUMX番目の配列の要素のすべての出現を削除します。

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

jq´。 -["xml"、 "yaml"] ´
["xml"、 "yaml"、 "json"]
=> ["json"]

乗算、 分割、 モジュロ - *, /, & %
これらの中置演算子は、XNUMXつの数値が与えられたときに期待どおりに動作します。 ゼロ除算は発生します
エラー。 x % y yを法としてxを計算します。

文字列に数値を掛けると、その文字列の連結が生成されます。
回。 "NS" * 0 生産する ヌル.

文字列を別の文字列で分割すると、最初の文字列がXNUMX番目の文字列を区切り文字として使用して分割されます。

XNUMXつのオブジェクトを乗算すると、それらが再帰的にマージされます。これは加算のように機能しますが、両方の場合
オブジェクトには同じキーの値が含まれ、値はオブジェクトであり、XNUMXつはマージされます
同じ戦略で。

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}} ´
ヌル
=> {"k"：{"a"：0、 "b"：2、 "c"：3}}

jq´。[] | （1 /。）？´
[1,0、-1]
=> 1、-1

長さ
内蔵機能 長さ さまざまなタイプの値の長さを取得します。

・の長さ 文字列 含まれているUnicodeコードポイントの数です（
純粋なASCIIの場合、JSONでエンコードされたバイト単位の長さと同じです）。

・の長さ 配列 要素の数です。

・の長さ オブジェクト キーと値のペアの数です。

・の長さ ヌル ゼロです。

jq´。[] | 長さ ´[[1,2]、 "string"、{"a"：2}、null] => 2、6、1、0

キー、 キー_未分類
内蔵機能 キー、オブジェクトが与えられると、そのキーを配列で返します。

キーは、Unicodeコードポイントの順序で「アルファベット順に」ソートされます。 これは注文ではありません
これは特定の言語では特に意味がありますが、
ロケール設定に関係なく、同じキーセットを持つ任意のXNUMXつのオブジェクトで同じです。

日時 キー 配列が与えられると、その配列の有効なインデックスを返します：整数
0から長さ-1まで。

　 キー_未分類 機能は次のようなものです キー、ただし、入力がオブジェクトの場合、キー
ソートされませんが、代わりにキーは大まかに挿入順になります。

jq「キー」
{"abc"：1、 "abcd"：2、 "Foo"：3}
=> ["Foo"、 "abc"、 "abcd"]

jq「キー」
【42,3,35]
=> [0,1,2]

has（key）
内蔵機能 持っています 入力オブジェクトが指定されたキーを持っているか、入力を持っているかを返します
配列には、指定されたインデックスに要素があります。

has（$ key） かどうかをチェックするのと同じ効果があります $ key 返された配列のメンバーです
by キーものの、 持っています より速くなります。

jq´map（has（ "foo"）） ´
[{"foo"：42}、{}]
=> [true、false]

jq´map（持っています（2）） ´
[[0,1]、["a"、 "b"、 "c"]]
=> [false、true]

in
内蔵機能 in 入力キーが指定されたオブジェクト、または入力インデックスにあることを返します
指定された配列の要素に対応します。 これは、本質的に、の逆バージョンです。
持っています.

jq´。[] | in（{"foo"：42}） ´
["foo"、 "bar"]
=>真、偽

jq´map（in（[0,1]）） ´
[2、0]
=> [false、true]

path（path_expression）
指定されたパス式の配列表現をで出力します .。 出力はの配列です
文字列（objects0のキーおよび/または数値（配列インデックス）。

パス式は次のようなjq式です .a、 だけでなく 。[]。 パスにはXNUMXつのタイプがあります
式：完全に一致するものと一致しないもの。 例えば、 .abc あります
完全一致パス式、 .a []。b そうではありません。

path（exact_path_expression） パス式の配列表現を生成します
に存在しなくても .、もし . is ヌル または配列またはオブジェクト。

パス（パターン） 一致するパスの配列表現を生成します パターン もし
パスはに存在します ..

パス式は通常の式と変わらないことに注意してください。 表現
path（.. | select（type == "boolean"）） のブール値へのすべてのパスを出力します .、そしてのみ
それらのパス。

jq´path（.a [0] .b） ´
ヌル
=> ["a"、0、 "b"]

jq´ [path（..）] ´
{"a"：[{"b"：1}]}
=> [[]、["a"]、["a"、0]、["a"、0、 "b"]]

del（path_expression）
内蔵機能 インクルード キーとそれに対応する値をオブジェクトから削除します。

jq´del（.foo） ´
{"foo"：42、 "bar"：9001、 "baz"：42}
=> {"bar"：9001、 "baz"：42}

jq´del（。[1、2]） ´
["foo"、 "bar"、 "baz"]
=> ["foo"]

to_entries、 from_entries、 with_entries
これらの関数は、オブジェクトとキーと値のペアの配列の間で変換を行います。 もしも to_entries
オブジェクトが渡され、次に k: v 入力のエントリ、出力配列には次のものが含まれます
{"鍵"： k, "価値"： v}.

from_entries 反対の変換を行い、 with_entries（foo） の略記です
to_entries | map（foo） | from_entries、すべてのキーに対して何らかの操作を行うのに役立ちます
オブジェクトの値。 from_entries キー、キー、名前、値、および値をキーとして受け入れます。

jq´to_entries´
{"a"：1、 "b"：2}
=> [{"key"： "a"、 "value"：1}、{"key"： "b"、 "value"：2}]

jq´from_entries´
[{"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（boolean_expression）
関数 select（foo） 次の場合、入力は変更されずに生成されます foo その入力に対してtrueを返し、
それ以外の場合は出力を生成しません。

リストのフィルタリングに役立ちます。 【1,2,3] | map（select（。 >= 2）） あなたを与えるだろう 【2,3].

jq´map（select（。> = 2）） ´
【1,5,3,0,7]
=> [5,3,7]

jq´。[] | select（.id == "second"） ´
[{"id"： "first"、 "val"：1}、{"id"： "second"、 "val"：2}]
=> {"id"： "second"、 "val"：2}

配列、 オブジェクト、 iterables、 ブール値、 数、 法線、 有限、 文字列、 ヌル、 値、
スカラー
これらのビルトインは、配列、オブジェクト、反復可能オブジェクト（配列または
オブジェクト）、ブール値、数値、正規数、有限数、文字列、null、null以外
それぞれ、値、および非反復可能。

jq´。[] | numbers´
[[]、{}、1、 "foo"、null、true、false]
=> 1

空の
空の 結果を返しません。 まったくありません。 でもない ヌル.

たまに便利です。 あなたがそれを必要とするかどうかあなたは知っているでしょう:)

jq ´1、空、2´
ヌル
=> 1、2

jq´ [1,2、empty、3] ´
ヌル
=> [1,2,3]

エラー（メッセージ）
のようにエラーを生成します .a nullとオブジェクト以外の値に適用されますが、
与えられたメッセージをエラーの値として使用します。

$ __ loc__
「file」キーと「line」キーを持ち、ファイル名と行番号を持つオブジェクトを生成します
コラボレー $ __ loc__ 値として発生します。

jq´try error（ "\（$ __ loc __）"）catch .´
ヌル
=> "{\" file \ "：\" \"、\"ライン1}"

map（x）、 map_values（x）
任意のフィルター用 x, map（x） 入力配列の要素ごとにそのフィルターを実行し、
出力に新しい配列を生成します。 マップ（。+ 1） の配列の各要素をインクリメントします
数字。

同様に、 map_values（x） 要素ごとにそのフィルターを実行しますが、
オブジェクトが渡されたときのオブジェクト。

map（x） に相当します [。[] | x]。 実際、これがその定義方法です。 同様に、
map_values（x） として定義される 。[] |= x.

jq´map（。+ 1） ´
【1,2,3]
=> [2,3,4]

jq´map_values（。+ 1） ´
{"a"：1、 "b"：2、 "c"：3}
=> {"a"：2、 "b"：3、 "c"：4}

パス、 パス（node_filter）、 リーフパス
パス 入力内のすべての要素へのパスを出力します（ただし、
を表す空のリスト。 自体）。

パス（f） パスを出力する値 f 本当です。 あれは、 パス（番号）
すべての数値へのパスを出力します。

リーフパス のエイリアスです パス（スカラー）; リーフパス is 非推奨の で削除されます
次のメジャーリリース。

jq´ [パス] ´
[1、[[]、{"a"：2}]]
=> [[0],[1],[1,0],[1,1],[1,1,"a"]]

jq´ [paths（scalars）] ´
[1、[[]、{"a"：2}]]
=> [[0]、[1,1、 "a"]]

加えます
フィルター 加えます 入力として配列を受け取り、出力として配列の要素を生成します
一緒に追加されました。 これは、タイプに応じて、合計、連結、またはマージを意味する場合があります
入力配列の要素-ルールは、 + オペレータ
（上記）

入力が空の配列の場合、 加えます 収益 ヌル.

jq「追加」
["a"、 "b"、 "c"]
=>「abc」

jq「追加」
[1、2、3]
=> 6

jq「追加」
[]
=> null

どれか、 any（条件）、 any（ジェネレーター; 状態）
フィルター どれか ブール値の配列を入力として受け取り、を生成します true 出力として
配列の要素のいずれかは true.

入力が空の配列の場合、 どれか 収益 false.

　 any（条件） formは、指定された条件を入力配列の要素に適用します。

　 any（ジェネレーター; 状態） フォームは、指定された条件をのすべての出力に適用します
与えられたジェネレータ。

jq´any´
[真/偽]
=> true

jq´any´
[false、false]
=> false

jq´any´
[]
=> false

全て、 all（条件）、 all（ジェネレーター; 状態）
フィルター を ブール値の配列を入力として受け取り、を生成します true 出力として
配列のすべての要素は true.

　 all（条件） formは、指定された条件を入力配列の要素に適用します。

　 all（ジェネレーター; 状態） フォームは、指定された条件をのすべての出力に適用します
与えられたジェネレータ。

入力が空の配列の場合、 を 収益 true.

jq「すべて」
[真/偽]
=> false

jq「すべて」
[本当、本当]
=> true

jq「すべて」
[]
=> true

[必要 1.5] 平らにする、 平らにする（深さ）
フィルター 平らにする ネストされた配列の配列を入力として受け取り、でフラットな配列を生成します。
元の配列内のすべての配列は、それらの値によって再帰的に置き換えられています。
引数を渡して、フラット化するネストのレベル数を指定できます。

平らにする(2) のようなものです 平らにする、ただし、深さはXNUMXレベルまでです。

jq「フラット化」
[1、[2]、[[3]]]
=> [1、2、3]

jq´平らにする（1） ´
[1、[2]、[[3]]]
=> [1、2、[3]]

jq「フラット化」
[[]]
=> []

jq「フラット化」
[{"foo"： "bar"}、[{"foo"： "baz"}]]
=> [{"foo"： "bar"}、{"foo"： "baz"}]

範囲（最大）、 range（from; upto） range（from; upto; by）
　 範囲 関数は数値の範囲を生成します。 range（4; 10） 6から4つの数値を生成します
（包括的）から10（排他的）。 数値は個別の出力として生成されます。 つかいます
[範囲（4; 10）] 範囲を配列として取得します。

0つの引数形式は、XNUMXから指定された数までの数を生成します。
1.

XNUMXつの引数形式は、から数値を生成します から 〜へ 件まで 1刻みで。

XNUMXつの引数形式は数値を生成します から 〜へ 件まで の増分で by.

jq´range（2; 4） ´
ヌル
=> 2、3

jq´ [range（2; 4）] ´
ヌル
=> [2,3]

jq´ [範囲（4）] ´
ヌル
=> [0,1,2,3]

jq´ [range（0; 10; 3）] ´
ヌル
=> [0,3,6,9]

jq´ [range（0; 10; -1）] ´
ヌル
=> []

jq´ [range（0; -5; -1）] ´
ヌル
=> [0,-1,-2,-3,-4]

床
　 床 関数は、数値入力のフロアを返します。

jq「フロア」
3.14159
=> 3

平方根
　 平方根 関数は、数値入力の平方根を返します。

jq´sqrt´
9
=> 3

に番号
　 に番号 関数はその入力を数値として解析します。 正しくフォーマットされて変換されます
文字列を同等の数値にし、数値をそのままにして、他のすべての文字列にエラーを与える
入力。

jq´。[] | tonumber´
[1、 "1"]
=> 1、1

ひも
　 ひも 関数は、入力を文字列として出力します。 文字列は変更されず、すべて
他の値はJSONでエンコードされています。

jq´。[] | tostring´
[1、 "1"、[1]]
=> "1"、 "1"、 "[1]"

type
　 type 関数は、引数の型を文字列として返します。これはnullのXNUMXつです。
ブール値、数値、文字列、配列、またはオブジェクト。

jq´map（type） ´
[0、false、[]、{}、null、 "hello"]
=> ["number"、 "boolean"、 "array"、 "object"、 "null"、 "string"]

無限、 いいえ、 無限です、 isnan、 無限、 正常です
一部の算術演算では、無限大と「数値ではない」（NaN）値が生成される場合があります。 ザ
無限大 ビルトインリターン true その入力が無限の場合。 The イスナン ビルトインリターン true
入力がNaNの場合。 The 無限 ビルトインは正の無限値を返します。 ザ ナン
ビルトインはNaNを返します。 The 正常です 組み込みは、入力が正規数の場合にtrueを返します。

ゼロによる除算はエラーを発生させることに注意してください。

現在、無限大、NaN、および準法線で動作するほとんどの算術演算は、
エラーを発生させます。

jq´。[] | （無限*。）<0´
[-1、1]
=>真、偽

jq´infinite、nan | タイプ
ヌル
=>「番号」、「番号」

ソート、 sort_by（path_expression）
　 sort 関数は入力をソートします。入力は配列でなければなりません。 値はでソートされます
次の順序：

· ヌル

· false

· true

・数字

・文字列、アルファベット順（Unicodeコードポイント値による）

・配列、辞書式順序

・オブジェクト

オブジェクトの順序は少し複雑です。まず、オブジェクトを比較して比較します。
キーのセット（ソートされた順序の配列として）、およびそれらのキーが等しい場合、値は次のようになります。
キーごとに比較。

sort オブジェクトの特定のフィールドで並べ替えたり、jqフィルターを適用したりするために使用できます。

sort_by（foo） の結果を比較してXNUMXつの要素を比較します foo 各要素に。

jq´sort´
[8,3、null、6]
=> [null、3,6,8]

jq´sort_by（.foo） ´
[{"foo"：4、 "bar"：10}、{"foo"：3、 "bar"：100}、{"foo"：2、 "bar"：1}]
=> [{"foo"：2、 "bar"：1}、{"foo"：3、 "bar"：100}、{"foo"：4、 "bar"：10}]

group_by（path_expression）
group_by（.foo） 配列を入力として受け取り、同じ要素を持つ要素をグループ化します .foo フィールド
別々の配列に分割し、これらすべての配列をより大きな配列の要素として生成します。
の値でソート .foo フィールド。

フィールドアクセスだけでなく、任意のjq式を代わりに使用できます .foo。 仕分け
順序は、 sort 上記の機能。

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}]]

分 max、 min_by（path_exp）、 max_by（path_exp）
入力配列の最小要素または最大要素を見つけます。

　 min_by（path_exp） & max_by（path_exp） 関数を使用すると、特定のを指定できます
調べるフィールドまたはプロパティ、例： min_by（.foo） 最小のオブジェクトを検索します foo
フィールド。

jq´min´
【5,4,2,7]
=> 2

jq´max_by（.foo） ´
[{"foo"：1、 "bar"：14}、{"foo"：2、 "bar"：3}]
=> {"foo"：2、 "bar"：3}

個性的、 unique_by（path_exp）
　 ユニーク 関数は入力として配列を受け取り、同じ要素の配列を生成します。
重複を削除して、並べ替えられた順序。

　 unique_by（path_exp） 関数は、によって取得された値ごとにXNUMXつの要素のみを保持します
引数を適用します。 すべてからXNUMXつの要素を取り出して配列を作成することと考えてください
によって生成されたグループ グループヘッド.

jq「ユニーク」
【1,2,5,3,5,3,1,3]
=> [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（length） ´
[「分厚い」、「ベーコン」、「子猫」、「蝉」、「アスパラガス」]
=> ["ベーコン"、 "分厚い"、 "アスパラガス"]

逆
この関数は配列を反転します。

jq「リバース」
【1,2,3,4]
=> [4,3,2,1]

contains（element）
フィルター 含む（b） bが入力内に完全に含まれている場合、trueを生成します。 A
BがAの部分文字列である場合、文字列Bは文字列Aに含まれます。配列Bはに含まれます。
Bのすべての要素がAの任意の要素に含まれている場合は、配列A。オブジェクトBは
Bのすべての値がAの値に含まれている場合、オブジェクトAに含まれます。
同じキー。 他のすべてのタイプは、それらが等しい場合、互いに含まれていると見なされます。

jq´contains（ "bar"） ´
「foobar」
=> true

jq´contains（["baz"、 "bar"]） ´
["foobar"、 "foobaz"、 "blarp"]
=> true

jq´contains（["bazzzzz"、 "bar"]） ´
["foobar"、 "foobaz"、 "blarp"]
=> false

jq´contains（{foo：12、bar：[{barp：12}]}） ´
{"foo"：12、 "bar"：[1,2、{"barp"​​：12、 "blip"：13}]}
=> true

jq´contains（{foo：12、bar：[{barp：15}]}） ´
{"foo"：12、 "bar"：[1,2、{"barp"​​：12、 "blip"：13}]}
=> false

インデックス
のインデックスを含む配列を出力します . コラボレー s 発生します。 入力は配列である可能性があります。
どちらの場合 s が配列の場合、インデックス出力は、のすべての要素が .
のそれらに一致します s.

jq´indices（ "、"） ´
「a、b、cd、efg、hijk」
=> [3,7,12]

jq´索引（1） ´
【0,1,2,1,3,1,4]
=> [1,3,5]

jq´indices（[1,2]） ´
【0,1,2,3,1,4,2,5,1,2,6,7]
=> [1,8]

インデックス、 rindex（s）
最初のインデックスを出力します（index）または最後（インデックス）の発生 s 入力で。

jq´index（ "、"） ´
「a、b、cd、efg、hijk」
=> 3

jq´rindex（ "、"） ´
「a、b、cd、efg、hijk」
=> 12

内部
フィルター 内部（b） 入力がb内に完全に含まれている場合、trueが生成されます。 これ
本質的に、の逆バージョンです 含まれています.

jq´inside（ "foobar"） ´
"バー"
=> true

jq´inside（["foobar"、 "foobaz"、 "blarp"]） ´
["baz"、 "bar"]
=> true

jq´inside（["foobar"、 "foobaz"、 "blarp"]） ´
["bazzzzz"、 "bar"]
=> false

jq´inside（{"foo"：12、 "bar"：[1,2、{"barp"​​：12、 "blip"：13}]}） ´
{"foo"：12、 "bar"：[{"barp"​​：12}]}
=> true

jq´inside（{"foo"：12、 "bar"：[1,2、{"barp"​​：12、 "blip"：13}]}） ´
{"foo"：12、 "bar"：[{"barp"​​：15}]}
=> false

startwith（str）
出力 true もしも 。 指定された文字列引数で始まります。

jq´ [。[] | startupswith（ "foo"）] ´
["fo"、 "foo"、 "barfoo"、 "foobar"、 "barfoob"]
=> [false、true、false、true、false]

endswith（str）
出力 true もしも 。 指定された文字列引数で終了します。

jq´ [。[] | endswith（ "foo"）] ´
["foobar"、 "barfoo"]
=> [false、true]

組み合わせ、 組み合わせ（n）
入力配列内の配列の要素のすべての組み合わせを出力します。 与えられた場合
引数 n、それはのすべての組み合わせを出力します n 入力配列の繰り返し。

jq「組み合わせ」
[[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）
指定されたプレフィックス文字列で始まる場合は、削除された入力を出力します。

jq´ [。[] | ltrimstr（ "foo"）] ´
["fo"、 "foo"、 "barfoo"、 "foobar"、 "afoo"]
=> ["fo"、 ""、 "barfoo"、 "bar"、 "afoo"]

rtrimstr（str）
指定されたサフィックス文字列が最後にある場合は、それを削除して入力を出力します。

jq´ [。[] | rtrimstr（ "foo"）] ´
["fo"、 "foo"、 "barfoo"、 "foobar"、 "foob"]
=> ["fo"、 ""、 "bar"、 "foobar"、 "foob"]

爆発する
入力文字列を文字列のコードポイント番号の配列に変換します。

jq「爆発」
「foobar」
=> [102,111,111,98,97,114]

爆縮する
爆発の逆。

jq「implode」
[65、66、67]
=>「ABC」

split
セパレータ引数で入力文字列を分割します。

jq´split（ "、"） ´
「a、b、c、d、e、」
=> ["a"、 "b、c、d"、 "e"、 ""]

join（str）
引数を区切り文字として使用して、入力として指定された要素の配列を結合します。 それは
の逆 split：つまり、実行中 split（ "foo"） | join（ "foo"） 任意の入力文字列に対して
上記の入力文字列を返します。

jq´join（ "、"） ´
["a"、 "b、c、d"、 "e"]
=> "a、b、c、d、e"

ascii_downcase、 ascii_upcase
アルファベット文字（azおよびAZ）を次のように変換した入力文字列のコピーを発行します。
指定されたケース。

while（cond; 更新）
　 while（cond; 更新） 関数を使用すると、更新を繰り返し適用できます . まで 条件
は偽です。

注意してください while（cond; 更新） 内部的には再帰的なjq関数として定義されています。 再帰的
内の呼び出し while 次の場合、追加のメモリを消費しません update 最大でXNUMXつを生成します
各入力の出力。 以下の高度なトピックを参照してください。

jq´ [while（。<100;。* 2）] ´
1
=> [1,2,4,8,16,32,64]

until（cond; 次）
　 until（cond; 次） 関数を使用すると、式を繰り返し適用できます 次の,
最初に . その後、独自の出力に 条件 本当です。 たとえば、これを使用できます
階乗関数を実装します（以下を参照）。

注意してください until（cond; 次） 内部的には再帰的なjq関数として定義されています。 再帰的
内の呼び出し それまで（） 次の場合、追加のメモリを消費しません 次の 最大でXNUMXつを生成します
各入力の出力。 以下の高度なトピックを参照してください。

jq´ [。、1] | until（。[0] <1; [。[0] -1、。[1] *。[0]]）|。[1] ´
4
=> 24

recurse（f）、 再帰、 recurse（f; 調子）、 再帰_ダウン
　 recurse（f） 関数を使用すると、再帰構造を検索して抽出できます
すべてのレベルからの興味深いデータ。 入力がファイルシステムを表すと仮定します。

{"名前"： "/"、 "子供"：[
{"名前"： "/ binに"、 "子供達"： [
{"名前"： "/ bin / ls"、 "子供達"： []}、
{"名前"： "/bin/sh"、 "子供達"： []}]}、
{"名前"： "/ホーム"、 "子供達"： [
{"名前"： "/ home / stephen"、 "子供"：[
{"name"： "/ home / stephen / jq"、 "children"：[]}]}]}]}

ここで、存在するすべてのファイル名を抽出するとします。 取得する必要があります .nameの,
.children []。name, .children []。children []。name、 等々。 これは次の方法で実行できます。

recurse（.children []）| 。名前

引数なしで呼び出された場合、 再帰 に相当します recurse（。[]？）.

recurse（f） と同じです recurse（f; . != ヌル） 心配することなく使用できます
再帰の深さ。

recurse（f; 状態） を放出することから始まるジェネレータです。 その後、順番に放出します
。| f 、。 | f | f 、。 | f | f | f、...計算値が条件を満たす限り。 にとって
たとえば、すべての整数を生成するには、少なくとも原則として、次のように書くことができます。 recurse（。+ 1;
真）.

従来の理由で、 再帰_ダウン 呼び出しのエイリアスとして存在します 再帰 引数なし。
このエイリアスは考慮されます 非推奨の 次のメジャーリリースで削除されます。

の再帰呼び出し 再帰 いつでも追加のメモリを消費しません f で生産
各入力に対してほとんど単一の出力。

jq´recurse（.foo []） ´
{"foo"：[{"foo"：[]}、{"foo"：[{"foo"：[]}]}]}
=> {"foo"：[{"foo"：[]}、{"foo"：[{"foo"：[]}]}]}、{"foo"：[]}、{"foo"： [{"foo"：[]}]}、{"foo"：[]}

jq「recurse」
{"a"：0、 "b"：[1]}
=> {"a"：0、 "b"：[1]}、0、[1]、1

jq´recurse（。*。;。<20） ´
2
=> 2、4、16

..
の省略形 再帰 引数なし。 これは、XPathに似せることを目的としています //
オペレーター。 ご了承ください ..と 動作しません; 使用する .. | a 代わりは。 以下の例では、
.. | .a？ 「下」にあるオブジェクトのオブジェクトキー「a」のすべての値を見つけるには ..

jq´ .. | .a？ ´
[[{"a"：1}]]
=> 1

env
jqの環境を表すオブジェクトを出力します。

jq´env.PAGER´
ヌル
=>「少ない」

転置
ギザギザの可能性のある行列（配列の配列）を転置します。 行にはnullが埋め込まれるため、
結果は常に長方形です。

jq「転置」
[[1]、[2,3]]
=> [[1,2]、[null、3]]

bsearch（x）
bsearch（x）は、入力配列内のxの二分探索を実行します。 入力がソートされている場合
xが含まれている場合、bsearch（x）は配列内のインデックスを返します。 それ以外の場合、配列が
並べ替えると、（-1-ix）が返されます。ここで、ixは、配列が
ixにxを挿入した後もソートされます。 配列がソートされていない場合、bsearch（x）
おそらく関心のない整数を返します。

jq´bサーチ（0） ´
【0,1]
=> 0

jq´bサーチ（0） ´
【1,2,3]
=> -1

jq´bサーチ（4）$ ixとして| $ ix <0の場合。[-（1 + $ ix）] = 4else。 終わり
【1,2,3]
=> [1,2,3,4]

文字列 補間 - \（foo）
文字列内では、バックスラッシュの後に式をparens内に配置できます。 何でも
式の戻り値は文字列に補間されます。

jq´ "入力は\（。）でした。これは\（。+ 1）よりXNUMXつ少ないです" ´
42
=>「入力は42でした。これは43よりXNUMXつ少ないです」

変換 へ/から JSONの
　 トジソン & fromjson ビルトインは値をJSONテキストとしてダンプするか、JSONテキストを解析して
それぞれ値。 tojsonビルトインは、tostringが返すという点でtostringとは異なります。
文字列は変更されませんが、tojsonは文字列をJSON文字列としてエンコードします。

jq´ [。[] | tostring] ´
[1、 "foo"、["foo"]]
=> ["1"、 "foo"、 "[\" foo \ "]"]

jq´ [。[] | tojson] ´
[1、 "foo"、["foo"]]
=> ["1"、 "\" foo \ ""、 "[\" foo \ "]"]

jq´ [。[] | tojson | fromjson] ´
[1、 "foo"、["foo"]]
=> [1、 "foo"、["foo"]]

フォーマット ストリング & 逃げる
　 @フー 構文は、文字列のフォーマットとエスケープに使用されます。これは、URLの構築に役立ちます。
HTMLやXMLなどの言語のドキュメント。 @フー 上のフィルターとして使用できます
それ自体、可能なエスケープは次のとおりです。

@文章:

コー​​ル ひも、詳細については、その関数を参照してください。

@json:

入力をJSONとしてシリアル化します。

@html:

文字をマッピングすることにより、HTML / XMLエスケープを適用します <>＆ ´" 彼らの実体に
同等物 <, >, と, ', 「.

@uri:

すべての予約済みURI文字をにマッピングすることにより、パーセントエンコードを適用します ％XX シーケンス。

@csv:

入力は配列である必要があり、二重引用符付きのCSVとしてレンダリングされます。
文字列、および引用符は繰り返しによってエスケープされます。

@tsv:

入力は配列である必要があり、TSV（タブ区切り値）としてレンダリングされます。 各
入力配列はXNUMX行で出力されます。 フィールドは単一のタブで区切られます
（ASCII 0x09）。 入力文字の改行（ASCII 0x0a）、キャリッジリターン（ASCII
0x0d）、タブ（ASCII 0x09）およびバックスラッシュ（ASCII 0x5c）エスケープとして出力されます
シーケンス \n, \r, \t, \\ 。

@sh:

入力は、POSIXシェルのコマンドラインでの使用に適した形でエスケープされます。 の場合
入力は配列であり、出力は一連のスペースで区切られた文字列になります。

@ base64:

入力は、RFC64で指定されているbase4648に変換されます。

この構文は、便利な方法で文字列補間と組み合わせることができます。 あなたはフォローすることができます
@フー 文字列リテラルを含むトークン。 文字列リテラルの内容は 逃げる。
ただし、その文字列リテラル内で行われたすべての補間はエスケープされます。 例えば、

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

入力に対して次の出力を生成します {"検索"： "何 is jq？ "}:

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

URLのスラッシュ、疑問符などは一部であるため、エスケープされないことに注意してください。
文字列リテラルの。

jq´ @ html´
「これはx <yの場合に機能します」
=> "これはx <yの場合に機能します"

jq´ @ sh "echo \（。）" ´
「オハラエール」
=> "echo´O´ \\´´Hara´ \\´´s Ale´"

試合日
jqは、いくつかの基本的な日付処理機能と、いくつかの高レベルおよび低レベルを提供します
ビルトイン。 すべての場合において、これらのビルトインはUTCの時刻のみを処理します。

　 fromdateiso8601 ビルトインは、ISO8601形式の日時を秒数に解析します
Unixエポック（1970-01-01T00：00：00Z）以降。 The 今日iso8601 ビルトインはその逆を行います。

　 日付から ビルトインは日時文字列を解析します。 現在 日付から ISO8601のみをサポート
日時文字列ですが、将来的には、より多くの日時文字列を解析しようとします
フォーマット。

　 現在まで ビルトインはのエイリアスです 今日iso8601.

　 今 ビルトインは、Unixエポックからの現在の時刻を秒単位で出力します。

Cライブラリの時間関数への低レベルのjqインターフェイスも提供されています。 strptime,
ストラフタイム, エムクタイム, グラムタイム。 については、ホストオペレーティングシステムのドキュメントを参照してください。
によって使用されるフォーマット文字列 strptime & ストラフタイム。 注：これらは必ずしも安定しているとは限りません
特にローカリゼーション機能に関して、jqのインターフェース。

　 グラムタイム ビルトインはUnixエポックから数秒を消費し、「壊れた」を出力します
ダウンタイム」を表す数値の配列としての時間の表現（この順序で）：
年、月（ゼロベース）、月の日、時間、分
時間、秒、曜日、および年の日-すべて
特に明記されていない限り、XNUMXベース。

　 エムクタイム ビルトインは、によって出力された時間の「分解された時間」表現を消費します グラムタイム
& strptime.

　 strptime（fmt） ビルトインは、に一致する入力文字列を解析します FMT 口論。 出力はにあります
によって消費される「故障時間」表現 グラムタイム と出力 エムクタイム.

　 strftime（fmt） ビルトインは、指定された形式で時刻をフォーマットします。

のフォーマット文字列 strptime & ストラフタイム 典型的なCライブラリで説明されています
ドキュメンテーション。 ISO8601日時のフォーマット文字列は次のとおりです。 "％Y-％m-％dT％H：％M：％SZ".

jqは、一部のシステムでこの日付機能の一部またはすべてをサポートしない場合があります。

jq「fromdate」
"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

条件 そして 比較

==、 !=
式「a == b」は、aとbの結果が等しい場合（つまり、
それらが同等のJSONドキュメントを表す場合）、それ以外の場合は「false」。 特に、文字列
数値と等しいとは見なされません。 Javascriptを使用している場合、jq´s ==は次のようになります。
Javascriptの===-値が同じである場合にのみ等しい値を考慮します
同じ値。

！=は「等しくない」であり、´a！= b´は´a == b´の反対の値を返します。

jq´。[] == 1´
[1、1.0、 "1"、 "バナナ"]
=> true、true、false、false

if-then-else
if A その後 B ほかに C end と同じように動作します B if A falseまたは
nullですが、同じように動作します C さもないと。

falseまたはnullのチェックは、Javascriptに見られるよりも単純な「真実性」の概念です。
またはPythonですが、条件についてより明確にする必要がある場合があることを意味します
あなたが望む：例えば、文字列が空であるかどうかをテストすることはできません if .nameの その後 A ほかに B end,
あなたはもっと似たようなものが必要になります if （。名前 | 長さ） > 0 その後 A ほかに B end を代わりにお使いください。

条件Aが複数の結果を生成する場合、それらのいずれかが「真」であると見なされます
結果はfalseまたはnullではありません。 結果がゼロの場合、それは誤りと見なされます。

使用している場合は、さらに多くのケースを追加できます elif A その後 B 構文。

jq´if。 == 0その後

「ゼロ」elif。 == 1 then "one" else "many" end´ 2 => "many"

>, > =、 <=、 <
比較演算子 >, >=, <=, < 左の引数がより大きいかどうかを返します。
正しい引数以上、以下、または以下
（それぞれ）。

順序は、について説明したものと同じです。 sort、上記。

jq´。 <5´
2
=> true

および/または/
jqは、通常のブール演算子および/またはnotをサポートします。 彼らは同じ真実の基準を持っています
式-falseとnullは「false値」と見なされ、それ以外は
"本当の価値"。

これらの演算子のXNUMXつのオペランドが複数の結果を生成する場合、演算子自体
入力ごとに結果が生成されます。

実際には、演算子ではなく組み込み関数であるため、フィルターとして呼び出されます。
のように、特別な構文ではなく、パイプできるもの .foo & 。バー | .

これらのXNUMXつは、「true」と「false」の値のみを生成するため、本物の場合にのみ役立ちます。
の一般的なPerl / Python / Rubyイディオムではなく、ブール演算
「value_that_may_be_nullまたはデフォルト」。 この形式の「または」を使用する場合は、
条件を評価するのではなく、XNUMXつの値については、以下の「//」演算子を参照してください。

jq ´42と「文字列」 ´
ヌル
=> true

jq´（true、false）またはfalse´
ヌル
=>真、偽

jq´（true、true）および（true、false） ´
ヌル
=> true、false、true、false

jq´ [true、false | いいえ
ヌル
=> [false、true]

Alternative オペレータ - //
フォームのフィルター a // b と同じ結果を生成します a、もし a その他の結果を生成します
より false & ヌル。 さもないと、 a // b と同じ結果を生成します b.

これは、デフォルトを提供するのに役立ちます。 .foo // 1 に評価されます 1 ない場合 .foo
入力の要素。 それはどのように似ています or Pythonで使用されることもあります（jq´s or オペレータ
厳密にブール演算用に予約されています）。

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

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

トライキャッチ
を使用してエラーをキャッチできます 試します EXP キャッチ EXP。 最初の式が実行され、
失敗すると、XNUMX番目がエラーメッセージとともに実行されます。 ハンドラーの出力（
anyは、試行する式の出力であるかのように出力されます。

　 試します EXP フォームの使用 空の 例外ハンドラとして。

jq´try .a catch "。isnota object" ´
true
=>「。はオブジェクトではありません」

jq´ [。[] | try .a] ´
[{}、true、{"a"：1}]
=> [null、1]

jq´try error（ "some exception"）catch .´
true
=>「いくつかの例外」

破壊 でる of コントロール 構造
try / catchの便利な使用法は、次のような制御構造から抜け出すことです。 減らします, foreachの,
while、などなど。

例：

＃「break」が発生するまで式を繰り返します
＃エラーが発生したら、エラーを再発生させずに繰り返しを停止します。
＃しかし、キャッチされたエラーが「ブレーク」でない場合は、それを再発生させます。
repeat（exp）catch。== "break"を試してから、elseエラーを空にしてください。

jqには、名前付き字句ラベルを「ブレーク」または「移動（戻る）」するための構文があります。

ラベル$ out | ... $ outを破る..。

　 破る $ label_name 式により、プログラムは最も近いもののように動作します
（左の方です） ラベル $ label_name 生産 空の.

との関係 破る 対応する ラベル 字句です：ラベルは
休憩から「見える」。

から抜け出すには 減らしますたとえば、次の

ラベル$ out | 。[]を$ itemとして削減します（null;。== falseの場合は$ outをブレークしますelse ... end）

次のjqプログラムは、構文エラーを生成します。

$ outを破る

ラベルがないので $ out 見えます。

? オペレータ
　 ? 演算子、として使用 EXP？、はの省略形です 試します EXP.

jq´ [。[] |（.a）？] ´
[{}、true、{"a"：1}]
=> [null、1]

REGULAR 表現 （PCRE）

jqは、php、ruby、TextMate、Sublime Text、
などなので、ここでの説明はjqの詳細に焦点を当てます。

jq正規表現フィルターは、次のいずれかのパターンを使用して使用できるように定義されています。

文字列| FILTER（正規表現）
文字列| FILTER（正規表現;フラグ）
文字列| FILTER（[正規表現]）
文字列| FILTER（[正規表現、フラグ]）

ここで、* STRING、REGEX、およびFLAGSはjq文字列であり、jq文字列補間の対象です。 *
文字列補間後のREGEXは、有効なPCRE正規表現である必要があります。 * FILTERは test,
match または キャプチャー、以下に説明します。

FLAGSは、サポートされているフラグのXNUMXつ以上で構成される文字列です。

· g -グローバル検索（最初の一致だけでなく、すべての一致を検索）

· i -大文字と小文字を区別しない検索

· m -マルチラインモード（´.´は改行に一致します）

· n -空の一致を無視します

· p -sモードとmモードの両方が有効になっている

· s -単線モード（ ´^´->´ \ A´、 ´$´->´ \ Z´）

· l -可能な限り長い一致を見つける

· x -拡張正規表現形式（空白とコメントを無視）

xパターンの空白を一致させるには、\ sなどのエスケープを使用します。

・test（ "a \ sb"、 "x"）。

特定のフラグもREGEX内で指定できることに注意してください。

・jq -n´（ "test"、 "TEst"、 "teST"、 "TEST"）| test（ "（？i）te（？-i）st"） ´

評価：true、true、false、false。

[必要 1.5] test（val）、 test（正規表現; フラグ）
いいね match 、ただし、一致オブジェクトは返しません。 true or false かどうかのために
正規表現は入力と一致します。

jq´test（ "foo"） ´
「フー」
=> true

jq´。[] | test（ "abc＃スペースは無視されます"; "ix"） ´
["xabcd"、 "ABC"]
=>真、真

[必要 1.5] match（val）、 match（正規表現; フラグ）
match 見つかった一致ごとにオブジェクトを出力します。 一致には次のフィールドがあります。

· オフセット -入力の先頭からのUTF-8コードポイントのオフセット

· 長さ -一致のUTF-8コードポイントの長さ

· 文字列 -一致した文字列

· キャプチャ -キャプチャグループを表すオブジェクトの配列。

グループオブジェクトのキャプチャには、次のフィールドがあります。

· オフセット -入力の先頭からのUTF-8コードポイントのオフセット

· 長さ -このキャプチャグループのUTF-8コードポイントの長さ

· 文字列 -キャプチャされた文字列

· 名 -キャプチャグループの名前（または ヌル 名前がない場合）

何にも一致しなかったグループをキャプチャすると、-1のオフセットが返されます

jq´match（ "（abc）+"; "g"） ´
「abcabc」
=> {"offset"：0、 "length"：3、 "string"： "abc"、 "captures"：[{"offset"：0、 "length"：3、 "string"： "abc"、 " name "：null}]}、{" offset "：4、" length "：3、" string "：" abc "、" captions "：[{" offset "：4、" length "：3、" string " ： "abc"、 "name"：null}]}

jq´match（ "foo"） ´
「foobarfoo」
=> {"offset"：0、 "length"：3、 "string"： "foo"、 "captures"：[]}

jq´match（["foo"、 "ig"]） ´
「foobarFOO」
=> {"offset"：0、 "length"：3、 "string"： "foo"、 "captures"：[]}、{"offset"：8、 "length"：3、 "string"： "FOO "、"キャプチャ "：[]}

jq´match（ "foo（？ バー）？ foo ";" ig "） ´
「foobarfoo foofoo」
=> {"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、 "文字列"：null、 "名前"： "bar123"}]}

jq´ [match（ "。"; "g"）] | 長さ
「abc」
=> 3

[必要 1.5] キャプチャ（val）、 キャプチャ（正規表現; フラグ）
名前付きキャプチャをJSONオブジェクトに収集し、各キャプチャの名前をキーとして、
対応する値として一致した文字列。

jq´capture（ "（？ [az] +）-（？ [0-9] +） "） ´
「xyzzy-14」
=> {"a"： "xyzzy"、 "n"： "14"}

[必要 1.5] scan（regex）、 scan（regex; フラグ）
の正規表現に一致する入力の重複しないサブストリングのストリームを出力します
フラグが指定されている場合は、フラグに従います。 一致するものがない場合、ストリームは
空の。 各入力文字列のすべての一致をキャプチャするには、イディオムを使用します [ 式 ]、例えば [
scan（regex） ].

split（正規表現; フラグ）
下位互換性のために、 split 正規表現ではなく、文字列で分割します。

[必要 1.5] 分割（正規表現）、 splits（正規表現; フラグ）
これらは彼らと同じ結果を提供します split 対応するものですが、代わりにストリームとして
アレイ。

[必要 1.5] sub（正規表現; tostring） sub（正規表現; ストリング; フラグ）
入力文字列の正規表現の最初の一致を次のように置き換えて取得した文字列を出力します
ひも、補間後。 ひも jq文字列である必要があり、参照を含めることができます
名前付きキャプチャに。 名前付きキャプチャは、事実上、JSONオブジェクトとして表示されます（
によって構築された キャプチャー）へ ひも、したがって、「x」という名前のキャプチャされた変数への参照は
「（.x）」の形式を取ります。

[必要 1.5] gsub（正規表現; ストリング）、 gsub（正規表現; ストリング; フラグ）
gサブ のようなものです 以下 ただし、重複しない正規表現はすべて、
文字列、補間後。

高度な 商品特徴

変数はほとんどのプログラミング言語で絶対に必要ですが、降格されています
jqの「高度な機能」に。

ほとんどの言語では、変数はデータを渡す唯一の手段です。 あなたが計算する場合
値であり、それを複数回使用する場合は、変数に格納する必要があります。 に
プログラムの別の部分に値を渡すと、プログラムのその部分が
配置する変数を（関数パラメーター、オブジェクトメンバーなどとして）定義します
データ。

jqで関数を定義することも可能ですが、これは最大の機能です。
使用はjqの標準ライブラリを定義することです（ 地図 & find 実際に
jqで書かれています）。

jqにはリダクション演算子があります。これは非常に強力ですが、少し注意が必要です。 繰り返しますが、これらは
主に内部で使用され、jqの標準ライブラリのいくつかの有用なビットを定義します。

最初は明らかではないかもしれませんが、jqはすべてジェネレーターに関するものです（はい、よく見られるように
他の言語）。 ジェネレーターの処理を支援するために、いくつかのユーティリティが提供されています。

いくつかの最小限のI / Oサポート（標準入力からJSONを読み取り、JSONを
標準出力）が利用可能です。

最後に、モジュール/ライブラリシステムがあります。

Variables
jqでは、すべてのフィルターに入力と出力があるため、手動で配管する必要はありません。
プログラムのある部分から次の部分に値を渡します。 たとえば、多くの表現 a + b,
入力をXNUMXつの異なる部分式に渡します（ここでは a & b 両方とも同じように渡されます
input）なので、値をXNUMX回使用するために、通常、変数は必要ありません。

たとえば、数値の配列の平均値を計算するには、いくつかの必要があります
ほとんどの言語の変数-配列を保持するために少なくともXNUMXつ、おそらく各要素にXNUMXつ
またはループカウンターの場合。 jqでは、それは単に 加えます / 長さ - 加えます 式は与えられます
配列し、その合計を生成し、 長さ 式に配列が与えられ、その配列が生成されます
長さ

したがって、一般的に、変数を定義するよりも、jqのほとんどの問題を解決するためのよりクリーンな方法があります。
それでも、時々それらは物事を簡単にするので、jqはあなたがを使って変数を定義することを可能にします
表現 as $変数。 すべての変数名はで始まります $。 これは少し醜いバージョンです
配列平均の例の例：

$ array_lengthとしての長さ| 追加/ $ array_length

変数を実際に使用する状況を見つけるには、より複雑な問題が必要になります
私たちの生活を楽にします。

「作成者」フィールドと「タイトル」フィールドを含む一連のブログ投稿があり、別のブログ投稿があるとします。
著者のユーザー名を実際の名前にマップするために使用されるオブジェクト。 入力は次のようになります。

{"投稿"：[{"タイトル"： "最初のpsot"、 "著者"： "anon"}、
{"タイトル"： "よく書かれた記事"、 "著者"： "person1"}]、
"realnames"：{"anon"： "Anonymous Coward"、
"person1"： "Person McPherson"}}

次のように、実際の名前を含む作成者フィールドを使用して投稿を作成します。

{"title"： "Frist psot"、 "author"： "Anonymous Coward"}
{"タイトル"： "よく書かれた記事"、 "著者"： "パーソンマクファーソン"}

後で参照できるように、変数$ namesを使用してrealnamesオブジェクトを格納します
著者のユーザー名を検索する場合：

.realnames as $ names | .posts [] | {タイトル、作成者：$ names [.author]}

表現 EXP as $x | ... 意味：式の値ごとに EXP、残りを実行します
元の入力全体を含むパイプライン、および $x その値に設定します。 したがって as
foreachループのようなものとして機能します。

同じように {ふー} 便利な書き方です {foo： .foo}ので、 {$ foo} 便利な書き方です
{foo：$ foo}.

単一の変数を使用して複数の変数を宣言できます as パターンを提供することによる表現
入力の構造と一致します（これは「破壊」として知られています）：

。 as {realnames：$ names、posts：[$ first、$ second]} | ..。

配列パターンの変数宣言（例： . as [$ first、 $ second]）にバインドする
配列の要素は、インデックスXNUMXの要素から上に向かって順番に入力されます。 ないとき
配列パターン要素のインデックスの値、 ヌル その変数にバインドされています。

変数は、それらを定義する式の残りの部分にスコープされるため、

.realnames as $ names | （.posts [] | {タイトル、作成者：$ names [.author]}）

動作しますが

（.realnames as $ names | .posts []）| {タイトル、作成者：$ names [.author]}

しません。

プログラミング言語理論家にとって、jq変数は
字句スコープのバインディング。 特に、バインディングの値を変更する方法はありません。
同じ名前の新しいバインディングしか設定できませんが、どこにも表示されません
古いものでした。

jq´.bar as $ x | .foo | 。 + $ x´
{"foo"：10、 "bar"：200}
=> 210

jq´。 as $ i | [（。* 2 |。as$ i | $ i）、$ i] ´
5
=> [10,5]

jq´。 as [$ a、$ b、{c：$ c}] | $ a + $ b + $ c´
[2、3、{"c"：4、 "d"：5}]
=> 9

jq´。[] as [$ a、$ b] | {a：$ a、b：$ b} ´
[[0]、[0、1]、[2、1、0]]
=> {"a"：0、 "b"：null}、{"a"：0、 "b"：1}、{"a"：2、 "b"：1}

定義 機能
「def」構文を使用して、フィルターに名前を付けることができます。

def増分：。 + 1;

あれから、 増加 組み込み関数と同じようにフィルターとして使用できます（実際、これは
いくつかのビルトインがどのように定義されているかです）。 関数は引数を取ることができます：

def map（f）：[。[] | f];

引数は、値としてではなく、フィルターとして渡されます。 同じ引数を参照できます
異なる入力で複数回（ここでは f 入力配列の要素ごとに実行されます）。
関数への引数は、値の引数よりもコールバックのように機能します。 これは
理解することが重要です。 検討：

def foo（f）：f | f;
5 | foo（。* 2）

結果は20になります。 f is 。* 2、およびの最初の呼び出し中 f . 5になります
10回目は5（2 * 20）になるため、結果はXNUMXになります。関数の引数
はフィルターであり、フィルターは呼び出されたときに入力を期待します。

単純な関数を定義するための値引数の動作が必要な場合は、
変数：

def addvalue（f）：f as $ f | map（。+ $ f）;

または、省略形を使用します。

def addvalue（$ f）：...;

どちらの定義でも、 addvalue（.foo） 現在の入力を追加します .foo それぞれへのフィールド
配列の要素。

同じ関数名を使用した複数の定義が許可されます。 各再定義は置き換えられます
同じ数の関数引数に対する前の引数ですが、
再定義後の関数（またはメインプログラム）。

jq´def addvalue（f）：。 + [f]; map（addvalue（。[0]）） ´
[[1,2]、[10,20]]
=> [[1,2,1]、[10,20,10]]

jq´def addvalue（f）：f as $ x | map（。+ $ x）; addvalue（。[0]） ´
[[1,2]、[10,20]]
=> [[1,2,1,2]、[10,20,1,2]]

減らす
　 減らします jqの構文を使用すると、式のすべての結果を次のように組み合わせることができます。
それらを単一の答えに蓄積します。 例として、合格します 【3,2,1] これに
式：

。[]を$ item（0;。+ $ item）として減らします

結果ごとに 。[] を生成し、 . + $ item 現在の合計を累積するために実行されます、
0から開始します。この例では、 。[] 結果3、2、および1が生成されるため、効果は次のようになります。
このようなものを実行するのと似ています：

0 | （$ item |。+ $ itemとして3）|
（2 as $ item |。+ $ item）|
（$ item |。+ $ itemとして1）

jq´reduce。[] as $ item（0;。+ $ item） ´
【10,2,5,3]
=> 20

limit（n; exp）
　 制限 関数は最大を抽出します n からの出力 EXP.

jq´ [limit（3;。[]）] ´
【0,1,2,3,4,5,6,7,8,9]
=> [0,1,2]

first（expr）、 last（expr）、 nth（n; expr）
　 first（expr） & last（expr） 関数は、から最初と最後の値を抽出します 式,
。

　 nth（n; expr） 関数は、によって出力されたn番目の値を抽出します 式。 これは次のように定義できます
def nth（n; expr）： last（limit（n + 1; expr））;。 ご了承ください nth（n; expr） サポートしていません
の負の値 n.

jq´ [first（range（。））、last（range（。））、nth（./ 2; range（。））] ´
10
=> [0,9,5]

最初、 過去、 n番目（n）
　 最初の & last 関数は、次の任意の配列から最初と最後の値を抽出します。 ..

　 n番目（n） 関数は、で任意の配列のn番目の値を抽出します ..

jq´ [range（。）] | [最初、最後、 n番目の（5）] ´
10
=> [0,9,5]

foreachの
　 foreachの 構文は次のようになります 減らします、しかし、の構築を可能にすることを目的としています 制限
中間結果を生成するレデューサー（例を参照）。

フォームは foreachの EXP as $ var （初期化; アップデート; エキス）。 様 減らします, INIT 評価されます
状態値を生成するためにXNUMX回、次に EXP にバインドされています $ var, UPDATE is
の出力ごとに評価 EXP 現在の状態と $ var 見える。 各値
によって出力 UPDATE 以前の状態を置き換えます。 ついに、 エキス 新しいごとに評価されます
の出力を抽出する状態 foreachの.

これは主に構築にのみ役立ちます 減らします - と 制限-のような機能。 しかし、それは
部分的な削減が可能になるため、はるかに一般的です（以下の例を参照）。

jq´ [foreach。[] as $ item（[[]、[]]; if $ item == null then [[]、。[0]] else [（。[0] + [$ item]）、[ ]] end; $ item == nullの場合、。[1] else empty end）] ´
[1,2,3,4、null、 "a"、 "b"、null]
=> [[1,2,3,4]、["a"、 "b"]]

再帰
上記のように、 再帰 再帰を使用し、任意のjq関数を再帰的にすることができます。 ザ
while 組み込みは再帰の観点からも実装されています。

末尾呼び出しは、再帰呼び出しの左側の式が出力されるたびに最適化されます
その最後の値。 実際には、これは再帰の左側の式が
呼び出しは、入力ごとに複数の出力を生成してはなりません。

例：

def recurse（f）：def r：。、（f | select（。！= null）| r）; r;

def while（cond; update）：
def _while：
cond then。、（update | _while）else empty end;
_その間;

def repeat（exp）：
def _repeat：
exp、_repeat;
_繰り返す;

ジェネレータ & イテレータ
一部のjq演算子と関数は、ゼロを生成できるという点で実際にはジェネレータです。
他のプログラミングで予想されるように、入力ごとにXNUMXつ以上の値
ジェネレーターを持つ言語。 例えば、 。[] 入力にすべての値を生成します
（配列またはオブジェクトである必要があります）、 range（0; 10） 0との間の整数を生成します
10 など。

コンマ演算子でさえジェネレータであり、最初に生成された値を生成します
カンマの左側の式、次にそれらのそれぞれについて、値はによって生成されます
カンマの右側の式。

　 空の ビルトインはゼロ出力を生成するジェネレータです。 The 空の ビルトイン
前のジェネレータ式に戻ります。

すべてのjq関数は、組み込みのジェネレーターを使用するだけでジェネレーターにすることができます。 それも可能です
再帰とコンマ演算子のみを使用して新しいジェネレーターを定義します。 再帰的な場合
呼び出しが「テール位置」にある場合、ジェネレーターは効率的になります。 例では
による再帰呼び出しの下 _範囲 それ自体が尾の位置にあります。 例は自慢します
XNUMXつの高度なトピック：末尾再帰、ジェネレーターの構築、およびサブ機能。

jq´def range（init; upto; by）：def _range：if（by> 0and。<upto）or（by <0and。> upto）then。、（（。+ by）| _range）else。 終わり; if by == 0 then init else init | _range end | select（（by> 0and。<upto）or（by <0and。> upto））; range（0; 10; 3） ´
ヌル
=> 0、3、6、9

jq´def while（cond; update）：def _while：if cond then。、（update | _while）else empty end; _その間; [while（。<100;。* 2）] ´
1
=> [1,2,4,8,16,32,64]

数学

jqは現在、IEEE754倍精度（64ビット）浮動小数点数のみをサポートしています。

次のような単純な算術演算子に加えて +、jqにはほとんどの標準的な数学関数もあります
C数学ライブラリから。 単一の入力引数を取るC数学関数（例： 罪（）)
引数がゼロのjq関数として使用できます。 XNUMXつの入力を受け取るC数学関数
引数（例： 捕虜（））は、無視するXNUMXつの引数のjq関数として使用できます。 ..

標準の数学関数の可用性は、対応する数学関数の可用性に依存します
オペレーティングシステムとC数学ライブラリの数学関数。 利用できない数学関数
定義されますが、エラーが発生します。

I / O

現時点では、jqはI / Oを最小限にサポートしており、ほとんどの場合、いつ制御するかという形でサポートされています。
入力が読み取られます。 このためにXNUMXつの組み込み関数が提供されています。 & 入力、それは読んだ
同じソースから（例えば、 stdin、コマンドラインで指定されたファイル）jq自体として。 これらは
XNUMXつのビルトイン、およびjq独自の読み取りアクションは、相互にインターリーブできます。

XNUMXつのビルトインは、最小限の出力機能を提供します。 debug。 （jqプログラムの
出力値は常にJSONテキストとして出力されます (Linuxで言うところのstdout）。） debug ビルトインは持つことができます
libjq C APIを使用するが、そうではない実行可能ファイルなど、アプリケーション固有の動作
jq実行可能ファイル自体。


XNUMXつの新しい入力を出力します。

入力
残りのすべての入力をXNUMXつずつ出力します。

これは主に、プログラムの入力を減らす場合に役立ちます。

debug
入力値に基づいたデバッグメッセージを生成します。 jq実行可能ファイルはラップします
入力値 ["デバッグ："、 ] それと改行をstderrに出力します。
コンパクトに。 これは将来変更される可能性があります。

入力ファイル名
入力が現在フィルタリングされているファイルの名前を返します。 これは
jqがUTF-8ロケールで実行されていない限り、うまく機能しません。

入力行番号
現在フィルタリングされている入力の行番号を返します。

STREAMING

- ストリーム オプションjqは、入力テキストをストリーミング方式で解析できるため、jqが可能になります。
解析後ではなく、すぐに大きなJSONテキストの処理を開始するプログラム
完了します。 サイズが1GBの単一のJSONテキストがある場合、それをストリーミングすると、
それをはるかに迅速に処理します。

ただし、jqプログラムのように、ストリーミングを処理するのは簡単ではありません。 [ 、
] （および他のいくつかの形式）入力として。

ストリームの処理を容易にするために、いくつかのビルトインが提供されています。

以下の例では、のストリーミング形式を使用しています [0、[1]]ボタンの隣にある
[[0],0],[[1,0],1],[[1,0]],[[1]].

ストリーミングフォームには次のものが含まれます [ 、 ] （任意のスカラー値、空の配列を示すため、
または空のオブジェクト）、および [ ] （配列またはオブジェクトの終わりを示すため）。 未来
jqのバージョンはで実行されます - ストリーム & -seq 次のような追加のフォームを出力する場合があります ["エラー
メッセージ"] 入力テキストの解析に失敗したとき。

truncate_stream（stream_expression）
入力として数値を消費し、からの対応する数のパス要素を切り捨てます。
指定されたストリーミング式の出力の左側。

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

fromstream（stream_expression）
ストリーム式の出力に対応する値を出力します。

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

ストリームへ
　 ストリームへ ビルトインは、その入力のストリーミング形式を出力します。

jq´。 as $ dot | fromstream（$ dot | tostream）|。== $ dot´
[0、[1、{"a"：1}、{"b"：2}]]
=> true

割り当て

jqでの割り当ての動作は、ほとんどのプログラミング言語とは少し異なります。 jqはしません
何かへの参照とコピーを区別します-XNUMXつのオブジェクトまたは配列は
「同じオブジェクト」または「等しくない」という概念をさらに持たずに、等しいか等しくないかのいずれか
同じオブジェクト」。

オブジェクトに配列であるXNUMXつのフィールドがある場合、 .foo & 。バー、そしてあなたは何かを追加します
.fooをタップし、その後、 。バー 大きくなることはありません。 設定したばかりでも 。バー = .foo。 使用している場合
Python、Java、Ruby、Javascriptなどの言語でプログラミングするなら、あなたは考えることができます
jqが割り当てを行う前に、すべてのオブジェクトの完全なディープコピーを行うかのように
（パフォーマンスに関しては、実際にはそれを行いませんが、それが一般的な考え方です）。

jqのすべての代入演算子には、左側にパス式があります。

=
フィルター .foo = 1 入力としてオブジェクトを受け取り、出力としてオブジェクトを生成します。
「foo」フィールドが1に設定されています。jqに何かを「変更」または「変更」するという概念はありません-
すべてのjq値は不変です。 例えば、

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

.bar.bazを1に設定するという副作用はありません。
Javascript、Python、Rubyまたは他の言語のプログラムはそうするでしょう。 これらの言語とは異なり（ただし
Haskellや他の関数型言語のように）、XNUMXつの配列や
「同じ配列」または「同じオブジェクト」であるオブジェクト。 それらは等しい場合も等しくない場合もありますが、
いずれかの状況でそれらのXNUMXつを変更した場合、もうXNUMXつは私たちの背後で変更されません。

これは、jqで循環値を作成することが不可能であることを意味します（配列など
最初の要素はそれ自体です）。 これは非常に意図的なものであり、jq
プログラムが生成できるJSONで表すことができます。

´=´の左側は、の値を参照していることに注意してください。 .。 かくして $ var.foo = 1 動作しません
予想通り （$ var.foo の有効または有用なパス式ではありません .）; 使用する $ var | .foo = 1
を代わりにお使いください。

´=´の右側が複数の値を生成する場合、そのような値ごとにjqは
左側のパスを値に設定すると、変更されたパスが出力されます ..
たとえば、 （.a、.b）=範囲(2) outputs {"a"：0、 "b"：0}をタップし、その後、 {"a"：1、 "b"：1}。 更新"
譲渡フォーム（下記参照）はこれを行いません。

それも注意してください .a、.b = 0 設定されません .a & .b、 だけど （.a、.b）= 0 両方を設定します。

|=
代入演算子 ´=´と同様に、jqは「更新」演算子 ´| =´を提供します。
右側のフィルターを取り、のプロパティの新しい値を計算します .
この式を介して古い値を実行することによって割り当てられます。 たとえば、.foo | =
。+ 1は、「foo」フィールドが入力の「foo」プラス1に設定されたオブジェクトを作成します。

この例は、 ´=´と ´| =´の違いを示しているはずです。

プログラムに入力 ´{"a"：{"b"：10}、 "b"：20}´を提供します。

.a = .b .a | = .b

前者は、入力の「a」フィールドを入力の「b」フィールドに設定し、次のように生成します。
出力{"a"：20}。 後者は、入力の「a」フィールドを「a」フィールドに設定します。
"b"フィールド、{"a"：10}を生成します。

左側は、任意の一般的なパス式にすることができます。 見る 道（）.

´| =´の左側は、の値を参照していることに注意してください。 .。 かくして $ var.foo |= . + 1 しません
期待どおりに動作します（$ var.foo の有効または有用なパス式ではありません .）; 使用する $ var | .foo
|= . + 1 を代わりにお使いください。

右側が複数の値を出力する場合、最後の値のみが使用されます。

jq´（.. | select（type == "boolean"））| = if。 次に1、その他0終了 ´
[true、false、[5、true、[true、[false]]、false]]
=> [1,0,[5,1,[1,[0]],0]]

+ =、 -=、 * =、 / =、 ％=、 // =
jqには次の形式の演算子がいくつかあります a op = b、これらはすべて同等です a |= . op b。 そう、
+= 1 値をインクリメントするために使用できます。

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

複雑な 割り当て
jq割り当ての左側では、ほとんどの場合よりも多くのことが許可されています
言語。 左側で簡単なフィールドアクセスをすでに見ましたが、
配列アクセスも同様に機能することに驚いてください。

.posts [0] .title = "JQマニュアル"

驚かれるかもしれませんが、左側の式は複数を生成する可能性があります
入力ドキュメントのさまざまなポイントを参照した結果：

.posts []。comments | =。 + ["これは素晴らしい"]

この例では、文字列「thisisgreat」を各投稿の「comments」配列に追加します。
入力（入力は、投稿の配列である「posts」フィールドを持つオブジェクトです）。

jqが「a = b」のような割り当てに遭遇すると、jqはaを選択するためにたどった「パス」を記録します。
実行中の入力ドキュメントの一部。 次に、このパスを使用して、
割り当ての実行中に変更する入力。 任意のフィルターを使用できます
等号の左側-入力から選択したパスは、
割り当てが実行されます。

これは非常に強力な操作です。 を使用して、ブログ投稿にコメントを追加したいとします。
上記と同じ「ブログ」入力。 今回は、
「ステドラン」。 前述の「選択」機能を使用して、これらの投稿を見つけることができます。

.posts [] | select（.author == "stedolan"）

この操作によって提供されるパスは、「stedolan」が書き込んだ各投稿を指し、
以前と同じ方法で、それぞれにコメントすることができます。

（.posts [] | select（.author == "stedolan"）| .comments）| =
。 + ["ひどい。"]

モジュール

jqにはライブラリ/モジュールシステムがあります。 モジュールは、名前がで終わるファイルです .jq.

プログラムによってインポートされたモジュールは、デフォルトの検索パスで検索されます（以下を参照）。 The
import & include ディレクティブを使用すると、インポーターはこのパスを変更できます。

検索パス内のパスは、さまざまな置換の対象になります。

「〜/」で始まるパスの場合、ユーザーのホームディレクトリが「〜」に置き換えられます。

「$ ORIGIN /」で始まるパスの場合、jq実行可能ファイルのパスが代わりに使用されます
「$ ORIGIN」。

「./」で始まるパスまたは「。」であるパスの場合、インクルードファイルのパスは次のようになります。
「。」の代わりに使用します。 コマンドラインで指定されたトップレベルプログラムの場合、現在
ディレクトリが使用されます。

インポートディレクティブは、オプションで、デフォルトが追加される検索パスを指定できます。

デフォルトの検索パスは、に指定された検索パスです。 -L コマンドラインオプション、それ以外の場合
["〜/ .jq", "$ ORIGIN /../ lib / jq"、 "$ ORIGIN /。。/ lib"].

ヌルおよび空の文字列パス要素は、検索パス処理を終了します。

相対パス「foo / bar」の依存関係は、「foo /bar.jq」で検索され、
指定された検索パスの「foo / bar /bar.jq」。 これは、モジュールを配置できるようにすることを目的としています
たとえば、バージョン管理ファイル、READMEファイルなどと一緒にディレクトリにあります。
また、単一ファイルモジュールを許可します。

同じ名前の連続するコンポーネントは、あいまいさを回避することはできません（例：
「foo / foo」）。

たとえば、 -L $ HOME / .jq モジュール foo で見つけることができます $ HOME / .jq / foo.jq &
$ HOME / .jq / foo / foo.jq.

「$ HOME / .jq」がファイルの場合、メインプログラムにソースされます。

import 相対パス文字列 as NAME [ ];
検索パス内のディレクトリを基準にして、指定されたパスで見つかったモジュールをインポートします。 「.jq」
相対パス文字列に接尾辞が追加されます。 モジュールのシンボルの前には接頭辞が付いています
"名前：："。

オプションのメタデータは定数jq式である必要があります。 キーを持つオブジェクトである必要があります
「ホームページ」など。 現時点では、jqはの「検索」キー/値のみを使用します
メタデータ。 メタデータは、ユーザーが モジュールメタ 内蔵。

メタデータの「検索」キーが存在する場合は、文字列または配列の値（array
文字列の）; これは、最上位の検索パスの前に付ける検索パスです。

include 相対パス文字列 [ ];
検索パス内のディレクトリに関連する特定のパスで見つかったモジュールを、あたかもそれであるかのようにインポートします
所定の場所に含まれていました。 「.jq」サフィックスが相対パス文字列に追加されます。 The
モジュールのシンボルは、モジュールのコンテンツが持っているかのように、呼び出し元の名前空間にインポートされます
直接含まれています。

オプションのメタデータは定数jq式である必要があります。 キーを持つオブジェクトである必要があります
「ホームページ」など。 現時点では、jqはの「検索」キー/値のみを使用します
メタデータ。 メタデータは、ユーザーが モジュールメタ 内蔵。

import 相対パス文字列 as $ NAME [ ];
検索パス内のディレクトリを基準にして、指定されたパスで見つかったJSONファイルをインポートします。 A
「.json」サフィックスが相対パス文字列に追加されます。 ファイルのデータは次のようになります
として利用可能 $ NAME :: NAME.

オプションのメタデータは定数jq式である必要があります。 キーを持つオブジェクトである必要があります
「ホームページ」など。 現時点では、jqはの「検索」キー/値のみを使用します
メタデータ。 メタデータは、ユーザーが モジュールメタ 内蔵。

メタデータの「検索」キーが存在する場合は、文字列または配列の値（array
文字列の）; これは、最上位の検索パスの前に付ける検索パスです。

モジュール ;
このディレクティブは完全にオプションです。 適切な操作には必要ありません。 それは役立ちます
で読み取ることができるメタデータを提供する目的のみ モジュールメタ 内蔵。

メタデータは定数jq式である必要があります。 次のようなキーを持つオブジェクトである必要があります
「ホームページ」。 現時点では、jqはこのメタデータを使用していませんが、ユーザーが利用できるようになっています
ビア モジュールメタ 内蔵。

モジュールメタ
モジュール名を入力として受け取り、モジュールのメタデータをオブジェクトとして出力します。
モジュールは、「deps」キーの配列値として（メタデータを含む）インポートします。

プログラムはこれを使用して、モジュールのメタデータをクエリできます。
たとえば、不足している依存関係を検索、ダウンロード、およびインストールします。

onworks.netサービスを使用してjqをオンラインで使用する