Bash में JSON फॉर्मेटिंग: jq और python3 गाइड
मुफ़्त JSON Formatter & Beautifier को सीधे अपने ब्राउज़र में उपयोग करें — इंस्टॉलेशन की ज़रूरत नहीं।
JSON Formatter & Beautifier ऑनलाइन आज़माएं →जब एक deploy स्क्रिप्ट API रिस्पॉन्स प्रोसेस करना या CI में कॉन्फ़िग फ़ाइलें वैलिडेट करना शुरू करती है, तो bash में JSON फॉर्मेट करना जल्दी ही ज़रूरी हो जाता है। वास्तविक दुनिया के 99% मामलों को कवर करने वाले दो टूल हैं jq और python3 -m json.tool — दोनों json bash फॉर्मेट पाइपलाइन को विश्वसनीय रूप से चला सकते हैं, एग्जिट कोड के साथ वैलिडेट कर सकते हैं और CI/CD वर्कफ़्लो में साफ़ तरीके से इंटीग्रेट हो सकते हैं। टर्मिनल के बिना एक बार के इंस्पेक्शन के लिए, ब्राउज़र-आधारित JSON Formatter तुरंत काम करता है। यह गाइड jq इंस्टॉलेशन, पाइप और फ़ाइल फॉर्मेटिंग, वैलिडेशन फंक्शन, GitHub Actions में CI/CD इंटीग्रेशन, pre-commit hooks, heredoc पैटर्न और Python stdlib फॉलबैक का उपयोग कब करें, सब कवर करती है।
- •
jq .एक साथ फॉर्मेट AND वैलिडेट करता है — इनवैलिड JSON पर कोड 1 से बाहर निकलता है - • CI पाइपलाइन में
jq -eउपयोग करें: खाली/false/null आउटपुट पर नॉन-ज़ीरो एग्जिट - •
jq . file.json > /dev/null && echo "valid"— आउटपुट बदले बिना वैलिडेट करें - •
python3 -m json.toolबिना किसी अतिरिक्त इंस्टॉलेशन के किसी भी सिस्टम पर काम करता है - • कभी न करें
jq . f.json > f.json— shell, jq के पढ़ने से पहले सोर्स फ़ाइल को ट्रंकेट कर देता है
Bash में JSON फॉर्मेटिंग क्या है?
Bash में JSON फॉर्मेटिंग का मतलब है कॉम्पैक्ट, मिनिफाइड JSON को इंडेंटेड, मानव-पठनीय आउटपुट में बदलना। अंतर्निहित डेटा अपरिवर्तित रहता है — केवल व्हाइटस्पेस और लाइन ब्रेक अलग होते हैं। स्क्रिप्टिंग संदर्भों में यह दो कारणों से महत्वपूर्ण है: डिबगिंग के दौरान पठनीयता, और वैलिडेशन जब फॉर्मेटर साइड इफेक्ट के रूप में सिंटैक्स की दोबारा जाँच करता है। jq जैसे टूल री-फॉर्मेटिंग से पहले JSON को पूरी तरह पार्स करते हैं, जिसका मतलब है कि एक सफल फॉर्मेट रन एक अंतर्निहित वैधता जाँच भी है। यही दोहरा व्यवहार — एक कदम में फॉर्मेट और वैलिडेट — jq को स्वचालित पाइपलाइन में इतना उपयोगी बनाता है।
{"service":"payments-api","version":"2.4.1","database":{"host":"db-prod-01.internal","port":5432,"pool_size":20},"cache":{"enabled":true,"ttl":300}}{
"service": "payments-api",
"version": "2.4.1",
"database": {
"host": "db-prod-01.internal",
"port": 5432,
"pool_size": 20
},
"cache": {
"enabled": true,
"ttl": 300
}
}jq — Bash में JSON फॉर्मेट करना
jq shell स्क्रिप्ट में JSON प्रोसेसिंग का de-facto स्टैंडर्ड है (jq 1.6+, bash 4+)। यह एक उद्देश्य-निर्मित कमांड-लाइन JSON प्रोसेसर है जो JSON को फॉर्मेट, फ़िल्टर, ट्रांसफॉर्म और वैलिडेट कर सकता है। आइडेंटिटी फ़िल्टर . इनपुट को बिना बदले पास करता है, लेकिन फॉर्मेटेड। जब jq इनपुट पार्स नहीं कर पाता तो कोड 1 से बाहर निकलता है — यही इसे स्क्रिप्टिंग के लिए आदर्श बनाता है: फॉर्मेटिंग और वैलिडेशन एकल ऑपरेशन है।
jq इंस्टॉल करें
# macOS brew install jq # Debian / Ubuntu apt-get install -y jq # Fedora / RHEL / CentOS dnf install jq # Alpine (Docker इमेज) apk add --no-cache jq # वेरिफाई करें jq --version # jq-1.7.1
stdin और फ़ाइल से फॉर्मेट करें
# inline JSON को jq के माध्यम से पाइप करें
echo '{"host":"db-prod-01.internal","port":5432}' | jq .
# फ़ाइल को सीधे फॉर्मेट करें (stdout पर प्रिंट करता है)
jq . config/feature-flags.json
# 4-स्पेस इंडेंटेशन के साथ फॉर्मेट करें
jq --indent 4 . config/feature-flags.json
# स्पेस की बजाय टैब्स का उपयोग करके फॉर्मेट करें
jq --tab . config/feature-flags.jsonफॉर्मेटेड आउटपुट को फ़ाइल में लिखें
# फॉर्मेटेड आउटपुट सेव करें (उसी फ़ाइल पर वापस रीडायरेक्ट न करें) jq . compact.json > formatted.json # कॉम्पैक्ट (मिनिफाई) — फॉर्मेटिंग का उलटा jq -c . formatted.json
jq इनवैलिड JSON पर 1 कोड से, सफलता पर 0 कोड से, और usage एरर पर 5 कोड से बाहर निकलता है। इसे अपनी स्क्रिप्ट में if स्टेटमेंट और || exit 1 गार्ड में उपयोग करें।कीज़ सॉर्ट करें और रंग हटाएँ
# सभी कीज़ को वर्णमाला क्रम से सॉर्ट करें (डिटर्मिनिस्टिक diff के लिए उपयोगी) jq --sort-keys . config/app-config.json # लॉग फ़ाइल में लिखते समय रंगीन आउटपुट अक्षम करें jq --monochrome-output . response.json >> deploy.log
jq विकल्प संदर्भ
फॉर्मेटिंग और वैलिडेशन वर्कफ़्लो के लिए सबसे अधिक उपयोग किए जाने वाले jq फ्लैग:
Bash स्क्रिप्ट में JSON वैलिडेट करना
jq में वैलिडेशन और फॉर्मेटिंग एक ही ऑपरेशन है — यह प्रिंट करने से पहले पार्स करता है। जब आप फॉर्मेटेड आउटपुट के बिना केवल एग्जिट कोड चाहते हैं तो stdout को /dev/null पर रीडायरेक्ट करें। नीचे दिया गया पैटर्न deploy स्क्रिप्ट, pre-commit hooks और CI पाइपलाइन में पुन: उपयोग योग्य है। incident response में, किसी अपरिचित API पेलोड के साथ मेरा पहला काम होता है उसे jq के माध्यम से पाइप करना — यह मिनिफाइड JSON की दीवार को कुछ ऐसा बनाता है जिसे मैं वास्तव में पढ़ और debug कर सकूँ।
पुन: उपयोग योग्य वैलिडेशन फंक्शन
validate_json() {
local file="$1"
if jq . "$file" > /dev/null 2>&1; then
echo "✓ वैलिड JSON: $file"
return 0
else
echo "✗ इनवैलिड JSON: $file" >&2
return 1
fi
}इनवैलिड कॉन्फ़िग पर deploy रोकें
CONFIG="infra/k8s/app-config.json"
validate_json "$CONFIG" || { echo "Deploy रद्द: इनवैलिड कॉन्फ़िग" >&2; exit 1; }एक डायरेक्टरी में सभी JSON फ़ाइलें वैलिडेट करें
find ./config -name "*.json" | while read -r f; do jq . "$f" > /dev/null 2>&1 || echo "इनवैलिड: $f" done
-e / --exit-status फ्लैग और आगे जाता है: यह तब भी कोड 1 से बाहर निकलता है जब आउटपुट false या null हो। किसी विशिष्ट फ़ील्ड के truthy होने की पुष्टि करने के लिए उपयोग करें: jq -e '.feature_flags.new_checkout' config.json.फ़ाइलों और API रिस्पॉन्स से JSON फॉर्मेट करना
shell स्क्रिप्ट में JSON के दो सामान्य स्रोत हैं डिस्क पर फ़ाइलें और curl के माध्यम से HTTP API रिस्पॉन्स। प्रत्येक का थोड़ा अलग हैंडलिंग पैटर्न है। फ़ाइलों के लिए, मुख्य चिंता सुरक्षित in-place editing है। API रिस्पॉन्स के लिए, मुख्य विवरण curl के प्रोग्रेस बार को दबाना है ताकि यह jq के इनपुट को खराब न करे।
फ़ाइल का सुरक्षित in-place फॉर्मेटिंग
# temp फ़ाइल का उपयोग करके सुरक्षित रूप से फॉर्मेट और ओवरराइट करें tmp=$(mktemp) jq --indent 2 . config/feature-flags.json > "$tmp" && mv "$tmp" config/feature-flags.json echo "config/feature-flags.json फॉर्मेट किया गया"
curl API रिस्पॉन्स फॉर्मेट करें
# API से deployment स्टेटस फॉर्मेट करें DEPLOY_ID="dep_8f3a2b9c" curl -s \ -H "Authorization: Bearer $DEPLOY_API_TOKEN" \ "https://api.deployments.internal/v1/deploys/$DEPLOY_ID" \ | jq --indent 2 .
एक साथ फॉर्मेट और फ़िल्टर करें
# monitoring endpoint से फॉर्मेटेड + केवल errors पर फ़िल्टर करें
curl -s "https://monitoring.internal/api/events?level=error&limit=10" \
| jq '[.events[] | {id, message, timestamp, service}]' \
|| { echo "Events फ़ेच या पार्स करने में विफल" >&2; exit 1; } || { ... } पैटर्न यहाँ महत्वपूर्ण है। इसके बिना, एक विफल curl या खराब API रिस्पॉन्स चुपचाप पास हो जाता है और आपकी स्क्रिप्ट का अगला चरण खाली या आंशिक डेटा पर काम करता है। यदि आपको पहले फ़िल्टर एक्सप्रेशन लिखे बिना जटिल नेस्टेड रिस्पॉन्स इंस्पेक्ट करने की आवश्यकता है, तो ब्राउज़र-आधारित JSON Formatter आपको raw रिस्पॉन्स पेस्ट करके ट्री को इंटरैक्टिव रूप से नेविगेट करने देता है।
CI/CD पाइपलाइन में JSON फॉर्मेट करना
CI वह जगह है जहाँ JSON वैलिडेशन गेट्स सबसे अधिक मायने रखते हैं — प्रोडक्शन तक पहुँचने वाला खराब कॉन्फ़िग पाइपलाइन की विफलता से कहीं अधिक दर्दनाक है। अधिकांश प्रतियोगी jq को one-off टर्मिनल उपयोग के लिए डॉक्युमेंट करते हैं; नीचे दिए गए पैटर्न वे हैं जो मैं प्रोडक्शन SRE वर्कफ़्लो में कॉन्फ़िग एरर को deployment slot तक पहुँचने से पहले पकड़ने के लिए उपयोग करता हूँ।
GitHub Actions — सभी JSON कॉन्फ़िग वैलिडेट करें
- name: JSON कॉन्फ़िग वैलिडेट करें
run: |
echo "JSON कॉन्फ़िगरेशन फ़ाइलें वैलिडेट हो रही हैं..."
find . -name "*.json" -not -path "*/node_modules/*" | while read -r f; do
if ! jq . "$f" > /dev/null 2>&1; then
echo "::error file=$f::इनवैलिड JSON सिंटैक्स"
exit 1
fi
done
echo "सभी JSON फ़ाइलें वैलिड हैं"Pre-commit hook — staged JSON फ़ाइलें वैलिडेट करें
#!/usr/bin/env bash
set -euo pipefail
STAGED=$(git diff --cached --name-only --diff-filter=ACM | grep '\.json$' || true)
[ -z "$STAGED" ] && exit 0
for f in $STAGED; do
jq . "$f" > /dev/null 2>&1 || { echo "इनवैलिड JSON: $f"; exit 1; }
done
echo "JSON वैलिडेशन पास"scripts/validate-json.sh में सेव करें, chmod +x scripts/validate-json.sh से executable बनाएँ, फिर symlink बनाएँ: ln -s ../../scripts/validate-json.sh .git/hooks/pre-commit.Bash में JSON वेरिएबल और Heredoc फॉर्मेट करना
Shell स्क्रिप्ट अक्सर JSON पेलोड डायनेमिक रूप से बनाती हैं — एनवायरनमेंट वेरिएबल, git metadata या computed values से। सबसे सुरक्षित पैटर्न jq -n --arg / --argjson है न कि string interpolation, जो उस पल टूट जाता है जब कोई value एक quote या newline रखती है। JSON में whitespace पर word splitting को रोकने के लिए jq को पाइप करते समय हमेशा वेरिएबल्स को double-quote करें।
stored API रिस्पॉन्स वेरिएबल फॉर्मेट करें
# हमेशा "$API_RESPONSE" को quote करें — JSON में whitespace unquoted expansion को तोड़ देगा echo "$API_RESPONSE" | jq --indent 2 .
jq -n के साथ पेलोड बनाएँ और फॉर्मेट करें
payload=$(jq -n \
--arg env "production" \
--arg version "$(git describe --tags)" \
--argjson replicas 3 \
'{environment: $env, version: $version, replicas: $replicas}')
# बना हुआ पेलोड इंस्पेक्ट करें
echo "$payload" | jq .
# API पर पोस्ट करें
curl -s -X POST \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $DEPLOY_API_TOKEN" \
-d "$payload" \
"https://api.deployments.internal/v1/deploys"--arg हमेशा एक string value बाइंड करता है। --argjson value को पहले JSON के रूप में पार्स करता है, इसलिए आप filter expression के अंदर उन्हें quote किए बिना numbers, booleans, arrays और objects पास कर सकते हैं।jq इंस्टॉल किए बिना Bash में JSON फॉर्मेट करना
जब jq उपलब्ध नहीं हो — minimal Docker images, locked-down CI runners, या ऐसे सिस्टम जहाँ आप packages इंस्टॉल नहीं कर सकते — Python का बिल्ट-इन json.tool मॉड्यूल वही मुख्य क्षमता प्रदान करता है। यह Python standard library का हिस्सा है; यदि Python 3 इंस्टॉल है, यह बिना किसी अतिरिक्त dependency के काम करता है।
# फ़ाइल से फॉर्मेट करें python3 -m json.tool config.json # इंडेंट width कंट्रोल करें python3 -m json.tool --indent 2 config.json # कीज़ को वर्णमाला क्रम से सॉर्ट करें python3 -m json.tool --sort-keys config.json # stdin से फॉर्मेट करें (जैसे curl से पाइप) curl -s https://api.deployments.internal/v1/status | python3 -m json.tool
python3 -m json.tool jq से अधिक सख्त है: यह trailing commas, comments और JSON5 extensions को अस्वीकार करता है। यह कड़ाई प्रोडक्शन कॉन्फ़िग वैलिडेशन के लिए वांछनीय है लेकिन third-party टूल्स से loose JSON के साथ काम करते समय friction point हो सकती है। यह colorized output भी नहीं देता, जिससे इंटरैक्टिव उपयोग के लिए टर्मिनल इंस्पेक्शन jq से कम ergonomic बनती है।# एग्जिट कोड के साथ वैलिडेशन (jq जैसी semantics)
python3 -m json.tool config.json > /dev/null && echo "valid" || echo "invalid"
# Inline string वैलिडेशन
echo '{"service":"payments-api","healthy":true}' | python3 -m json.tool > /dev/null
echo "Exit code: $?" # 0 = validसिंटैक्स हाइलाइटिंग के साथ टर्मिनल आउटपुट
jq डिफ़ॉल्ट रूप से अपना आउटपुट रंगीन करता है — keys नीले, strings हरे, numbers सफेद। जब आपको scrollable pager में पूर्ण JSON सिंटैक्स हाइलाइटिंग की आवश्यकता हो, या टर्मिनल session में बड़े नेस्टेड रिस्पॉन्स debug करते समय, bat सबसे ergonomic अनुभव देता है। दोनों debugging और interactive inspection के लिए उपयोगी हैं; किसी का भी उपयोग नहीं करना चाहिए जब files या API responses में output लिख रहे हों।
bat इंस्टॉल करें
# macOS brew install bat # Debian / Ubuntu (binary का नाम batcat हो सकता है — अगर हो तो alias बनाएँ) apt-get install -y bat # alias bat=batcat # अगर ज़रूरत हो तो ~/.bashrc में जोड़ें # वेरिफाई करें bat --version # bat 0.24.0
सिंटैक्स हाइलाइटिंग के साथ JSON फ़ाइलें देखें
# pager में syntax-highlighted JSON (बाहर निकलने के लिए q दबाएँ) bat config/app-config.json # paging अक्षम करें — सीधे टर्मिनल पर प्रिंट करें bat --paging=never config/app-config.json # रंगीन inspection के लिए jq output को bat के माध्यम से पाइप करें jq '.database' infra/app-config.json | bat --language=json --paging=never
scrollable pager में colorized jq output
# -C stdout tty न होने पर भी रंग force करता है (जैसे less में पाइप करते समय) jq -C . logs/deploy-response.json | less -R
bat / jq -C) का उपयोग केवल terminal inspection और debugging के लिए करें। log files में लिखने या अन्य tools को पाइप करने से पहले ANSI color codes हटाएँ — jq -M . (--monochrome-output) या bat --plain उपयोग करें।Bash में बड़ी JSON फ़ाइलों के साथ काम करना
जब JSON फ़ाइल 50–100 MB से अधिक हो, तो jq के default mode के साथ memory में लोड करना धीमा हो सकता है या memory-constrained hosts (512 MB सीमा वाले Docker containers) पर OOM trigger कर सकता है। jq --stream पूरे document को buffer किए बिना पढ़ते समय incrementally path/value pairs emit करता है। NDJSON (एक JSON object प्रति लाइन) के लिए, jq के पास एक अधिक efficient native approach है।
jq --stream के साथ बड़ी JSON फ़ाइल stream करें
# --stream jq के input पढ़ते समय [path, scalar] pairs emit करता है # बड़े log archive से सभी "status" fields निकालें बिना पूरी तरह लोड किए jq -c --stream 'if length == 2 and (.[0][-1] == "status") then .[1] else empty end' logs/archive-2026-03.json
NDJSON / JSON Lines — प्रति लाइन एक object प्रोसेस करें
# NDJSON: प्रति लाइन एक JSON object — Kafka exports, Fluentd और Logstash में सामान्य
# -R raw lines पढ़ता है; fromjson? उन lines को skip करता है जो valid JSON नहीं हैं
jq -c -R 'fromjson? | {id: .request_id, status: .http_status, latency: .duration_ms}' logs/access-2026-03-13.ndjson > logs/summary.ndjson# Shell loop विकल्प — उपयोगी जब per-line error handling की जरूरत हो
while IFS= read -r line; do
echo "$line" | jq -c '{id: .request_id, status: .http_status}' 2>/dev/null || echo "SKIP: malformed line" >&2
done < logs/access-2026-03-13.ndjsonjq . file.json से --stream पर स्विच करें। NDJSON pipelines के लिए, shell while read loop की बजाय jq -R 'fromjson?' पसंद करें — यह प्रति लाइन subshell spawn करने से बचकर काफ़ी तेज़ है।सामान्य गलतियाँ
समस्या: Shell, jq के input पढ़ने से पहले output file को open और truncate कर देता है। यदि source और destination एक ही path हैं, jq एक खाली file पढ़ता है।
समाधान: पहले mktemp temporary file पर लिखें, फिर mv से मूल को atomically replace करें।
jq --indent 2 . settings.json > settings.json
tmp=$(mktemp) && jq --indent 2 . settings.json > "$tmp" && mv "$tmp" settings.json
समस्या: Error handler के बिना, JSON invalid होने पर script चुपचाप खाली या missing formatted file के साथ जारी रहती है — downstream steps confusing errors के साथ fail होते हैं।
समाधान: Output produce करने वाले हर jq call के बाद || { echo '...' >&2; exit 1; } जोड़ें।
jq . response.json > formatted.json
jq . response.json > formatted.json || { echo "response.json में invalid JSON" >&2; exit 1; }समस्या: curl डिफ़ॉल्ट रूप से stderr पर progress bar प्रिंट करता है। जब stderr को stdout के साथ merge किया जाता है (जैसे subshells या log capture में), progress bar text jq के input में दिखता है और parse error का कारण बनता है।
समाधान: jq में पाइप करते समय curl को हमेशा -s (silent) पास करें। diagnostic output के लिए -v या --fail-with-body को अलग से उपयोग करें।
curl https://api.payments.internal/config | jq .
curl -s https://api.payments.internal/config | jq .
समस्या: -r / --raw-output flag top-level string values से JSON string quotes हटाता है — यह objects या arrays को format नहीं करता। Object input पर -r . पास करने से indented output की बजाय वही compact object मिलता है।
समाधान: Formatting के लिए jq . (-r flag के बिना) उपयोग करें। -r को plain string values निकालने के लिए रखें जैसे jq -r '.version' config.json।
jq -r . config.json
jq . config.json
jq vs python3 vs json_pp — त्वरित तुलना
टूल्स के बीच चुनाव इस बात पर निर्भर करता है कि आपके environment में क्या उपलब्ध है और आपको basic formatting से परे क्या चाहिए:
अधिकांश bash scripting और CI/CD काम के लिए, jq सही default है — यह single binary में बिना runtime dependency के validate, format, filter करता है और reliable exit codes प्रदान करता है। तब python3 -m json.tool पर fall back करें जब आप additional packages install नहीं कर सकते और Python already present हो।
अक्सर पूछे जाने वाले प्रश्न
bash का उपयोग करके JSON फ़ाइल को जगह पर कैसे फॉर्मेट करूँ?
jq के आउटपुट को कभी भी उसी फ़ाइल पर वापस रीडायरेक्ट न करें — shell jq के पढ़ने से पहले फ़ाइल को ट्रंकेट कर देता है। इसके बजाय, पहले एक temp फ़ाइल पर लिखें, फिर mv के साथ मूल को atomically बदलें।
tmp=$(mktemp) jq --indent 2 . config/app-config.json > "$tmp" && mv "$tmp" config/app-config.json echo "जगह पर सफलतापूर्वक फॉर्मेट किया गया"
bash स्क्रिप्ट में JSON को कैसे वैलिडेट करूँ और एरर पर कैसे बाहर निकलूँ?
फ़ाइल को jq पर पाइप या पास करें और stdout को /dev/null पर रीडायरेक्ट करें। नॉन-ज़ीरो एग्जिट पकड़ने और स्क्रिप्ट को रोकने के लिए || का उपयोग करें। jq किसी भी पार्स एरर पर कोड 1 से बाहर निकलता है, जो इसे CI गेट्स के लिए विश्वसनीय बनाता है।
validate_json() {
local file="$1"
if jq . "$file" > /dev/null 2>&1; then
echo "✓ वैलिड JSON: $file"
return 0
else
echo "✗ इनवैलिड JSON: $file" >&2
return 1
fi
}
validate_json infra/k8s/app-config.json || exit 1jq इंस्टॉल किए बिना bash में JSON को कैसे फॉर्मेट करूँ?
python3 के बिल्ट-इन json.tool मॉड्यूल का उपयोग करें — यह हर मानक Python इंस्टॉलेशन के साथ आता है और jq जैसे exit-code semantics के साथ ठीक से इंडेंटेड आउटपुट देता है।
# फ़ाइल से फॉर्मेट करें python3 -m json.tool config.json # stdin से फॉर्मेट करें (जैसे curl रिस्पॉन्स) curl -s https://api.internal/status | python3 -m json.tool --indent 2
bash में curl रिस्पॉन्स से JSON को कैसे फॉर्मेट करूँ?
curl को हमेशा -s (साइलेंट) पास करें ताकि प्रोग्रेस बार jq के इनपुट को खराब न करें। curl के stdout को सीधे jq में पाइप करें।
DEPLOY_ID="dep_8f3a2b9c" curl -s \ -H "Authorization: Bearer $DEPLOY_API_TOKEN" \ "https://api.deployments.internal/v1/deploys/$DEPLOY_ID" \ | jq --indent 2 .
jq का उपयोग करके JSON फ़ाइल के केवल एक भाग को कैसे फॉर्मेट करूँ?
नेस्टेड ऑब्जेक्ट या ऐरे को एक्सट्रैक्ट और फॉर्मेट करने के लिए आइडेंटिटी फ़िल्टर (.) की बजाय jq पाथ एक्सप्रेशन का उपयोग करें। परिणाम खुद फॉर्मेटेड JSON है।
# केवल डेटाबेस कॉन्फिग ब्लॉक फॉर्मेट करें
jq --indent 2 '.database' infra/app-config.json
# फॉर्मेट + events ऐरे को केवल error लेवल पर फ़िल्टर करें
jq '[.events[] | select(.level == "error") | {id, message, service}]' events.jsonइनवैलिड JSON के लिए jq कौन सा एग्जिट कोड रिटर्न करता है?
jq किसी भी पार्स एरर के लिए कोड 1 से बाहर निकलता है और तब भी जब -e / --exit-status फ्लैग सेट हो और आउटपुट false या null हो। एग्जिट कोड 0 का मतलब है वैलिड JSON पार्स हुआ और सही आउटपुट दिया। एग्जिट कोड 5 का मतलब है सिस्टम को usage एरर मिला।
# एग्जिट कोड सीधे टेस्ट करें
echo '{"ok":true}' | jq . > /dev/null 2>&1; echo "exit: $?" # exit: 0
echo '{bad json}' | jq . > /dev/null 2>&1; echo "exit: $?" # exit: 1
# -e फ्लैग: आउटपुट false/null होने पर 1 से बाहर निकलें
echo 'null' | jq -e . > /dev/null 2>&1; echo "exit: $?" # exit: 1संबंधित उपकरण
bash JSON formatting के ब्राउज़र-आधारित विकल्प और पूरक — उपयोगी जब आपको visual interface, shareable link की आवश्यकता हो, या टर्मिनल के बाहर काम कर रहे हों:
Nadia is a site reliability engineer who lives in the terminal. She writes Bash scripts that process logs, transform data, and orchestrate infrastructure across fleets of servers. She is a heavy user of jq, awk, and sed and writes about shell one-liners, text processing pipelines, data serialisation from the command line, and the practical Bash patterns that SREs reach for when speed matters more than elegance.
Erik is a DevOps engineer who has spent years writing and maintaining the shell scripts that hold CI/CD pipelines together. He writes about Bash best practices, portable POSIX shell, encoding and decoding in shell scripts, secret management from the command line, and the patterns that separate reliable automation scripts from brittle ones. He is a strong believer in making shell scripts readable and testable with tools like bats-core.