jq Cheat Sheet: 30 praktycznych wzorców JSON w wierszu poleceń

Przekazujesz kubectl get pods -o json do less i terminal zamiera na dwumegabajtowej ścianie JSON. A potrzebujesz tylko nazwy każdego poda w fazie Running. jq robi to w trzech znakach składni filtra — wystarczy znać słownictwo.

To nie jest referencja składni. To 30 wzorców, które naprawdę będziesz wpisywać, pogrupowanych według zadania, jakie chcesz wykonać: dostęp, filtrowanie, transformacja, agregacja, formatowanie i sklejanie z prawdziwymi narzędziami w rodzaju kubectl, aws i docker.

Kiedy używać jq, a kiedy formatera w przeglądarce lub kodu

jq nie zawsze jest właściwą odpowiedzią. Trzy uczciwe opcje wyglądają tak:

Sytuacja	Najlepsze narzędzie	Dlaczego
Pojedyncza odpowiedź API, potrzebujesz podświetlania składni i numerów linii błędów	Przeglądarkowy JSON Formatter	Wizualny diff, zero konfiguracji, prywatnie w przeglądarce
Potok powłoki, przetwarzanie logów, skrypt CI, zdalny serwer	jq	Komponowalny, skryptowalny, bez zależności od GUI
Logika biznesowa, testy jednostkowe, złożone rozgałęzienia	Kod (JS / Python)	Prawdziwy debugger, typy, biblioteki

Wybieraj jq, gdy zadanie żyje wewnątrz potoku powłoki — wszystko inne najpewniej łatwiej wykonać gdzie indziej.

Instalacja i pierwszy potok

jq dostarczany jest jako pojedynczy plik binarny na każdej liczącej się platformie:

# macOS
brew install jq

# Debian / Ubuntu
sudo apt install jq

# Windows (winget)
winget install jqlang.jq

Pierwszy potok, z filtrem tożsamości:

curl -s https://api.github.com/users/octocat | jq .

Filtr . przyjmuje swoje wejście i zwraca je niezmienione, w wersji pretty-print. Już to samo zastępuje większość momentów typu „pozwól, że otworzę ten JSON w edytorze”.

Pięć flag pokrywa 90% realnych zastosowań:

Flaga	Zastosowanie
-r	Raw output — usuwa cudzysłowy otaczające wyniki będące łańcuchami
-c	Compact — jedna wartość JSON na linię (NDJSON)
-s	Slurp — wczytuje wszystkie wejścia do jednej tablicy
-R	Raw input — czyta linie jako łańcuchy zamiast jako JSON
-n	Null input — nie czyta stdin, jako wejście używa null

Podstawowy model myślowy: filtry i potoki

Filtr przyjmuje jedną wartość JSON jako wejście i produkuje zero lub więcej wartości JSON jako wyjście. Filtry komponują się przez potok |, który przekazuje każde wyjście lewego filtra jako wejście do prawego filtra. To ten sam model myślowy co potoki powłoki, tylko że płyną wartości JSON, a nie bajty.

# . — tożsamość
echo '{"name":"Alice"}' | jq '.'

# .key — dostęp do pola
echo '{"name":"Alice"}' | jq '.name'

# .key.sub — głęboka ścieżka
echo '{"user":{"email":"a@x.com"}}' | jq '.user.email'

# .[] — iteruj po elementach tablicy (produkuje wiele wyjść)
echo '[{"id":1},{"id":2}]' | jq '.[] | .id'

# Komponowanie potokiem: każde wyjście .items[] zasila .name
echo '{"items":[{"name":"a"},{"name":"b"}]}' | jq '.items[] | .name'

To cała gramatyka. 30 wzorców poniżej to kombinacje tych prymitywów.

30 wzorców, których naprawdę będziesz używać

Każdy wzorzec pokazuje wejściowy JSON, polecenie i wyjście. Każdy z nich można skopiować bezpośrednio do terminala.

Dostęp i ekstrakcja (wzorce 1–5)

Wzorzec 1 — Bezpieczny dostęp z ?

Dostęp do pola, które może nie istnieć, bez wywalania błędu:

echo '{"name":"Alice"}' | jq '.address?.city?'
# Wynik: null

? wycisza błędy przy brakujących kluczach. Bez tego .address.city zgłosiłoby błąd typu, jeśli .address byłoby nieobecne.

Wzorzec 2 — Dostęp przez głęboką ścieżkę

echo '{"user":{"profile":{"email":"a@x.com"}}}' | jq '.user.profile.email'
# Wynik: "a@x.com"

Wzorzec 3 — Wycinanie tablic

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

echo '[10,20,30,40,50]' | jq '.[-1]'
# Wynik: 50

Indeksy ujemne liczone są od końca. Wycinki używają przedziałów półotwartych, jak w Pythonie.

Wzorzec 4 — Schodzenie rekurencyjne, by znaleźć każdy pasujący klucz

echo '{"a":{"name":"x"},"b":[{"name":"y"},{"id":1}]}' | jq '.. | .name? | select(. != null)'
# Wynik: "x"
#         "y"

.. przechodzi każdą wartość w drzewie. W połączeniu z .name? i select wyciąga każde pole name niezależnie od głębokości — bezcenne przy eksploracji nieznanych schemas JSON.

Wzorzec 5 — Wypisz wszystkie klucze obiektu

echo '{"zebra":1,"apple":2,"mango":3}' | jq 'keys'
# Wynik: ["apple", "mango", "zebra"]

echo '{"zebra":1,"apple":2,"mango":3}' | jq 'keys_unsorted'
# Wynik: ["zebra", "apple", "mango"]

keys sortuje alfabetycznie; keys_unsorted zachowuje kolejność wstawiania.

Filtrowanie (wzorce 6–10)

Wzorzec 6 — Filtruj tablicę po warunku

echo '[{"age":20},{"age":30},{"age":40}]' | jq 'map(select(.age > 25))'
# Wynik: [{"age":30},{"age":40}]

map(f) aplikuje f do każdego elementu; select(cond) zatrzymuje tylko elementy spełniające warunek.

Wzorzec 7 — Dopasowanie po prefiksie łańcucha

echo '[{"name":"api-gateway"},{"name":"web-ui"},{"name":"api-auth"}]' \
  | jq '.[] | select(.name | startswith("api"))'
# Wynik: {"name":"api-gateway"}
#         {"name":"api-auth"}

Przydatne też: endswith("..."), contains("..."), test("^regex$").

Wzorzec 8 — Warunki łączone

echo '[{"type":"A","count":5},{"type":"A","count":15},{"type":"B","count":20}]' \
  | jq '.[] | select(.type == "A" and .count > 10)'
# Wynik: {"type":"A","count":15}

and, or, not działają zgodnie z oczekiwaniami.

Wzorzec 9 — Usuwanie wrażliwych pól

echo '{"user":"alice","password":"s3cret","token":"abc"}' | jq 'del(.password, .token)'
# Wynik: {"user":"alice"}

del() przyjmuje wiele ścieżek i jest bezpieczne, jeśli któraś z nich nie istnieje.

Wzorzec 10 — Deduplikacja po polu

echo '[{"id":1,"v":"a"},{"id":2,"v":"b"},{"id":1,"v":"a2"}]' | jq 'unique_by(.id)'
# Wynik: [{"id":1,"v":"a"},{"id":2,"v":"b"}]

unique deduplikuje całe wartości; unique_by(f) deduplikuje na podstawie wyniku filtra.

Transformacja (wzorce 11–15)

Wzorzec 11 — Zmiana nazw pól

echo '[{"first_name":"Alice","age":30}]' | jq 'map({name: .first_name, age})'
# Wynik: [{"name":"Alice","age":30}]

Skrót {age} jest równoważny zapisowi {age: .age}.

Wzorzec 12 — Dodaj pole obliczone z interpolacją łańcucha

echo '[{"first":"Alice","last":"Chen"}]' \
  | jq 'map(. + {fullName: "\(.first) \(.last)"})'
# Wynik: [{"first":"Alice","last":"Chen","fullName":"Alice Chen"}]

\(expr) ewaluuje expr i wstawia jego wartość do łańcucha.

Wzorzec 13 — Spłaszczanie zagnieżdżonych tablic

echo '[{"tags":["a","b"]},{"tags":["c"]}]' | jq '[.[] | .tags[]]'
# Wynik: ["a","b","c"]

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

flatten przyjmuje opcjonalny argument głębokości: flatten(1) zdejmuje tylko jeden poziom.

Wzorzec 14 — Obiekt na tablicę i z powrotem

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

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

Ta para umożliwia transformacje wymagające iterowania po kluczach obiektu — czego składnia z kropkami nie potrafi zrobić bezpośrednio.

Wzorzec 15 — Głęboki merge dwóch obiektów

echo '{"a":{"x":1},"b":2}' | jq '. * {a:{y:9}, c:3}'
# Wynik: {"a":{"x":1,"y":9},"b":2,"c":3}

Operator * wykonuje głęboki merge. Dla płytkiego mergowania użyj + (wygrywa prawa strona).

Agregacja (wzorce 16–20)

Wzorzec 16 — Długość tablic, obiektów i łańcuchów

echo '[1,2,3,4]' | jq 'length'      # 4
echo '{"a":1,"b":2}' | jq 'length'  # 2
echo '"hello"' | jq 'length'        # 5

Wzorzec 17 — Sumuj pole

echo '[{"price":10},{"price":25},{"price":5}]' | jq '[.[].price] | add'
# Wynik: 40

add sumuje liczby, konkatenuje łańcuchy lub łączy tablice — w zależności od typu wejścia.

Wzorzec 18 — Grupowanie po polu

echo '[{"cat":"A","n":1},{"cat":"B","n":2},{"cat":"A","n":3}]' | jq 'group_by(.cat)'
# Wynik: [[{"cat":"A","n":1},{"cat":"A","n":3}],[{"cat":"B","n":2}]]

Każda grupa staje się tablicą wewnętrzną. Połącz z map, by agregować w obrębie grupy.

Wzorzec 19 — Sortuj malejąco

echo '[{"date":"2026-01-03"},{"date":"2026-01-01"},{"date":"2026-01-02"}]' \
  | jq 'sort_by(.date) | reverse'
# Wynik: [{"date":"2026-01-03"},{"date":"2026-01-02"},{"date":"2026-01-01"}]

Łańcuchy z datami w formacie ISO 8601 sortują się poprawnie jako łańcuchy. Dla innych formatów najpierw je sparsuj — przewodnik po Unix timestamp szczegółowo omawia sekundy epoch, milisekundy i konwersję stref czasowych.

Wzorzec 20 — Maksimum lub minimum po polu

echo '[{"name":"a","rating":4.1},{"name":"b","rating":4.8},{"name":"c","rating":3.9}]' \
  | jq 'max_by(.rating)'
# Wynik: {"name":"b","rating":4.8}

min_by, max_by zwracają pojedynczy element. Dla top N użyj sort_by(.rating) | reverse | .[:N].

Formatowanie wyjścia (wzorce 21–25)

Wzorzec 21 — Wyjście CSV

echo '[{"name":"Alice","age":30},{"name":"Bob","age":25}]' \
  | jq -r '.[] | [.name, .age] | @csv'
# Wynik: "Alice",30
#         "Bob",25

@csv ujmuje łańcuchy w cudzysłowy i escape’uje cudzysłowy w środku. -r usuwa zewnętrzne cudzysłowy łańcucha JSON, dzięki czemu CSV jest gotowy do dalszego potokowania. Pełną drogę tam i z powrotem między CSV a JSON w potokach opisuje przewodnik konwersji CSV na JSON.

Wzorzec 22 — Wyjście TSV

echo '[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]' \
  | jq -r '.[] | [.id, .name] | @tsv'
# Wynik: 1	Alice
#         2	Bob

Wyjście rozdzielone tabulatorami dobrze współpracuje z cut, awk i column -t.

Wzorzec 23 — Surowe wyjście łańcuchowe

echo '["alpha","beta"]' | jq -r '.[]'
# Wynik: alpha
#         beta

Bez -r każda linia miałaby otaczające cudzysłowy. Surowe wyjście to to, czym karmisz xargs, while read lub kolejne polecenie powłoki.

Wzorzec 24 — NDJSON / JSON Lines

echo '[{"a":1},{"a":2}]' | jq -c '.[]'
# Wynik: {"a":1}
#         {"a":2}

Każda linia to samodzielna wartość JSON — format używany przez Kafkę, Elasticsearch i większość ustrukturyzowanych loggerów. -c dodatkowo usuwa wewnętrzne białe znaki.

Wzorzec 25 — Interpolacja łańcucha do sformatowanego wyjścia

echo '[{"name":"server-1","cpu":0.73},{"name":"server-2","cpu":0.21}]' \
  | jq -r '.[] | "\(.name): \(.cpu * 100)% CPU"'
# Wynik: server-1: 73% CPU
#         server-2: 21% CPU

Świetne do podsumowań i linii logów, gdzie surowy JSON byłby tylko szumem.

DevOps w praktyce (wzorce 26–30)

Wzorzec 26 — kubectl: nazwy wszystkich uruchomionych podów

kubectl get pods -o json \
  | jq -r '.items[] | select(.status.phase=="Running") | .metadata.name'

Potok: iteracja po podach, zostawiamy tylko Running, emitujemy nazwę jako surowy łańcuch.

Wzorzec 27 — AWS EC2: identyfikatory instancji z publicznymi IP

aws ec2 describe-instances \
  | jq -r '.Reservations[].Instances[] | [.InstanceId, .PublicIpAddress // "none"] | @tsv'

Operator alternatywy // dostarcza wartość zastępczą, gdy pole jest null — dzięki czemu w kolumnie wyjściowej nie pojawia się dosłowne null.

Wzorzec 28 — GitHub API: scal wyniki z paginacji

for p in 1 2 3; do
  curl -s "https://api.github.com/orgs/myorg/repos?per_page=100&page=$p"
done | jq -s 'add | map(.name)'

-s zbiera wszystkie odpowiedzi w jedną tablicę tablic, add je konkatenuje, a map(.name) wyciąga nazwy. Częsty wzorzec dla każdego paginowanego API.

Wzorzec 29 — Filtruj ustrukturyzowane pliki logów

cat app.log | jq -c 'select(.level=="error")'

Zakłada, że plik logów jest w formacie NDJSON (jeden obiekt JSON na linię). Połącz z tail -f dla monitorowania na żywo:

tail -f app.log | jq -c 'select(.level=="error") | {ts: .timestamp, msg: .message}'

Wzorzec 30 — Docker: wszystkie używane nazwy obrazów

docker inspect $(docker ps -q) | jq -r '.[].Config.Image' | sort -u

Dobre do szybkiego sprawdzenia, jakie wersje obrazów są uruchomione na hoście.

Typowe błędy i jak je naprawić

Każdy użytkownik jq na nie wpada. Znajomość rozwiązania z wyprzedzeniem oszczędza godziny.

Cannot iterate over null (null)

Pole wejściowe, po którym próbowałeś iterować, było null lub brakujące. Dwie poprawki:

# Wariant A: operator opcjonalny
echo '{}' | jq '.items[]?'
# Wynik: (nic, bez błędu)

# Wariant B: operator alternatywy z wartością domyślną
echo '{}' | jq '(.items // [])[]'
# Wynik: (nic, bez błędu)

Użyj ?, gdy chcesz cichego pominięcia. Użyj // [], gdy potrzebujesz konkretnej pustej tablicy, aby kolejne filtry mogły dalej działać.

Cannot index array with "key"

Napisałeś .foo, a bieżąca wartość jest tablicą. Dodaj [], aby iterować:

# Źle
echo '{"users":[{"name":"Alice"}]}' | jq '.users.name'
# Błąd: Cannot index array with "name"

# Dobrze
echo '{"users":[{"name":"Alice"}]}' | jq '.users[].name'
# Wynik: "Alice"

Problemy z cytowaniem w powłoce

Cały program jq otaczaj pojedynczymi cudzysłowami, a w środku używaj podwójnych dla literałów łańcuchowych:

# Działa wszędzie
jq '.users[] | select(.role == "admin")'

# Psuje się — podwójne cudzysłowy najpierw interpretuje powłoka
jq ".users[] | select(.role == \"admin\")"

Pułapki PowerShell na Windowsie

PowerShell nie traktuje pojedynczych cudzysłowów tak samo. Lepiej otaczaj program podwójnymi cudzysłowami i escape’uj wewnętrzne, albo użyj here-string:

jq "@'
.users[] | select(.role == \"admin\")
'@"

Dla czegokolwiek nietrywialnego zapisz filtr do pliku .jq i uruchom jq -f filter.jq.

Złe użycie raw output

-r wpływa tylko na wyniki będące łańcuchami. Podanie obiektu daje normalny obiekt JSON:

echo '{"a":1}' | jq -r '.'
# Wynik: {"a":1}     ← bez zmian; -r nie miało czego usuwać

Jeśli chcesz konkretne pole bez cudzysłowów, najpierw je wyselekcjonuj: jq -r '.a'.

jq odrzuca JSON z komentarzami lub przecinkami kończącymi

echo '{"a": 1, /* note */ "b": 2,}' | jq .
# parse error: Invalid numeric literal

jq trzyma się ścisłego RFC 8259 JSON — bez komentarzy, bez przecinków kończących, bez kluczy bez cudzysłowów. Jeśli plik jest w formacie JSON5 lub JSONC (częste w plikach konfiguracyjnych), najpierw zdejmij rozszerzenia. Przewodnik po formatach JSON5 i JSONC opisuje, które parsery je obsługują i jak skonwertować do ścisłego JSON, zanim wpuścisz dane do jq.

jq a alternatywy: gron, fx, jj, yq

jq nie jest jedyną opcją, a czasami inne narzędzie okazuje się szybsze:

Narzędzie	Mocna strona	Kiedy po nie sięgnąć
gron	Spłaszcza JSON do ścieżek przeszukiwalnych przez grep	Eksploracja nieznanych schemas — nie wiesz, gdzie jest klucz
fx	Interaktywny eksplorator TUI z podświetlaniem	Ręczne przeglądanie dużego JSON
jj	Znacznie szybszy od jq, ograniczona składnia	Gorące pętle przetwarzające miliony rekordów
yq	Ten sam język filtrów, ale dla YAML	Manifesty Kubernetes i konfiguracja CI
Przeglądarkowy JSON Formatter	Podświetlanie składni, precyzyjne komunikaty o błędach, zero instalacji	Debugowanie pojedynczej odpowiedzi w trakcie developmentu

W codziennej pracy z powłoką jq wygrywa komponowalnością. Dla jednorazowej eksploracji gron często jest szybszy. Dla YAML używaj yq — nie próbuj przepuszczać danych przez yq-then-jq.

Profesjonalne wskazówki na co dzień

Kilka nawyków, dzięki którym jq zacznie wydawać się naturalny:

1. Trzymaj .jqrc w $HOME. Wrzuć tam funkcje pomocnicze, a będą dostępne w każdym wywołaniu jq:

   def running: select(.status.phase == "Running");
   def table(f): [f] | @tsv;

2. Używaj jqplay.org dla złożonych filtrów. Wklej JSON po lewej, iteruj filtr po prawej, gotową wersję wstaw do skryptu.

3. Zbuduj własną ściągawkę z history. history | grep 'jq ' | sort -u > ~/jq-patterns.txt zapisze każdy wzorzec, którego naprawdę użyłeś.

4. Łącz z przeglądarkowym JSON Formatterem dla nieznanych schemas. Najpierw obejrzyj strukturę wzrokiem, by znaleźć potrzebną ścieżkę, a potem napisz polecenie jq.

5. Obserwuj wartości na żywo: watch -n 5 "curl -s api.example.com/health | jq '.uptime'" odświeża co 5 sekund — szybki dashboard ops bez żadnych zależności.

FAQ

Czym jest jq i dlaczego używają go deweloperzy?

jq to procesor JSON dla wiersza poleceń. Wyciąga, filtruje i transformuje JSON wewnątrz potoków powłoki, bez potrzeby skryptu w Pythonie czy w Node.js — najszybsza droga od odpowiedzi API, plików logów lub wyjścia kubectl do pola, którego naprawdę potrzebujesz.

Czy jq jest dostępny na Windowsie?

Tak. Zainstaluj przez winget install jqlang.jq, Chocolatey choco install jq lub pobierz binarkę ze strony jqlang.org. Reguły cytowania w PowerShellu różnią się od bash — w razie wątpliwości zapisz filtry do pliku .jq i uruchom jq -f filter.jq.

Czym jq różni się od formatera JSON w przeglądarce?

Przeglądarkowy JSON Formatter jest interaktywny — wkleisz JSON, widzisz podświetlanie i błędy, kopiujesz wynik. jq jest nieinteraktywny — opisujesz transformację raz i uruchamiasz ją w potoku powłoki. Przeglądarki używaj do debugowania jednej odpowiedzi; jq do automatyzacji tej samej operacji na setkach.

Dlaczego jq mówi „Cannot iterate over null”?

Spróbowałeś iterować (.[]) po wartości, która jest null — zwykle dlatego, że pole nie istniało na wejściu. Napraw operatorem opcjonalnym .items[]? albo dostarcz wartość domyślną: .items // [] | .[].

Czy jq potrafi modyfikować pliki w miejscu?

Bezpośrednio nie — jq pisze do stdout. Użyj pliku tymczasowego lub sponge z moreutils: jq '.version = "2.0"' config.json | sponge config.json. Zawsze najpierw zrób kopię oryginału; źle wpisany filtr nadpisze plik.

Jak używać jq z odpowiedziami curl?

Przekaż curl -s przez potok do jq. Flaga -s ucisza pasek postępu curl, dzięki czemu do jq dociera tylko ciało JSON:

curl -s https://api.github.com/users/octocat | jq '.name, .blog'

Jaka jest różnica między | w jq a | w powłoce?

Potok powłoki przesyła bajty między procesami. Potok jq przesyła wartości JSON między filtrami wewnątrz jednego wywołania jq. Pojedyncze polecenie jq z wieloma wewnętrznymi potokami działa w jednym procesie — taniej niż łańcuch jq | jq | jq.

Czy jq obsługuje JSON Lines (NDJSON)?

Tak, natywnie. jq czyta każdą linię jako niezależną wartość JSON, gdy są oddzielone białym znakiem. Użyj -c, by emitować NDJSON, i -s, by zebrać NDJSON w pojedynczą tablicę.

Jak wyświetlić JSON w trybie pretty-print bez filtrowania?

Użyj filtra tożsamości: cat data.json | jq . lub po prostu jq . < data.json. Parsuje, waliduje i pretty-printuje z wcięciem dwóch spacji — bez żadnego filtra.

Czy istnieje alternatywa dla jq z GUI?

Tak. fx daje interaktywne TUI. Dla wersji bez instalacji, przeglądarkowy JSON Formatter pokrywa większość potrzeb explore-and-validate. Narzędzia webowe w stylu jqplay.org oferują samego jq z podglądem na żywo.

Kiedy używać jq zamiast pisać skrypt w Pythonie?

Sięgaj po jq, gdy zadanie jest jednorazowe, mieści się w potoku powłoki i pozostaje w semantyce filtrowania, transformacji i ekstrakcji. Przejdź na Pythona, gdy potrzebujesz testów jednostkowych, złożonego stanu, bibliotek zewnętrznych albo logiki rozgałęzionej ponad to, co da się czytelnie utrzymać w pliku .jq.

Jak używać wyrażeń regularnych w jq?

jq udostępnia regex przez test("pattern"), match("pattern"), capture("pattern") i scan("pattern"), wszystkie w składni PCRE. Flagi przekazuj jako drugi argument: test("abc"; "i") dla trybu case-insensitive. match zwraca offsety i grupy; scan emituje każde niepokrywające się dopasowanie.

Najważniejsze wnioski

1. Najpierw model myślowy: filtr na wejściu, zero lub więcej wartości JSON na wyjściu, komponowanie przez |. Cała reszta to składnia.
2. Ucz się przez zadania, nie przez operatory: 30 wzorców powyżej pokrywa mniej więcej 95% codziennego użycia jq.
3. Obsługuj null jawnie: ? dla cichego pominięcia, // default dla konkretnej wartości domyślnej. Większość poprawek Cannot iterate over null to jedno z tych dwóch rozwiązań.
4. Wiedz, kiedy jq nie jest właściwym narzędziem: pojedyncze odpowiedzi należą do przeglądarkowego JSON Formattera; YAML należy do yq; złożona logika należy do prawdziwego kodu.
5. Łącz z istniejącym stosem: jq błyszczy wewnątrz curl, kubectl, aws, docker i potoków logów. Używaj go jako spoiwa, nie jako warstwy logiki.

Powiązane przepływy pracy z JSON znajdziesz w przewodniku po formatach JSON5 i JSONC, opisującym rozszerzenia składni dla plików konfiguracyjnych, oraz w przewodniku konwersji CSV na JSON, gdzie jq wpasowuje się w potok migracji formatów danych. Gdy w JSON pojawiają się timestampy, przewodnik po Unix timestamp opisuje pułapki, na które trafisz przy transformowaniu pól z datami.