jq：JSON処理ドメイン特化言語の形式的基盤、歴史的発展、および実用的評価

last_modified: 2026-03-16

生成AIによる自動生成記事に関する免責事項: 本記事は、生成AIによって自動構成された技術解説記事です。内容の正確性を保持するよう努めていますが、厳密な形式言語理論的証明や実装の詳細については、必ず原著ドキュメントおよび参考文献に記載の一次資料を参照してください。実装に際しては各自の責任において検証を行ってください。

1. 序論：データ処理基盤としてのJSONと処理ツールの位置付け#

1.1 背景：構造化データ処理の必要性#

現代のソフトウェアシステムにおいて、異種コンポーネント間のデータ交換フォーマットとして JavaScript Object Notation（JSON）が広く採用されている。JSON は 2001 年に Douglas Crockford によって仕様化が開始され、2013 年に ECMA-404 として国際標準化された軽量テキストフォーマットである。その採用は REST API、NoSQL データベース、設定ファイル、ログ記録システムなど多岐にわたっており、Unix 系システムにおけるデータパイプライン処理の中心的な位置を占めるに至っている。

しかしながら、JSON が人間可読性と機械可読性を両立するフォーマットとして設計された一方で、コマンドライン環境における JSON データの抽出・変換・集計処理には、従来の Unix テキスト処理ツール群（awk、sed、grep 等）が想定していなかった課題が存在する。これらのツールは本質的に行指向（line-oriented）のテキスト処理を前提としており、ネスト構造を持つ階層的データモデルとの親和性が低い。

jq は、この問題に対して「JSON を第一級の操作対象とするドメイン特化言語（Domain-Specific Language, DSL）」というアプローチで応答したツールである。本稿は jq の設計思想・数理的基盤・歴史的文脈・実利的効果を体系的に記述することを目的とする。

1.2 本稿の構成#

本稿は以下の順序で議論を展開する。第2節では JSON の形式的定義とデータモデルの数理的構造を整理する。第3節では jq の歴史的発展を記述する。第4節では jq フィルタ言語の形式的意味論を導出する。第5節では主要な構文要素を網羅的に解説する。第6節では jq のアーキテクチャと実装上の考慮点を論じる。第7節では実際の活用事例を示す。第8節では類似ツールとの比較考察を行う。第9節では限界と将来展望を論じる。第10節で結論を述べ、参考文献を列挙する。

2. JSON の形式的データモデルと数理的構造#

jq の動作を正確に理解するためには、まず jq が操作対象とする JSON データモデルの数理的構造を明確にしておく必要がある。

2.1 JSON の帰納的定義#

JSON の値（value）の集合 $\mathcal{V}$ は以下の帰納的定義によって形式化される。

\mathcal{V} ::= \mathtt{null} \mid \mathtt{true} \mid \mathtt{false} \mid n \mid s \mid [v_1, \ldots, v_k] \mid \{k_1: v_1, \ldots, k_n: v_n\}

ここで、 $n \in \mathbb{Q}$ （JSON の数値型は IEEE 754 倍精度浮動小数点として実装される場合が多い）、 $s \in \Sigma^*$ （Unicode 文字列の集合）、 $v_i \in \mathcal{V}$ （再帰的な値の参照）、 $k_i \in \Sigma^*$ （オブジェクトのキー文字列）である。

この定義において、配列 $[v_1, \ldots, v_k]$ は要素に順序を持つ有限列として、オブジェクト $\{k_1: v_1, \ldots, k_n: v_n\}$ はキーから値への有限写像（finite map）として解釈される。ただし、実用的な JSON 実装において、オブジェクト内でのキーの順序保持は仕様によって保証されない点に注意が必要である。

2.2 JSON 値の木構造表現#

JSON 値 $v \in \mathcal{V}$ は、有向根付き順序木（directed rooted ordered tree）として表現可能である。葉ノードはスカラー値（null、true、false、数値、文字列）に対応し、内部ノードは配列またはオブジェクトに対応する。

形式的には、JSON 値の木 $T(v)$ は以下のように定義される。

$v$ がスカラーのとき： $T(v)$ はラベル $v$ を持つ単一ノードからなる木。
$v = [v_1, \ldots, v_k]$ のとき： $T(v)$ は根ノードに $k$ 個の子 $T(v_1), \ldots, T(v_k)$ を持つ木（各辺には整数インデックス $0, \ldots, k-1$ のラベルが付与される）。
$v = \{k_1: v_1, \ldots, k_n: v_n\}$ のとき： $T(v)$ は根ノードに $n$ 個の子 $T(v_1), \ldots, T(v_n)$ を持つ木（各辺にはキー文字列 $k_i$ のラベルが付与される）。

この木構造表現は、jq のパス式（path expression）の意味論の基盤となる。

2.3 パスとパス式の形式化#

JSON 値内の特定のノードへの到達経路を表す「パス」は、ラベルの有限列として定義される。

p = [l_1, l_2, \ldots, l_d] \in (\mathbb{Z} \cup \Sigma^*)^*

ここで、 $l_i$ は整数インデックス（配列要素への参照）または文字列キー（オブジェクトフィールドへの参照）である。

空のパス $[]$ は根ノードを指示する。パス $p$ に対する評価関数 $\mathtt{eval}(v, p)$ は次のように帰納的に定義される。

\mathtt{eval}(v, []) = v

\mathtt{eval}(v, [l | p']) = \begin{cases} \mathtt{eval}(v_l, p') & \text{if } v = [v_0, \ldots, v_{k-1}] \text{ and } l \in \mathbb{Z} \\ \mathtt{eval}(v_{k}, p') & \text{if } v = \{\ldots, l: v_k, \ldots\} \text{ and } l \in \Sigma^* \\ \mathtt{error} & \text{otherwise} \end{cases}

この形式化は、jq における .foo.bar[2] のような連鎖的フィールドアクセスの意味論を数学的に記述するものである。

2.4 多値関数としての jq フィルタ#

jq の設計上の重要な特徴は、フィルタを JSON 値から JSON 値への単値関数ではなく、JSON 値から JSON 値の（有限）列への写像として捉えていることである。

f: \mathcal{V} \to \mathcal{V}^*

ここで $\mathcal{V}^* = \bigcup_{n \geq 0} \mathcal{V}^n$ は $\mathcal{V}$ 上の有限列全体の集合を表す。

この設計判断は、配列展開演算子 .[] のセマンティクスを自然に扱うために導入された。例えば、[1,2,3] に対して .[] フィルタを適用すると、単一の配列ではなく値の列 1, 2, 3 が順次出力される。これを「ストリーム（stream）」または「生成器（generator）」と呼ぶことができる。

3. jq の歴史的発展#

3.1 Unix パイプライン哲学との接続#

jq の登場を理解するためには、Unix 哲学（Unix Philosophy）の文脈を押さえておく必要がある。Douglas McIlroy らが 1978 年に定式化した Unix 哲学の中核的原則は次のように要約される。

一つのことをうまくこなすプログラムを書け（Do one thing and do it well）
協調して動くプログラムを書け（Write programs to work together）
テキストストリームを扱うプログラムを書け（Write programs to handle text streams）

Unix パイプライン（| 演算子によるプロセス間通信）は、この哲学を実現する中心的なメカニズムである。grep、awk、sed、cut、sort といったツール群は、それぞれ単純な変換操作を担い、パイプラインで組み合わせることで複雑なデータ処理を実現する。

JSON の普及以前、コマンドライン環境での構造化データ処理は awk によるフィールド分割が主流であったが、ネスト構造への対応は困難であった。XML 時代には xmllint、xsltproc、xpath などが同様の役割を担ったが、JSON の台頭に対応したコマンドラインツールの必要性が高まった。

3.2 jq の誕生（2012年）#

jq は Stephen Dolan（後に主にNicolas Seriot等の貢献者も加わった）によって 2012 年に開発・公開された。初期バージョンは C 言語で実装され、GitHub 上でオープンソースとして公開された（当初のリポジトリは stedolan/jq）。

Stephen Dolan は当時、コンビネータ論理（combinator logic）と圏論（category theory）の研究にも携わっており、この背景が jq の設計に影響を与えていると考えられる。jq のパイプライン演算子やコンビネータ的な合成モデルは、関数型プログラミングの理念と親和性が高い。

最初の安定版リリースである jq 1.3 は 2013 年に公開され、このバージョンで基本的な言語機能の多くが整備された。その後、jq 1.4（2014 年）、jq 1.5（2015 年）と機能拡張が続いた。jq 1.5 では正規表現サポート（PCRE バインディング）、SQL スタイルの演算子、高度なモジュールシステムなどが追加された。

3.3 リポジトリの移管と継続的開発（2023年以降）#

2023 年、jq プロジェクトはオリジナル開発者 Stephen Dolan の管理から独立した組織 jqlang/jq へとリポジトリが移管された。これは、プロジェクトの長期的な持続可能性と、コミュニティ主導の開発継続を目的とした措置であった。

jqlang/jq への移管後、2023 年に jq 1.6 のバグ修正を中心とした jq 1.7 がリリースされた。2024 年には jq 1.7.1 が公開され、引き続き安定した機能改善が行われている。本稿執筆時点（2026年3月）の最新安定版は jq 1.7.x 系列である。

3.4 関連ツールの派生的発展#

jq の成功は、類似する処理パラダイムを他のフォーマットに拡張する試みを促した。代表的な派生・類似ツールとして以下が挙げられる。

yq（mikefarah/yq）：YAML、TOML、XML を jq スタイルで処理するツール
xq：XML を jq フィルタで処理可能にするラッパー
gron：JSON をフラットなパス形式に変換し、grep での検索を容易にするツール（jq の代替手段の一つ）
fx：ターミナル上でのインタラクティブな JSON ビューワーと処理ツール
jless：jq と統合されたページャ型 JSON ビューワー

また、プログラミング言語レベルでは、Python の jmespath、JavaScript の JSONPath、Java の Jayway JsonPath など、jq の設計思想に影響を受けた（あるいは独立に発展した）クエリ言語・ライブラリが複数存在する。

4. jq フィルタ言語の形式的意味論#

4.1 フィルタ代数の構造#

jq の言語はフィルタの代数（filter algebra）として記述可能である。フィルタの集合 $\mathcal{F}$ は、基本フィルタと合成演算子によって構成される。

基本フィルタ（atomic filters）

フィルタ	記法	定義域 $\to$ 値域
恒等フィルタ	`.`	$\mathcal{V} \to \mathcal{V}^1$
フィールドアクセス	`.foo`	$\mathcal{V} \to \mathcal{V}^{\leq 1}$
配列インデックス	`.[n]`	$\mathcal{V} \to \mathcal{V}^{\leq 1}$
配列展開	`.[]`	$\mathcal{V} \to \mathcal{V}^*$
リテラル	`42`, `"str"`, `true`, `null`	$\mathcal{V} \to \mathcal{V}^1$
再帰展開	`..`	$\mathcal{V} \to \mathcal{V}^*$

合成演算子（composition operators）

演算子	記法	意味論
パイプライン合成	`f \| g`	$f$ の各出力に $g$ を適用した列を連結
コンマ演算子	`f, g`	$f$ の出力列と $g$ の出力列を連結
配列構築	`[f]`	$f$ のすべての出力を配列に収集
オブジェクト構築	`{k: f}`	指定されたフィールドでオブジェクトを構築

4.2 パイプライン合成の形式的定義#

パイプライン演算子 | による合成を形式的に定義する。

$f, g \in \mathcal{F}$ を任意のフィルタとする。合成フィルタ $f \,|\, g$ の入力 $v \in \mathcal{V}$ に対する評価は以下の通りである。

\llbracket f \,|\, g \rrbracket(v) = \bigsqcup_{v' \in \llbracket f \rrbracket(v)} \llbracket g \rrbracket(v')

ここで $\llbracket \cdot \rrbracket$ は評価括弧（evaluation brackets）であり、 $\bigsqcup$ は列の連結（concatenation）を表す。

すなわち、 $f | g$ は $f$ の出力各要素に $g$ を適用し、得られた列をすべて順に並べた列を返す。これはモナド（monad）の bind 演算（>>=）に相当する構造であり、jq のフィルタを「リストモナド上の計算」として解釈することができる。

4.3 コンマ演算子の意味論#

コンマ演算子 , は出力の列を連結（concatenate）する演算子である。

\llbracket f, g \rrbracket(v) = \llbracket f \rrbracket(v) \cdot \llbracket g \rrbracket(v)

ここで $\cdot$ は有限列の連結を表す。この定義により、f, g は $f$ の全出力に続いて $g$ の全出力を生成するフィルタとなる。

4.4 配列構築演算子の意味論#

配列構築演算子 [f] は、フィルタ $f$ のすべての出力を一つの JSON 配列に収集する演算子である。

\llbracket [f] \rrbracket(v) = \left[ \langle v_1, v_2, \ldots, v_k \rangle \right]

ここで $\langle v_1, v_2, \ldots, v_k \rangle = \llbracket f \rrbracket(v)$ であり、右辺の $[\cdot]$ は長さ 1 の列（その唯一の要素が JSON 配列）を表す。この演算子は生成器をコレクターに変換するものとして機能し、[.[] | select(...)] のような形で頻繁に用いられる。

4.5 再帰展開演算子 `..` の意味論#

再帰展開演算子 .. は、入力 JSON 値の木構造を深さ優先順（depth-first order）に走査し、すべてのサブ値（根を含む）を順に出力する演算子である。

\llbracket .. \rrbracket(v) = \text{DFS}(T(v))

ここで $\text{DFS}(T)$ は木 $T$ の深さ優先探索における訪問順に対応するノード値の列である。具体的には以下のように帰納的に定義される。

\text{DFS}(v) = \begin{cases} \langle v \rangle & \text{if } v \text{ はスカラー} \\ \langle v \rangle \cdot \bigsqcup_{i} \text{DFS}(v_i) & \text{if } v = [v_0, \ldots, v_{k-1}] \\ \langle v \rangle \cdot \bigsqcup_{i} \text{DFS}(v_i) & \text{if } v = \{k_1: v_1, \ldots, k_n: v_n\} \end{cases}

この演算子は .. | .foo? のようなネスト構造への到達に活用される。

4.6 エラーセマンティクスと `?` 演算子#

jq では、型不一致や存在しないフィールドへのアクセスはデフォルトで実行時エラーを発生させる（error 値の生成と伝播）。これに対して、try-catch 機構および ? 演算子（try operator）が提供されている。

? 演算子の意味論は次の通りである。

\llbracket f? \rrbracket(v) = \begin{cases} \llbracket f \rrbracket(v) & \text{if } \llbracket f \rrbracket(v) \text{ にエラーが含まれない} \\ \langle \rangle & \text{otherwise（エラーを空列に変換）} \end{cases}

これにより、異種スキーマを持つ JSON オブジェクトの集合に対して、特定フィールドが存在するものにのみフィルタを適用するといった処理が記述可能になる。

4.7 `reduce` 式の形式的意味論#

jq には関数型プログラミングにおける fold（畳み込み）に相当する reduce 式が実装されている。

reduce EXP as $var (INIT; UPDATE)

この式の意味論は次の通りである。

\llbracket \texttt{reduce } f \texttt{ as } \$x \texttt{ (} \text{init} \texttt{;} \, g\texttt{)} \rrbracket(v)

は、 $f$ の全出力 $v_1, v_2, \ldots, v_k = \llbracket f \rrbracket(v)$ に対して、以下の逐次更新の最終値を返す。

a_0 = \llbracket \text{init} \rrbracket(v)

a_{i+1} = \llbracket g \rrbracket(a_i) \text{ where } \$x = v_{i+1}

\text{output} = \langle a_k \rangle

これは左畳み込み（left fold）であり、配列の合計・積・最大値等の集約操作を表現する基盤となる。

5. jq の構文体系と主要演算子#

本節では jq の主要な構文要素を体系的に解説する。

5.1 基本的なデータアクセス#

恒等フィルタ（Identity Filter）

最も基本的なフィルタは .（ドット）であり、入力をそのまま出力する恒等写像に相当する。

echo '{"name": "Alice", "age": 30}' | jq '.'

{
  "name": "Alice",
  "age": 30
}

オブジェクトフィールドアクセス

.fieldname 構文によってオブジェクトの特定フィールドの値を取得する。

echo '{"name": "Alice", "age": 30}' | jq '.name'

"Alice"

フィールド名にスペースや特殊文字を含む場合は、.["field name"] 構文を使用する。

echo '{"field name": 42}' | jq '.["field name"]'

配列インデックスアクセス

.[n] 構文によって配列の $n$ 番目（0-indexed）の要素を取得する。負のインデックスは末尾からの相対位置を示す。

echo '[10, 20, 30, 40]' | jq '.[2]'

echo '[10, 20, 30, 40]' | jq '.[-1]'

配列スライス

.[m:n] 構文によって配列の部分列を取得する。Python のスライス記法と同様の意味論を持つ。

echo '[10, 20, 30, 40, 50]' | jq '.[1:3]'

[20, 30]

5.2 配列・オブジェクトの反復処理#

配列展開演算子 .[]

.[] は配列の全要素を個別の出力として生成する。これは前節で定式化した多値出力の典型例である。

echo '[1, 2, 3]' | jq '.[]'

1
2
3

オブジェクトに対して .[] を適用すると、全フィールドの値（キーなし）が出力される。

echo '{"a": 1, "b": 2}' | jq '.[]'

1
2

パイプラインとの組み合わせ

配列展開とパイプラインを組み合わせることで、各要素に処理を適用する。

echo '[{"name": "Alice"}, {"name": "Bob"}]' | jq '.[] | .name'

"Alice"
"Bob"

5.3 データ型と型検査#

jq は JSON の全データ型を扱い、型検査関数を提供する。

echo 'null' | jq 'type'           # "null"
echo '42' | jq 'type'             # "number"
echo '"hello"' | jq 'type'        # "string"
echo 'true' | jq 'type'           # "boolean"
echo '[1,2]' | jq 'type'          # "array"
echo '{"a":1}' | jq 'type'        # "object"

型変換関数 tonumber、tostring、ascii_downcase、ascii_upcase 等も提供される。

echo '"42"' | jq 'tonumber'       # 42
echo '42' | jq 'tostring'         # "42"

5.4 条件式と選択#

if-then-else 式

if CONDITION then EXPR_TRUE else EXPR_FALSE end

jq の if 式は、条件が false または null のときに else ブランチを評価し、それ以外の値（数値 0 を含む）を真として扱う。

echo '5' | jq 'if . > 3 then "large" else "small" end'

"large"

select 関数

select(f) は、入力に対して f が真値を返す場合にその入力をそのまま出力し、偽値を返す場合は出力を生成しない（空列を返す）フィルタである。

echo '[1, 2, 3, 4, 5]' | jq '.[] | select(. > 3)'

4
5

これは数学的には集合の外延的記法 $\{x \in A \mid P(x)\}$ に対応する。

5.5 組み込み関数#

jq は多数の組み込み関数を提供する。主要なものを以下に示す。

配列操作関数

echo '[3,1,4,1,5,9]' | jq 'sort'
# [1, 1, 3, 4, 5, 9]

echo '[3,1,4,1,5,9]' | jq 'sort | unique'
# [1, 3, 4, 5, 9]

echo '[3,1,4,1,5,9]' | jq 'length'
# 6

echo '[[1,2],[3,4]]' | jq 'flatten'
# [1, 2, 3, 4]

echo '[1,2,3,4,5]' | jq 'reverse'
# [5, 4, 3, 2, 1]

echo '[1,2,3]' | jq 'map(. * 2)'
# [2, 4, 6]

map と map_values の形式的定義

map(f) は [.[] | f] の糖衣構文（syntactic sugar）として定義される。

\llbracket \texttt{map}(f) \rrbracket(v) = \llbracket [\texttt{.[]} \,|\, f] \rrbracket(v)

同様に、map_values(f) はオブジェクト・配列の各値に f を適用する（キー・インデックスを保持する点で map と異なる）。

集約関数

echo '[1,2,3,4,5]' | jq 'add'
# 15

echo '[1,2,3,4,5]' | jq 'min, max'
# 1
# 5

echo '[1,2,3,4,5]' | jq 'add / length'
# 3

オブジェクト操作関数

echo '{"a":1,"b":2}' | jq 'keys'
# ["a","b"]

echo '{"a":1,"b":2}' | jq 'values'
# [1, 2]

echo '{"a":1,"b":2}' | jq 'to_entries'
# [{"key":"a","value":1},{"key":"b","value":2}]

echo '[{"key":"a","value":1}]' | jq 'from_entries'
# {"a": 1}

echo '{"a":1,"b":2}' | jq 'has("a")'
# true

echo '{"a":1}' | jq 'keys | length'
# 1

5.6 文字列処理#

文字列補間

jq では \(expr) 構文を用いて文字列中に式を埋め込むことができる。

echo '{"name": "Alice", "age": 30}' | jq '"Name: \(.name), Age: \(.age)"'

"Name: Alice, Age: 30"

正規表現（jq 1.5以降）

jq 1.5 以降、PCRE（Perl Compatible Regular Expressions）を用いた正規表現処理が利用可能になった。

echo '"2026-03-16"' | jq 'test("^[0-9]{4}-[0-9]{2}-[0-9]{2}$")'
# true

echo '"Hello World"' | jq 'scan("[A-Z][a-z]+")'
# "Hello"
# "World"

echo '"foo bar baz"' | jq 'split(" ")'
# ["foo","bar","baz"]

echo '["foo","bar","baz"]' | jq 'join(",")'
# "foo,bar,baz"

CSV / TSV 変換

echo '[["Alice",30],["Bob",25]]' | jq -r '.[] | @csv'
# "Alice",30
# "Bob",25

echo '[["Alice",30],["Bob",25]]' | jq -r '.[] | @tsv'
# Alice	30
# Bob	25

@csv および @tsv はフォーマット文字列（format string）と呼ばれる組み込みの変換器であり、@html（HTML エスケープ）、@uri（URLエンコード）、@base64（Base64エンコード）、@sh（シェルエスケープ）なども提供されている。

5.7 変数束縛と再利用#

jq では as $x 構文によって中間値を変数に束縛し、後続の式で参照することができる。

echo '{"a": 10, "b": 20}' | jq '.a as $x | .b as $y | $x + $y'

変数のスコープはlexically scoped（字句スコープ）であり、束縛の有効範囲は as $x | ... の右辺の式に限定される。

5.8 ユーザー定義関数#

jq では def キーワードによってユーザー定義関数を定義できる。関数は引数として他のフィルタを受け取ることができる（高階関数）。

def square: . * .;
def power(n): . as $x | reduce range(n) as $_ (1; . * $x);

echo '5' | jq 'def square: . * .; square'
# 25

echo '2' | jq 'def power(n): . as $x | reduce range(n) as $_ (1; . * $x); power(10)'
# 1024

関数定義における引数は「フィルタ引数（filter arguments）」であり、通常の値ではなくフィルタそのものを渡すことができる。これは高階関数（higher-order function）のパターンを実現する。

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

これは組み込みの map と同等の動作をする。

5.9 `@base64d` と入出力制御#

jq の出力オプションも重要な実用的知識である。

オプション	説明
`-r`	出力がJSON文字列の場合、クォートなしのraw文字列として出力
`-c`	コンパクト（改行なし）JSON出力
`-n`	入力を読み込まず、`null` を初期入力として処理
`-s`	全入力行を単一のJSON配列として処理（slurpモード）
`-e`	最終出力が `false` または `null` の場合に終了コード1を返す
`--arg name value`	シェル変数を jq 内の文字列変数として渡す
`--argjson name value`	JSON値をjq変数として渡す
`--rawfile name file`	ファイル内容を文字列変数として渡す

echo '{"name": "Alice"}' | jq -r '.name'
# Alice  （クォートなし）

echo '{"name": "Alice"}' | jq -c '.'
# {"name":"Alice"}

jq -n '{"result": (1 + 2)}'
# {"result": 3}

echo '1
2
3' | jq -s '.'
# [1, 2, 3]

6. jq のアーキテクチャと実装上の考慮点#

6.1 処理パイプラインの概観#

jq の内部処理パイプラインは大きく以下のフェーズから構成される。

字句解析（Lexical Analysis）：入力フィルタ文字列をトークン列に変換
構文解析（Parsing）：トークン列を抽象構文木（AST）に変換
コンパイル（Compilation）：AST を jq のバイトコード（内部命令列）に変換
実行（Execution）：JSON 入力に対してバイトコードを実行し出力を生成

この処理モデルにより、同じフィルタを複数の入力に繰り返し適用する場合、コンパイルフェーズは一度のみ実行される。

6.2 メモリ効率とストリーミング処理#

大規模な JSON データを扱う場合、デフォルトの動作では JSON 全体を一度にメモリに読み込む。これは巨大なファイル（数 GB 規模）の処理においてメモリの制約要因となりうる。

jq 1.5 以降、--stream オプションが提供されており、入力 JSON を逐次的なイベントストリームとして処理することが可能になった。--stream モードでは、パーサがイベント（パス・値のペア）を逐次的に出力し、jq フィルタがそれを処理する。

jq --stream '.' large_file.json
# [["key1"], "value1"]
# [["key2", 0], "element1"]
# ...

ただし、--stream モードを活用するフィルタの記述は従来の記法より複雑になるため、truncate_stream、first、last、nth 等の補助関数と組み合わせて使用する。

6.3 jq の計算複雑性#

jq フィルタの計算複雑性は、使用する演算子に依存する。以下に主要な演算の計算量を示す。

操作	時間計算量	備考
フィールドアクセス `.foo`	$O(n)$	$n$ : オブジェクトのフィールド数（線形探索）
配列インデックス `.[k]`	$O(1)$	直接インデックス参照
配列展開 `.[]`	$O(m)$	$m$ : 配列長
`sort`	$O(m \log m)$	比較ベースのソート
`group_by`	$O(m \log m)$	ソートに基づく実装
`unique`	$O(m \log m)$	ソート後の重複除去
`to_entries / from_entries`	$O(n)$	$n$ : フィールド数
`..` （再帰展開）	$O(	v
`recurse(f)`	最悪 $O(	v

jq の実装（C言語）においてオブジェクトは動的配列（linked list ベースの実装もあり）として保持される場合があり、フィールドアクセスは最悪ケースで $O(n)$ となる。ハッシュテーブルを用いた実装への移行は長年の課題であるが、2026 年現在の主流実装では依然として線形探索が用いられる場面がある。

6.4 数値精度の問題#

JSON 仕様上の数値型は IEEE 754 倍精度浮動小数点数（64-bit double）として表現される。この設計は、大きな整数（ $2^{53}$ を超える値）の正確な表現において精度損失を招く可能性がある。

echo '9007199254740993' | jq '.'
# 9007199254740992   （精度損失）

これは JSON 仕様および多くの JSON ライブラリに共通する制約であり、jq 固有の問題ではないが、金融計算や大規模 ID（snowflake ID など）を扱う際には注意を要する。この問題への対処として、大きな整数値を文字列として保持する設計が推奨される場合がある。

7. 実利的な活用事例と評価#

本節では、jq が実際のエンジニアリング業務において解決する問題カテゴリを示す。

7.1 API レスポンスのフィールド抽出とトランスフォーメーション#

HTTP API からの JSON レスポンスのうち必要なフィールドのみを抽出し、下流ツールに渡す用途は jq の最も基本的な活用形である。

# GitHub API からリポジトリ一覧を取得し、名前とスター数を抽出
curl -s "https://api.github.com/users/jqlang/repos" \
  | jq '[.[] | {name: .name, stars: .stargazers_count}] | sort_by(.stars) | reverse | .[0:5]'

[
  {"name": "jq", "stars": 28000},
  ...
]

この一連の操作—リスト展開、フィールド選択によるオブジェクト再構成、ソート、スライス—が単一のフィルタ式として記述できる点が jq の実用上の利点である。

7.2 ログ処理と集計#

JSON Lines（NDJSON、Newline-Delimited JSON）形式のアプリケーションログの集計は、jq の代表的な活用場面である。

# HTTP ステータスコードごとのリクエスト数を集計
cat access.log | jq -n '
  [inputs] |
  group_by(.status) |
  map({status: .[0].status, count: length}) |
  sort_by(.count) |
  reverse
'

# 直近1時間の平均レスポンスタイムを算出
cat access.log | jq -n '
  [inputs | select(.timestamp > (now - 3600))] |
  if length > 0 then
    (map(.response_time) | add) / length
  else
    0
  end
'

-n オプションと inputs 関数の組み合わせにより、複数行の JSON Lines を配列として収集し、集約操作を行うパターンが実現される。

7.3 設定ファイルの自動更新#

CI/CD パイプラインや Infrastructure as Code の文脈で、JSON 形式の設定ファイルを自動的に更新する処理は多く存在する。

# バージョン番号を更新
jq '.version = "1.2.0"' package.json > package.json.tmp && mv package.json.tmp package.json

# 特定の環境変数を更新
jq '.environment.database.host = "new-host.example.com"' config.json > config.json.tmp \
  && mv config.json.tmp config.json

# 配列への要素追加
jq '.dependencies += ["new-package"]' config.json > tmp.json && mv tmp.json config.json

# キーの削除
jq 'del(.deprecated_field)' config.json > tmp.json && mv tmp.json config.json

注：jq は入力ファイルをインプレース編集する機能を持たない。上記のように一時ファイルを経由するか、sponge（moreutils パッケージ）などの補助ツールを用いる必要がある。

7.4 データ変換と形式変換#

異なるシステム間でのデータ統合（ETL: Extract, Transform, Load）処理において、jq は変換ステップを担う。

フラット構造への変換（正規化）

echo '{"user": {"name": "Alice", "address": {"city": "Tokyo", "zip": "100-0001"}}}' | jq '
{
  name: .user.name,
  city: .user.address.city,
  zip: .user.address.zip
}'

配列のグループ化と集約

echo '[
  {"dept": "Engineering", "salary": 800000},
  {"dept": "Marketing", "salary": 600000},
  {"dept": "Engineering", "salary": 750000}
]' | jq '
group_by(.dept) |
map({
  dept: .[0].dept,
  avg_salary: (map(.salary) | add / length),
  count: length
})'

[
  {"dept": "Engineering", "avg_salary": 775000, "count": 2},
  {"dept": "Marketing", "avg_salary": 600000, "count": 1}
]

差分計算

# 2つのJSONオブジェクトのキーの差集合を取得
jq -n '
  {"a":1,"b":2,"c":3} as $old |
  {"a":1,"b":9,"d":4} as $new |
  {
    added: (($new | keys) - ($old | keys)),
    removed: (($old | keys) - ($new | keys)),
    changed: [($old | keys) | .[] | select($old[.] != $new[.])]
  }'

7.5 パス操作と動的フィールドアクセス#

path(expr) 関数はフィルタ式が示すパスを配列として返し、getpath/setpath/delpaths 関数と組み合わせることで動的なフィールド操作が可能になる。

# 全パスを列挙
echo '{"a": {"b": 1}, "c": [2, 3]}' | jq '[path(..)]'
# [[], ["a"], ["a","b"], ["c"], ["c",0], ["c",1]]

# 動的パスでの値取得
echo '{"a": {"b": 42}}' | jq 'getpath(["a","b"])'
# 42

# 動的パスでの値設定
echo '{}' | jq 'setpath(["a","b","c"]; 100)'
# {"a": {"b": {"c": 100}}}

7.6 SQL 的な操作#

jq 1.5 以降、INDEX、IN、GROUP_BY、JOIN のような SQL 的な高レベル演算子が追加された。

# INDEX: 配列をキーによる辞書に変換（O(n) → O(1) lookup）
echo '[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]' | jq 'INDEX(.[]; .id)'
# {"1":{"id":1,"name":"Alice"},"2":{"id":2,"name":"Bob"}}

# INDEX を利用したルックアップ（join 操作の実現）
jq -n '
  [{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}] as $users |
  [{"user_id":1,"order":"Widget"},{"user_id":2,"order":"Gadget"}] as $orders |
  ($users | INDEX(.[]; .id)) as $user_map |
  $orders | map(. + {name: $user_map[.user_id | tostring].name})
'

7.7 `env` による環境変数の利用#

jq 1.5 以降、$ENV オブジェクトおよび env 関数を通じて環境変数にアクセスできる。

export DB_HOST="db.example.com"
jq -n '$ENV.DB_HOST'
# "db.example.com"

jq -n 'env.HOME'
# "/home/username"

この機能により、設定値をシェル環境変数から jq フィルタに注入するパターンが実現され、スクリプトの可搬性が向上する。

7.8 AWS CLI との連携#

AWS CLI は JSON 形式でリソース情報を出力する設定が可能であり（--output json）、jq との組み合わせによるインフラ管理自動化は広く実践されている。

# EC2インスタンスの一覧を取得しインスタンスIDと名前タグを抽出
aws ec2 describe-instances --output json | jq -r '
  .Reservations[].Instances[] |
  [
    .InstanceId,
    (.Tags // [] | map(select(.Key == "Name")) | .[0].Value // "N/A"),
    .State.Name
  ] | @tsv'

# 停止中のインスタンスのIDのみ抽出
aws ec2 describe-instances --output json | jq -r '
  [.Reservations[].Instances[] |
   select(.State.Name == "stopped") |
   .InstanceId] | .[]'

# S3バケットの合計サイズを計算
aws s3api list-objects-v2 --bucket my-bucket --output json | jq '
  .Contents | map(.Size) | add'

8. 類似ツールとの比較考察#

8.1 jq と Python の json モジュール#

Python の json モジュールと jq コマンドはしばしば比較される選択肢である。

観点	jq	Python json
起動コスト	低（C言語実装）	中（Pythonインタプリタ起動）
パイプライン統合	ネイティブ	subprocess を介す
表現力	DSL の範囲内	汎用言語の全機能
可読性（単純操作）	高（簡潔）	低（boilerplate が多い）
デバッグ容易性	限定的	高（デバッガ使用可）
外部依存	jq のみ	Python（通常インストール済）

単純なフィールド抽出や変換にはjqが適しており、複雑なビジネスロジックや外部ライブラリとの連携が必要な場面では Python が適切である、という使い分けが一般的な実践知となっている。

8.2 jq と JSONPath#

JSONPath は Stefan Göessner が 2007 年に提案した JSON のクエリ言語であり、XPath の JSON 版として設計された。

jq記法:       .store.book[*].author
JSONPath記法: $.store.book[*].author

観点	jq	JSONPath
変換能力	高（演算・関数・ループ）	限定的（読み取り中心）
書き込み操作	サポート	限定的
標準化	非公式（事実上の標準）	RFC 9535（2024年標準化）
コマンドライン統合	ネイティブ	ライブラリ依存
学習コスト	中程度	低（XPath知識の転用可）

2024 年に JSONPath は RFC 9535 として IETF 標準として正式化されたが、変換・演算能力においては jq の方が表現力が高い。

8.3 jq と gron#

gron（Make JSON Greppable, Tom Hudson 作）は、JSON をフラットな代入文の列に変換し、grep や sed との組み合わせを容易にするツールである。

echo '{"a":{"b":1},"c":[2,3]}' | gron
# json = {};
# json.a = {};
# json.a.b = 1;
# json.c = [];
# json.c[0] = 2;
# json.c[1] = 3;

gron の出力は人間が容易に grep で検索できる形式であり、特にキーの完全名がわからない状態での探索的調査に適する。一方で、jq は変換・集計・再構成に優れる。実際には両者は相補的な関係にある。

8.4 jq と miller#

miller（mlr）は CSV、TSV、JSON Lines 等の複数フォーマットを統一的に扱うデータ処理ツールである。JSON Lines（ストリーム形式）の集計操作においては miller の方が直感的な記法を提供する場合があるが、ネスト構造の深い JSON の処理においては jq の方が適している。

9. jq の限界と将来の展望#

9.1 既知の限界#

インプレース編集の非対応

前述の通り、jq は入力ファイルを直接編集する機能を持たない。これはファイル操作の安全性（アトミック性）を確保する観点からの設計判断とも解釈できるが、実用上は一時ファイルや追加ツール（sponge）との組み合わせが必要である。

エラーメッセージの情報量

jq のエラーメッセージは比較的簡潔であり、大規模なフィルタ式のどの部分で問題が生じたかの特定が困難な場合がある。フィルタ開発時のデバッグには debug 関数の挿入や段階的な評価が推奨される。

echo '{"a":1}' | jq '.a | debug | . + 1'
# ["DEBUG:",1]
# 2

型システムの欠如

jq は動的型付けのみであり、静的な型チェックは提供されていない。これは大規模なjqフィルタライブラリのメンテナンスにおいて保守性の課題となりうる。

並列処理のサポートの限定性

jq 単体では入力ストリームの並列処理をサポートしない。複数ファイルの並列処理には parallel、xargs -P 等の外部ツールとの組み合わせが必要である。

数値精度

前述の IEEE 754 倍精度浮動小数点数の制約は根本的な制限であり、高精度計算や大整数処理においては別途対策が必要である。

9.2 大規模 JSON 処理における実用上の制約#

jq の --stream モードは大規模ファイルへの対応手段であるが、フィルタの記述が複雑になるという課題がある。数 GB 以上の JSON ファイルを処理する場合、専用のストリーミング JSON パーサー（ijson for Python、StreamingJsonParser for JavaScript など）や、列指向フォーマット（Apache Parquet、Apache Arrow）への変換を検討する方が適切な場合がある。

9.3 代替・後継的なアプローチ#

jq の後継または補完として注目されるアプローチを挙げる。

jq2 / libjq

jq のライブラリ化（libjq）により、他のプログラムから jq のフィルタエンジンを組み込みとして利用する形態が普及しつつある。これは jq フィルタの再利用性と統合性を高める方向性である。

DataScript / Meander / Pathom（クロージャ系）

Clojure/ClojureScript エコシステムでは、データ変換のための宣言的 DSL が発展しており、グラフ構造のデータ処理において jq を超える表現力を持つアプローチが提案されている。

WASM ターゲット

jq のWebAssembly ターゲットへのコンパイルにより、ブラウザ環境での jq フィルタの実行が可能になっている（jq-web 等）。これにより、フロントエンドアプリケーションに jq フィルタを埋め込む新たな活用形態が拡大している。

jq + jsonnet との比較

jsonnet（Google 製の JSON テンプレート言語）は JSON 生成の用途に特化しており、jq の変換・抽出用途とは目的が異なるが、設定ファイルの生成・管理において相補的な関係にある。

9.4 形式的検証の観点からの展望#

jq フィルタの形式的意味論（第4節）の整備は、フィルタの等価変換（最適化）および型推論の基盤となる。例えば：

map(f) | map(g) → map(f | g) の等価変換（融合変換、fusion transformation）
select(f) | select(g) → select(f and g) の最適化
型推論による事前エラー検出

これらの最適化は理論的には可能であり、将来の jq 実装またはその派生処理系に取り込まれる可能性がある。

10. 実践的なベストプラクティス#

10.1 フィルタの段階的構築#

複雑なjqフィルタを一度に記述しようとすると誤りが生じやすい。段階的に構築し、各段階で出力を確認するアプローチが推奨される。

# 段階1: データ全体の確認
cat data.json | jq '.'

# 段階2: 目的のキーへのアクセス確認
cat data.json | jq '.users'

# 段階3: 配列展開の確認
cat data.json | jq '.users[]'

# 段階4: 必要フィールドの選択
cat data.json | jq '.users[] | {name: .name, email: .email}'

# 段階5: フィルタリングの追加
cat data.json | jq '[.users[] | {name: .name, email: .email} | select(.email != null)]'

10.2 `null` 値の安全な処理#

jq では存在しないフィールドへのアクセスが null を返す（エラーにならない）仕様である。これはピット（pitfall）にもなりうる。

echo '{"a": null}' | jq '.a.b'
# null  （エラーにならない）

echo '{"a": null}' | jq '.a // "default"'
# "default"  （代替値演算子）

代替値演算子 // は、左辺が false または null の場合に右辺の値を返す演算子である。

\llbracket f \,//\, g \rrbracket(v) = \begin{cases} \llbracket f \rrbracket(v) & \text{if } \llbracket f \rrbracket(v) \notin \{\mathtt{null}, \mathtt{false}\} \\ \llbracket g \rrbracket(v) & \text{otherwise} \end{cases}

ただし、代替値演算子は false も置き換えてしまうため、真偽値フィールドへの適用には注意が必要である。

10.3 `empty` を活用したフィルタリング#

empty は出力を一切生成しない特殊なフィルタ（空列を返す）であり、select の実装基盤となる。

# select(cond) は以下と等価
# if cond then . else empty end

echo '[1,2,3,4,5]' | jq '.[] | if . % 2 == 0 then . else empty end'
# 2
# 4

empty を明示的に使用することで、select より細かい制御（条件によって異なる値を出力するなど）が可能になる。

10.4 パフォーマンスに関する考慮事項#

# 非効率: 大きな配列に対して条件フィルタリング後に変換
jq '[.[] | {a: .a, b: .b}] | map(select(.a > 10))'

# 効率的: 先にフィルタリングしてから変換（不要な変換を省略）
jq '[.[] | select(.a > 10) | {a: .a, b: .b}]'

# INDEX 関数を使った O(1) ルックアップ（大きな配列での検索に有効）
jq '(.[] | INDEX(.[]; .id)) as $idx | ...'

10.5 コメントの活用（jq 1.6+）#

jq 1.6 以降、# コメントがサポートされ、複雑なフィルタの可読性向上に貢献する。

# ユーザーリストから管理者を抽出し、メールアドレス一覧を返す
[
  .users[]
  | select(.role == "admin")  # 管理者のみ選択
  | .email                     # メールアドレスを抽出
  | select(. != null)          # nullを除外
]
| unique                       # 重複を除去

11. 演習問題と解答例#

本節では、理解の深化を目的とした演習問題とその解答例を示す。

問題 1: ネストされた集計#

以下の JSON データから、部門別の平均給与と人数を計算せよ。

[
  {"name": "Alice", "dept": "Engineering", "salary": 800000},
  {"name": "Bob", "dept": "Marketing", "salary": 600000},
  {"name": "Carol", "dept": "Engineering", "salary": 750000},
  {"name": "Dave", "dept": "Marketing", "salary": 650000},
  {"name": "Eve", "dept": "Engineering", "salary": 900000}
]

解答例

echo '[
  {"name": "Alice", "dept": "Engineering", "salary": 800000},
  {"name": "Bob", "dept": "Marketing", "salary": 600000},
  {"name": "Carol", "dept": "Engineering", "salary": 750000},
  {"name": "Dave", "dept": "Marketing", "salary": 650000},
  {"name": "Eve", "dept": "Engineering", "salary": 900000}
]' | jq '
group_by(.dept) |
map({
  dept: .[0].dept,
  count: length,
  avg_salary: (map(.salary) | (add / length | floor)),
  total_salary: (map(.salary) | add)
}) |
sort_by(.dept)'

[
  {"dept": "Engineering", "count": 3, "avg_salary": 816666, "total_salary": 2450000},
  {"dept": "Marketing", "count": 2, "avg_salary": 625000, "total_salary": 1250000}
]

問題 2: 再帰的なデータ処理#

以下のネストされたカテゴリツリーから、全てのリーフノード（children が存在しないノード）の名前を抽出せよ。

{
  "name": "root",
  "children": [
    {"name": "A", "children": [
      {"name": "A1"},
      {"name": "A2"}
    ]},
    {"name": "B"},
    {"name": "C", "children": [
      {"name": "C1", "children": [
        {"name": "C1a"}
      ]}
    ]}
  ]
}

解答例

echo '{...}' | jq '[.. | objects | select(.children == null and .name != null) | .name]'

または再帰関数を用いた解：

echo '{...}' | jq '
def leaves:
  if .children == null then .name
  else .children[] | leaves
  end;
[leaves]'

["A1", "A2", "B", "C1a"]

問題 3: 差分計算#

2 つの JSON オブジェクトを比較し、追加・削除・変更されたキーを特定せよ。

解答例

jq -n '
  {"a": 1, "b": 2, "c": 3} as $old |
  {"a": 1, "b": 9, "d": 4} as $new |
  {
    added:   (($new | keys) - ($old | keys)),
    removed: (($old | keys) - ($new | keys)),
    changed: [
      ($old | keys_unsorted)[] |
      select(. as $k | $old[$k] != $new[$k] and $new[$k] != null)
    ]
  }'

{
  "added": ["d"],
  "removed": ["c"],
  "changed": ["b"]
}

12. 結論#

本稿は、jq コマンドを以下の観点から体系的に論じた。

形式言語理論的観点において、JSON データモデルを有向根付き順序木として形式化し、jq フィルタを $\mathcal{V} \to \mathcal{V}^*$ 型の多値関数として定義した。パイプライン演算子がリストモナドの bind 演算に対応すること、reduce 式が左畳み込みとして定式化されることを示した。

歴史的観点において、jq が Unix 哲学の延長線上に位置付けられ、Stephen Dolan による 2012 年の初期実装から jqlang 組織への移管を経て継続的に開発されていることを記述した。

実利的観点において、API レスポンス処理・ログ集計・設定ファイル管理・データ変換・インフラ管理自動化など多様な応用場面を具体的なコード例とともに示した。

比較的観点において、Python json モジュール・JSONPath・gron・miller との比較を行い、各ツールの適用領域における相対的な位置付けを整理した。

jq は、コマンドライン環境における JSON 処理の事実上の標準として定着しており、その設計—特にフィルタ代数の構造と Unix パイプラインとの親和性—は、現代のデータエンジニアリング実践において高い実用的価値を持つ。一方で、インプレース編集の非対応・大規模データへの適用限界・数値精度の制約といった既知の限界も存在し、利用場面に応じた適切なツール選択が求められる。

参考文献#

Dolan, S. (2012). jq: A lightweight and flexible command-line JSON processor. GitHub Repository: jqlang/jq. https://github.com/jqlang/jq
Crockford, D. (2006). The application/json Media Type for JavaScript Object Notation (JSON). RFC 4627. Internet Engineering Task Force.
Ecma International. (2013). ECMA-404: The JSON Data Interchange Syntax. 1st Edition. Ecma International.
McIlroy, M. D., Pinson, E. N., & Tague, B. A. (1978). UNIX Time-Sharing System: Foreword. The Bell System Technical Journal, 57(6), 1899–1904.
Gogolla, M. (1994). An algebraic treatment of type theory in database query languages. Theoretical Computer Science, 131(1), 37–66.
Meijer, E., Fokkinga, M., & Paterson, R. (1991). Functional programming with bananas, lenses, envelopes and barbed wire. In Proceedings of the 5th ACM Conference on Functional Programming Languages and Computer Architecture, 124–144.
Göessner, S. (2007). JSONPath - XPath for JSON. https://goessner.net/articles/JsonPath/
IETF. (2024). JSONPath: Query Expressions for JSON. RFC 9535. Internet Engineering Task Force.
Hudson, T. (2016). gron: Make JSON Greppable. GitHub Repository: tomnomnom/gron.
Wadler, P. (1995). Monads for Functional Programming. In Advanced Functional Programming, Lecture Notes in Computer Science Vol. 925, 24–52.
Bird, R. S., & Moor, O. de. (1997). The Algebra of Programming. Prentice Hall.
Okasaki, C. (1998). Purely Functional Data Structures. Cambridge University Press.
ECMA International. (2021). ECMA-262: ECMAScript 2021 Language Specification. 12th Edition. Ecma International. (JSON との関係性および数値型仕様)
IEEE. (2019). IEEE Standard for Floating-Point Arithmetic (IEEE 754-2019). IEEE.
Thompson, K. (1968). Programming Techniques: Regular expression search algorithm. Communications of the ACM, 11(6), 419–422. (PCRE の理論的基盤)
Kahn, G. (1974). The semantics of a simple language for parallel programming. Proceedings of IFIP Congress, 471–475. (ストリーム処理の理論的背景)
Filinski, A. (1994). Representing monads. In Proceedings of the 21st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, 446–457.
Scott, D. S., & Strachey, C. (1971). Toward a Mathematical Semantics for Computer Languages. Technical Report PRG-6, Programming Research Group, Oxford University. (denotational semantics の基盤)
jqlang contributors. (2024). jq Manual (development version). https://jqlang.github.io/jq/manual/
jqlang contributors. (2023-2024). jq Changelog: Version 1.7 and 1.7.1. GitHub Releases: jqlang/jq.

本記事は、生成AIによって自動構成された技術解説記事です。内容の正確性を保持するよう努めていますが、厳密な形式言語理論的証明やバージョン固有の実装詳細については、必ず原著ドキュメントおよび一次資料を参照してください。引用・実装に際しては各自の責任において検証を行ってください。

1. 序論：データ処理基盤としてのJSONと処理ツールの位置付け#

1.1 背景：構造化データ処理の必要性#

1.2 本稿の構成#

2. JSON の形式的データモデルと数理的構造#

2.1 JSON の帰納的定義#

2.2 JSON 値の木構造表現#

2.3 パスとパス式の形式化#

2.4 多値関数としての jq フィルタ#

3. jq の歴史的発展#

3.1 Unix パイプライン哲学との接続#

3.2 jq の誕生（2012年）#

3.3 リポジトリの移管と継続的開発（2023年以降）#

3.4 関連ツールの派生的発展#

4. jq フィルタ言語の形式的意味論#

4.1 フィルタ代数の構造#

4.2 パイプライン合成の形式的定義#

4.3 コンマ演算子の意味論#

4.4 配列構築演算子の意味論#

4.5 再帰展開演算子 .. の意味論#

4.6 エラーセマンティクスと ? 演算子#

4.7 reduce 式の形式的意味論#

5. jq の構文体系と主要演算子#

5.1 基本的なデータアクセス#

5.2 配列・オブジェクトの反復処理#

5.3 データ型と型検査#

5.4 条件式と選択#

5.5 組み込み関数#

5.6 文字列処理#

5.7 変数束縛と再利用#

5.8 ユーザー定義関数#

5.9 @base64d と入出力制御#

6. jq のアーキテクチャと実装上の考慮点#

6.1 処理パイプラインの概観#

6.2 メモリ効率とストリーミング処理#

6.3 jq の計算複雑性#

6.4 数値精度の問題#

7. 実利的な活用事例と評価#

7.1 API レスポンスのフィールド抽出とトランスフォーメーション#

7.2 ログ処理と集計#

7.3 設定ファイルの自動更新#

7.4 データ変換と形式変換#

7.5 パス操作と動的フィールドアクセス#

7.6 SQL 的な操作#

7.7 env による環境変数の利用#

7.8 AWS CLI との連携#

8. 類似ツールとの比較考察#

8.1 jq と Python の json モジュール#

8.2 jq と JSONPath#

8.3 jq と gron#

8.4 jq と miller#

9. jq の限界と将来の展望#

9.1 既知の限界#

9.2 大規模 JSON 処理における実用上の制約#

9.3 代替・後継的なアプローチ#

9.4 形式的検証の観点からの展望#

10. 実践的なベストプラクティス#

10.1 フィルタの段階的構築#

10.2 null 値の安全な処理#

10.3 empty を活用したフィルタリング#

10.4 パフォーマンスに関する考慮事項#

10.5 コメントの活用（jq 1.6+）#

11. 演習問題と解答例#

問題 1: ネストされた集計#

問題 2: 再帰的なデータ処理#

問題 3: 差分計算#

12. 結論#

参考文献#

4.5 再帰展開演算子 `..` の意味論#

4.6 エラーセマンティクスと `?` 演算子#

4.7 `reduce` 式の形式的意味論#

5.9 `@base64d` と入出力制御#

7.7 `env` による環境変数の利用#

10.2 `null` 値の安全な処理#

10.3 `empty` を活用したフィルタリング#