ToolDeck

จัดรูปแบบ JSON ใน Bash: คู่มือ jq และ python3

·SRE & Shell Scripting Specialist·ตรวจสอบโดยErik Lindqvist·เผยแพร่เมื่อ

ใช้ จัดรูปแบบและตกแต่ง JSON ฟรีโดยตรงในเบราว์เซอร์ของคุณ — ไม่ต้องติดตั้ง

ลอง จัดรูปแบบและตกแต่ง JSON ออนไลน์ →

เมื่อ deploy script เริ่มประมวลผล API response หรือตรวจสอบไฟล์ config ใน CI การรู้วิธี จัดรูปแบบ JSON ใน bash จะกลายเป็นสิ่งจำเป็นอย่างรวดเร็ว สองเครื่องมือที่ครอบคลุม 99% ของกรณีในโลกจริงคือ jq และ python3 -m json.tool — ทั้งคู่สามารถรัน pipeline จัดรูปแบบ json bash ได้อย่างน่าเชื่อถือ ตรวจสอบด้วยรหัสออก และผสานรวมเข้ากับ workflow CI/CD ได้อย่างสะอาด สำหรับการตรวจสอบครั้งเดียวโดยไม่ต้องใช้ terminal ตัวจัดรูปแบบ JSON ที่ใช้เบราว์เซอร์จัดการได้ทันที คู่มือนี้ครอบคลุมการติดตั้ง jq การจัดรูปแบบ pipe และไฟล์ ฟังก์ชันการตรวจสอบ การผสานรวม CI/CD ใน GitHub Actions pre-commit hooks รูปแบบ heredoc และเมื่อใดควรใช้ Python stdlib fallback

สาระสำคัญ
  • • jq . จัดรูปแบบ AND ตรวจสอบพร้อมกัน — ออกด้วยรหัส 1 เมื่อ JSON ไม่ถูกต้อง
  • • ใช้ jq -e ใน CI pipeline: ออกที่ไม่ใช่ศูนย์เมื่อเอาต์พุตว่าง/false/null
  • • jq . file.json > /dev/null && echo "valid" — ตรวจสอบโดยไม่เปลี่ยนเอาต์พุต
  • • python3 -m json.tool ทำงานบนระบบใดก็ได้โดยไม่ต้องติดตั้งเพิ่มเติม
  • • ห้ามทำ jq . f.json > f.json เด็ดขาด — shell ตัดไฟล์ต้นทางก่อนที่ jq จะอ่าน

การจัดรูปแบบ JSON ใน Bash คืออะไร?

การจัดรูปแบบ JSON ใน bash หมายถึงการแปลง JSON ที่กะทัดรัด minified เป็นเอาต์พุตที่เยื้องและอ่านได้ง่ายสำหรับมนุษย์ ข้อมูลพื้นฐานไม่เปลี่ยนแปลง — แตกต่างกันเฉพาะช่องว่างและการขึ้นบรรทัดใหม่เท่านั้น ในบริบทการเขียน script นี่สำคัญด้วยสองเหตุผล: ความสามารถในการอ่านขณะ debug และการตรวจสอบเมื่อตัวจัดรูปแบบตรวจสอบไวยากรณ์เป็นผลข้างเคียง เครื่องมืออย่าง jq parse JSON อย่างครบถ้วนก่อนจัดรูปแบบใหม่ ซึ่งหมายความว่าการรันจัดรูปแบบที่สำเร็จก็เป็นการตรวจสอบความถูกต้องโดยนัยด้วย พฤติกรรมสองแบบนั้น — จัดรูปแบบและตรวจสอบในขั้นตอนเดียว — คือสิ่งที่ทำให้ jq มีประโยชน์มากใน automated pipeline

Before · json
After · json
{"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 — จัดรูปแบบ JSON ใน Bash

jq คือมาตรฐาน de-facto สำหรับการประมวลผล JSON ใน shell script (jq 1.6+, bash 4+) เป็น command-line JSON processor ที่สร้างขึ้นเพื่อวัตถุประสงค์เฉพาะซึ่งสามารถจัดรูปแบบ กรอง แปลง และตรวจสอบ JSON ตัวกรองเอกลักษณ์ . ส่งอินพุตผ่านโดยไม่เปลี่ยนแปลง แต่จัดรูปแบบ เมื่อ jq ไม่สามารถ parse อินพุตได้จะออกด้วยรหัส 1 — นี่คือสิ่งที่ทำให้มันเหมาะสำหรับ scripting: การจัดรูปแบบและการตรวจสอบเป็นการดำเนินการเดียว

ติดตั้ง jq

Bash
# macOS
brew install jq

# Debian / Ubuntu
apt-get install -y jq

# Fedora / RHEL / CentOS
dnf install jq

# Alpine (Docker image)
apk add --no-cache jq

# ตรวจสอบ
jq --version  # jq-1.7.1

จัดรูปแบบจาก stdin และจากไฟล์

Bash
# Pipe JSON แบบ inline ผ่าน jq
echo '{"host":"db-prod-01.internal","port":5432}' | jq .

# จัดรูปแบบไฟล์โดยตรง (พิมพ์ไปยัง stdout)
jq . config/feature-flags.json

# จัดรูปแบบด้วยการเยื้อง 4 ช่องว่าง
jq --indent 4 . config/feature-flags.json

# จัดรูปแบบโดยใช้ tab แทนช่องว่าง
jq --tab . config/feature-flags.json

เขียนเอาต์พุตที่จัดรูปแบบไปยังไฟล์

Bash
# บันทึกเอาต์พุตที่จัดรูปแบบ (อย่า redirect กลับไปยังไฟล์เดิม)
jq . compact.json > formatted.json

# Compact (minify) — ตรงข้ามกับการจัดรูปแบบ
jq -c . formatted.json
หมายเหตุ:jq ออกด้วยรหัส 1 เมื่อ JSON ไม่ถูกต้อง รหัส 0 เมื่อสำเร็จ และรหัส 5 เมื่อมีข้อผิดพลาดการใช้งาน ใช้สิ่งนี้ใน คำสั่ง if และตัวป้องกัน || exit 1 ทั่วทั้ง script ของคุณ

เรียงลำดับ key และลบสี

Bash
# เรียงลำดับ key ทั้งหมดตามตัวอักษร (มีประโยชน์สำหรับ diff ที่กำหนดได้)
jq --sort-keys . config/app-config.json

# ปิดใช้งานเอาต์พุตสีเมื่อเขียนไปยังไฟล์ log
jq --monochrome-output . response.json >> deploy.log

เอกสารอ้างอิงตัวเลือก jq

แฟล็ก jq ที่ใช้บ่อยที่สุดสำหรับ workflow การจัดรูปแบบและการตรวจสอบ:

ตัวเลือก
ประเภท
ค่าเริ่มต้น
คำอธิบาย
.
ตัวกรอง
—
ตัวกรองเอกลักษณ์ — จัดรูปแบบและพิมพ์อินพุตทั้งหมดโดยไม่เปลี่ยนแปลง
--indent N
int
2
กำหนดการเยื้องเป็น N ช่องว่าง (0–7) ใช้ 2 หรือ 4 สำหรับการจัดรูปแบบมาตรฐาน
--tab
แฟล็ก
ปิด
เยื้องด้วยอักขระแท็บแทนช่องว่าง
-c / --compact-output
แฟล็ก
ปิด
ยุบเอาต์พุตเป็นบรรทัดเดียว (minify) ยกเลิก pretty-print
-r / --raw-output
แฟล็ก
ปิด
พิมพ์สตริงโดยไม่มีเครื่องหมายคำพูด JSON มีประโยชน์สำหรับดึงค่าข้อความธรรมดา
-e / --exit-status
แฟล็ก
ปิด
ออกด้วยรหัส 1 หากเอาต์พุตเป็น false หรือ null เหมาะสำหรับการยืนยัน CI
-M / --monochrome-output
แฟล็ก
ปิด
ปิดใช้งานเอาต์พุตสี มีประโยชน์เมื่อส่งต่อไปยังไฟล์หรือ sink ที่ไม่ใช่ terminal
-S / --sort-keys
แฟล็ก
ปิด
เรียงลำดับคีย์ object ทั้งหมดตามตัวอักษรในทุกระดับการซ้อนกัน
-n / --null-input
แฟล็ก
ปิด
ไม่อ่านอินพุต ใช้กับ --arg / --argjson เพื่อสร้าง JSON ตั้งแต่ต้น
--arg name val
สตริง
—
ผูกสตริง shell เป็นตัวแปร jq ที่มีชื่อ ($name) ที่เข้าถึงได้ในตัวกรอง

ตรวจสอบ JSON ใน Bash Script

การตรวจสอบและการจัดรูปแบบเป็นการดำเนินการเดียวกันใน jq — มัน parse ก่อนที่จะพิมพ์ เปลี่ยนเส้นทาง stdout ไปยัง /dev/null เมื่อคุณ ต้องการเฉพาะรหัสออกโดยไม่มีเอาต์พุตที่จัดรูปแบบ รูปแบบด้านล่างนี้สามารถนำมาใช้ซ้ำได้ใน deploy script, pre-commit hooks และ CI pipeline ในการตอบสนองต่อเหตุการณ์ สิ่งแรกที่ผมทำกับ API payload ที่ไม่คุ้นเคย คือ pipe ผ่าน jq — มันเปลี่ยนกำแพง JSON ที่ minified ให้เป็นบางอย่างที่ผมสามารถอ่านและ debug ได้จริงๆ

ฟังก์ชันตรวจสอบที่นำมาใช้ซ้ำได้

Bash
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 ไม่ถูกต้อง

Bash
CONFIG="infra/k8s/app-config.json"
validate_json "$CONFIG" || { echo "ยกเลิก deploy: config ไม่ถูกต้อง" >&2; exit 1; }

ตรวจสอบไฟล์ JSON ทั้งหมดในไดเรกทอรี

Bash
find ./config -name "*.json" | while read -r f; do
  jq . "$f" > /dev/null 2>&1 || echo "ไม่ถูกต้อง: $f"
done
หมายเหตุ:แฟล็ก -e / --exit-status ไปไกลกว่านั้น: มันยังออกด้วยรหัส 1 เมื่อ เอาต์พุต เป็น false หรือ nullใช้เพื่อยืนยันว่า field เฉพาะเป็น truthy: jq -e '.feature_flags.new_checkout' config.json

จัดรูปแบบ JSON จากไฟล์และ API Response

แหล่ง JSON ที่พบบ่อยสองแห่งใน shell script คือไฟล์บนดิสก์และ HTTP API response ผ่าน curl แต่ละแบบมีรูปแบบการจัดการที่แตกต่างกันเล็กน้อย สำหรับไฟล์ ความกังวลหลักคือการแก้ไขในตำแหน่งเดิมอย่างปลอดภัย สำหรับ API response รายละเอียดสำคัญคือการปิดกั้นแถบความคืบหน้าของ curl เพื่อไม่ให้ทำให้อินพุตของ jq เสียหาย

การจัดรูปแบบในตำแหน่งเดิมอย่างปลอดภัยสำหรับไฟล์

Bash
# จัดรูปแบบและเขียนทับอย่างปลอดภัยโดยใช้ไฟล์ชั่วคราว
tmp=$(mktemp)
jq --indent 2 . config/feature-flags.json > "$tmp" && mv "$tmp" config/feature-flags.json
echo "จัดรูปแบบ config/feature-flags.json แล้ว"

จัดรูปแบบ curl API response

Bash
# จัดรูปแบบสถานะ deployment จาก API
DEPLOY_ID="dep_8f3a2b9c"
curl -s \
  -H "Authorization: Bearer $DEPLOY_API_TOKEN" \
  "https://api.deployments.internal/v1/deploys/$DEPLOY_ID" \
  | jq --indent 2 .

จัดรูปแบบและกรองพร้อมกัน

Bash
# รับที่จัดรูปแบบ + กรองเฉพาะ error จาก monitoring endpoint
curl -s "https://monitoring.internal/api/events?level=error&limit=10" \
  | jq '[.events[] | {id, message, timestamp, service}]' \
  || { echo "ไม่สามารถดึงหรือ parse events ได้" >&2; exit 1; }

รูปแบบ || { ... } มีความสำคัญอย่างยิ่งที่นี่ หากไม่มี curl ที่ล้มเหลวหรือ API response ที่ผิดรูปแบบจะผ่านไปอย่างเงียบๆ และขั้นตอนถัดไปใน script ของคุณจะดำเนินการกับข้อมูลที่ว่างเปล่าหรือไม่ครบถ้วน ถ้าคุณต้องการตรวจสอบ response ที่ซ้อนกันซับซ้อนโดยไม่เขียน filter expression ก่อน ตัวจัดรูปแบบ JSON ที่ใช้เบราว์เซอร์ช่วยให้คุณ paste response ดิบและนำทาง tree แบบ interactive ได้

จัดรูปแบบ JSON ใน CI/CD Pipeline

CI คือที่ที่ JSON validation gate มีความสำคัญมากที่สุด — config ที่ผิดรูปแบบที่ถึง production นั้นเจ็บปวด มากกว่าในการ rollback กว่า pipeline failure มาก คู่แข่งส่วนใหญ่ document jq สำหรับการใช้งาน terminal ครั้งเดียว รูปแบบด้านล่างคือสิ่งที่ผมใช้ใน production SRE workflow เพื่อตรวจจับข้อผิดพลาด config ก่อนที่ จะถึง deployment slot ใดๆ

GitHub Actions — ตรวจสอบ JSON config ทั้งหมด

YAML
- name: ตรวจสอบ JSON config
  run: |
    echo "กำลังตรวจสอบไฟล์ JSON configuration..."
    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 — ตรวจสอบไฟล์ JSON ที่ stage แล้ว

Bash
#!/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 ผ่านแล้ว"
หมายเหตุ:บันทึก pre-commit hook ไปยัง scripts/validate-json.sh, ทำให้ executable ด้วย chmod +x scripts/validate-json.sh, จากนั้นสร้าง symlink: ln -s ../../scripts/validate-json.sh .git/hooks/pre-commit

จัดรูปแบบตัวแปร JSON และ Heredoc ใน Bash

Shell script มักสร้าง JSON payload แบบ dynamic — จากตัวแปรสภาพแวดล้อม git metadata หรือค่าที่คำนวณ รูปแบบที่ปลอดภัยที่สุดคือ jq -n --arg / --argjson แทน string interpolation ซึ่งจะพังทันทีที่ค่ามีเครื่องหมายคำพูดหรือขึ้นบรรทัดใหม่ ใส่เครื่องหมายคำพูดคู่ให้กับตัวแปรเสมอเมื่อ pipe ไปยัง jq เพื่อป้องกันการแยกคำบนช่องว่างใน JSON

จัดรูปแบบตัวแปร API response ที่เก็บไว้

Bash
# ใส่เครื่องหมายคำพูดให้ "$API_RESPONSE" เสมอ — ช่องว่างใน JSON จะทำให้การขยายที่ไม่มีเครื่องหมายคำพูดพัง
echo "$API_RESPONSE" | jq --indent 2 .

สร้างและจัดรูปแบบ payload ด้วย jq -n

Bash
payload=$(jq -n \
  --arg env "production" \
  --arg version "$(git describe --tags)" \
  --argjson replicas 3 \
  '{environment: $env, version: $version, replicas: $replicas}')

# ตรวจสอบ payload ที่สร้างขึ้น
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 ผูกค่า สตริงเสมอ --argjson parse ค่าเป็น JSON ก่อน ดังนั้นคุณสามารถส่งตัวเลข boolean array และ object โดยไม่ต้องใส่เครื่องหมายคำพูด ภายใน filter expression

จัดรูปแบบ JSON ใน Bash โดยไม่ติดตั้ง jq

เมื่อ jq ไม่พร้อมใช้งาน — Docker image ขนาดเล็ก CI runner ที่ถูกล็อค หรือระบบที่ไม่สามารถ ติดตั้งแพ็กเกจได้ — โมดูล json.tool ในตัวของ Python ให้ความสามารถหลักเดียวกัน เป็นส่วนหนึ่งของ Python standard library หาก Python 3 ติดตั้งแล้ว จะทำงานได้โดยไม่มี dependency เพิ่มเติม

Bash
# จัดรูปแบบจากไฟล์
python3 -m json.tool config.json

# ควบคุมความกว้างการเยื้อง
python3 -m json.tool --indent 2 config.json

# เรียงลำดับ key ตามตัวอักษร
python3 -m json.tool --sort-keys config.json

# จัดรูปแบบจาก stdin (เช่น pipe จาก curl)
curl -s https://api.deployments.internal/v1/status | python3 -m json.tool
คำเตือน:python3 -m json.tool เข้มงวดกว่า jq: ปฏิเสธเครื่องหมายจุลภาคต่อท้าย comment และส่วนขยาย JSON5 ความเข้มงวดนี้เป็นที่ต้องการ สำหรับการตรวจสอบ config ใน production แต่อาจเป็นจุดเสียดทานเมื่อทำงานกับ JSON แบบหลวมๆ จากเครื่องมือ บุคคลที่สาม นอกจากนี้ยังไม่ผลิตเอาต์พุตสี ทำให้การตรวจสอบ terminal มีประสิทธิภาพน้อยกว่า jq สำหรับการใช้งานแบบ interactive
Bash
# ตรวจสอบด้วยรหัสออก (semantics เหมือนกับ jq)
python3 -m json.tool config.json > /dev/null && echo "ถูกต้อง" || echo "ไม่ถูกต้อง"

# ตรวจสอบสตริง inline
echo '{"service":"payments-api","healthy":true}' | python3 -m json.tool > /dev/null
echo "รหัสออก: $?"  # 0 = ถูกต้อง

เอาต์พุต Terminal ด้วยการเน้นสีไวยากรณ์

jq ระบายสีเอาต์พุต ตามค่าเริ่มต้น — key สีฟ้า สตริงสีเขียว ตัวเลขสีขาว เมื่อคุณต้องการการเน้นสีไวยากรณ์ JSON เต็มรูปแบบ ใน pager ที่เลื่อนได้ หรือเมื่อ debug response ที่ซ้อนกันขนาดใหญ่ในเซสชัน terminal bat ให้ประสบการณ์ ที่สะดวกที่สุด ทั้งคู่มีประโยชน์สำหรับการ debug และการตรวจสอบแบบ interactive ไม่ควรใช้อย่างใดอย่างหนึ่ง เมื่อเขียนเอาต์พุตไปยังไฟล์หรือ API response

ติดตั้ง bat

Bash
# 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 ด้วยการเน้นสีไวยากรณ์

Bash
# JSON ที่เน้นสีไวยากรณ์ใน pager (กด q เพื่อออก)
bat config/app-config.json

# ปิดใช้งาน paging — พิมพ์ตรงไปยัง terminal
bat --paging=never config/app-config.json

# Pipe เอาต์พุต jq ผ่าน bat เพื่อการตรวจสอบสี
jq '.database' infra/app-config.json | bat --language=json --paging=never

เอาต์พุต jq สีสันใน pager ที่เลื่อนได้

Bash
# -C บังคับสีแม้ว่า stdout จะไม่ใช่ tty (เช่น เมื่อ pipe ไปยัง less)
jq -C . logs/deploy-response.json | less -R
คำเตือน:ใช้เอาต์พุตสี (bat / jq -C) สำหรับ การตรวจสอบ terminal และการ debug เท่านั้น ลบ ANSI color code ก่อนเขียนไปยังไฟล์ log หรือ pipe ไปยังเครื่องมืออื่น — ใช้ jq -M . (--monochrome-output) หรือ bat --plain

การทำงานกับไฟล์ JSON ขนาดใหญ่ใน Bash

เมื่อไฟล์ JSON เกิน 50–100 MB การโหลดลงในหน่วยความจำด้วยโหมดเริ่มต้นของ jq อาจช้าหรือ ทำให้เกิด OOM บน host ที่จำกัดหน่วยความจำ (Docker container ที่มีขีดจำกัด 512 MB เป็นต้น) jq --stream ส่ง คู่ path/value แบบ incremental ขณะอ่าน โดยไม่ buffer เอกสารทั้งหมด สำหรับ NDJSON (หนึ่ง JSON object ต่อบรรทัด) jq มีวิธีการ native ที่มีประสิทธิภาพมากกว่า

Stream ไฟล์ JSON ขนาดใหญ่ด้วย jq --stream

Bash
# --stream ส่งคู่ [path, scalar] ขณะที่ jq อ่านอินพุต
# ดึง field "status" ทั้งหมดจาก log archive ขนาดใหญ่โดยไม่โหลดครบ
jq -c --stream   'if length == 2 and (.[0][-1] == "status") then .[1] else empty end'   logs/archive-2026-03.json

NDJSON / JSON Lines — ประมวลผลหนึ่ง object ต่อบรรทัด

Bash
# NDJSON: หนึ่ง JSON object ต่อบรรทัด — พบบ่อยใน Kafka export, Fluentd และ Logstash
# -R อ่านบรรทัดดิบ fromjson? ข้ามบรรทัดที่ไม่ใช่ JSON ที่ถูกต้อง
jq -c -R 'fromjson? | {id: .request_id, status: .http_status, latency: .duration_ms}'   logs/access-2026-03-13.ndjson > logs/summary.ndjson
Bash
# ทางเลือก shell loop — มีประโยชน์เมื่อต้องการ error handling ต่อบรรทัด
while IFS= read -r line; do
  echo "$line" | jq -c '{id: .request_id, status: .http_status}' 2>/dev/null ||     echo "ข้าม: บรรทัดที่ผิดรูปแบบ" >&2
done < logs/access-2026-03-13.ndjson
หมายเหตุ:เปลี่ยนจาก jq . file.json มาตรฐาน เป็น --stream เมื่อไฟล์ใหญ่กว่า 50–100 MB หรือเมื่อ process ทำงานภายใน container ที่มีขีดจำกัดหน่วยความจำ สำหรับ NDJSON pipeline ให้เลือก jq -R 'fromjson?' แทน shell while read loop — เร็วกว่าอย่างมีนัยสำคัญเพราะหลีกเลี่ยงการสร้าง subshell ต่อบรรทัด

ข้อผิดพลาดที่พบบ่อย

❌ เขียนทับไฟล์ต้นทางด้วย shell redirection

ปัญหา: Shell เปิดและตัดไฟล์เอาต์พุตก่อนที่ jq จะอ่านอินพุต ถ้า source และ destination เป็น path เดียวกัน jq จะอ่านไฟล์ว่าง

วิธีแก้ไข: เขียนไปยังไฟล์ชั่วคราว mktemp ก่อน จากนั้นแทนที่ต้นฉบับแบบ atomic ด้วย mv

Before · Bash
After · Bash
jq --indent 2 . settings.json > settings.json
tmp=$(mktemp) && jq --indent 2 . settings.json > "$tmp" && mv "$tmp" settings.json
❌ ไม่จัดการ jq failure ใน script

ปัญหา: หากไม่มี error handler script จะดำเนินการต่อเงียบๆ พร้อมไฟล์ที่จัดรูปแบบที่ว่างเปล่าหรือหายไปเมื่อ JSON ไม่ถูกต้อง — ขั้นตอนถัดไปล้มเหลวพร้อมข้อผิดพลาดที่สับสน

วิธีแก้ไข: เพิ่ม || { echo '...' >&2; exit 1; } หลังการเรียก jq ทุกครั้งที่ผลิตเอาต์พุตที่ใช้โดยขั้นตอนถัดไป

Before · Bash
After · Bash
jq . response.json > formatted.json
jq . response.json > formatted.json || { echo "JSON ไม่ถูกต้องใน response.json" >&2; exit 1; }
❌ ลืม -s กับ curl

ปัญหา: curl พิมพ์แถบความคืบหน้าไปยัง stderr ตามค่าเริ่มต้น เมื่อ stderr ถูกรวมกับ stdout (เช่น ใน subshell หรือการบันทึก log) ข้อความแถบความคืบหน้าจะปรากฏในอินพุตของ jq และทำให้เกิดข้อผิดพลาดการ parse

วิธีแก้ไข: ส่ง -s (silent) ให้ curl เสมอเมื่อ pipe ไปยัง jq ใช้ -v หรือ --fail-with-body แยกต่างหากถ้าต้องการเอาต์พุตการวินิจฉัย

Before · Bash
After · Bash
curl https://api.payments.internal/config | jq .
curl -s https://api.payments.internal/config | jq .
❌ ใช้ jq -r . โดยคาดหวัง JSON ที่จัดรูปแบบ

ปัญหา: แฟล็ก -r / --raw-output ลบเครื่องหมายคำพูดสตริง JSON ออกจากค่าสตริงระดับบนสุด — ไม่ได้จัดรูปแบบ object หรือ array การส่ง -r . ให้กับอินพุต object ผลิต object ที่กะทัดรัดเหมือนกัน ไม่ใช่เอาต์พุตที่เยื้อง

วิธีแก้ไข: ใช้ jq . (ไม่มีแฟล็ก -r) สำหรับการจัดรูปแบบ สงวน -r สำหรับการดึงค่าสตริงธรรมดาเช่น jq -r '.version' config.json

Before · Bash
After · Bash
jq -r . config.json
jq . config.json

jq vs python3 vs json_pp — เปรียบเทียบเร็ว

การเลือกระหว่างเครื่องมือขึ้นอยู่กับสิ่งที่มีในสภาพแวดล้อมของคุณและสิ่งที่คุณต้องการนอกเหนือจาก การจัดรูปแบบพื้นฐาน:

เครื่องมือ
ตรวจสอบ
ระบายสี
รองรับ CI
รหัสออก
ควบคุมการเยื้อง
ติดตั้ง
jq
✅
✅
✅
✅ (รหัส 1)
✅ --indent N
brew / apt / dnf
python3 -m json.tool
✅ (เข้มงวด)
❌
✅
✅ (รหัส 1)
✅ --indent N
ในตัว (Python)
json_pp (Perl)
✅
❌
⚠️ บางส่วน
⚠️ ผันแปร
❌
ในตัว (Perl)
fx (Node.js)
✅
✅
⚠️ บางส่วน
✅
⚠️ จำกัด
npm install -g fx
node -e JSON.parse
✅
❌
✅
✅
✅ JSON.stringify
ในตัว (Node.js)

สำหรับงาน bash scripting และ CI/CD ส่วนใหญ่ jq เป็นค่าเริ่มต้นที่ถูกต้อง — มันตรวจสอบ จัดรูปแบบ กรอง และให้รหัสออกที่เชื่อถือได้ใน binary เดียวโดยไม่มี runtime dependency ใช้ python3 -m json.tool เป็น fallback เมื่อคุณไม่สามารถติดตั้งแพ็กเกจเพิ่มเติมและ Python มีอยู่แล้ว

คำถามที่พบบ่อย

จะจัดรูปแบบไฟล์ JSON ในตำแหน่งเดิมโดยใช้ bash ได้อย่างไร?

อย่าเปลี่ยนเส้นทางเอาต์พุตของ jq กลับไปยังไฟล์เดิมเด็ดขาด — shell จะตัดไฟล์ก่อนที่ jq จะอ่าน แต่ให้เขียนไปยังไฟล์ชั่วคราวก่อน จากนั้นแทนที่ต้นฉบับแบบ atomic ด้วย mv

Bash
tmp=$(mktemp)
jq --indent 2 . config/app-config.json > "$tmp" && mv "$tmp" config/app-config.json
echo "จัดรูปแบบในตำแหน่งเดิมสำเร็จ"

จะตรวจสอบความถูกต้องของ JSON ใน bash script และออกเมื่อเกิดข้อผิดพลาดได้อย่างไร?

ส่งหรือ pipe ไฟล์ไปยัง jq และเปลี่ยนเส้นทาง stdout ไปยัง /dev/null ใช้ || เพื่อจับการออกที่ไม่ใช่ศูนย์และยกเลิก script jq ออกด้วยรหัส 1 สำหรับข้อผิดพลาดการ parse ใดๆ ทำให้เชื่อถือได้สำหรับ CI gate

Bash
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 1

จะจัดรูปแบบ JSON ใน bash โดยไม่ติดตั้ง jq ได้อย่างไร?

ใช้โมดูล json.tool ในตัวของ python3 — มาพร้อมกับการติดตั้ง Python มาตรฐานทุกรุ่นและสร้างเอาต์พุตที่เยื้องอย่างถูกต้องด้วย semantics รหัสออกเหมือนกับ jq

Bash
# จัดรูปแบบจากไฟล์
python3 -m json.tool config.json

# จัดรูปแบบจาก stdin (เช่น response ของ curl)
curl -s https://api.internal/status | python3 -m json.tool --indent 2

จะจัดรูปแบบ JSON จาก response ของ curl ใน bash ได้อย่างไร?

ส่ง -s (silent) ให้ curl เสมอเพื่อไม่ให้แถบความคืบหน้าทำให้อินพุตของ jq เสียหาย Pipe stdout ของ curl ตรงไปยัง jq

Bash
DEPLOY_ID="dep_8f3a2b9c"
curl -s \
  -H "Authorization: Bearer $DEPLOY_API_TOKEN" \
  "https://api.deployments.internal/v1/deploys/$DEPLOY_ID" \
  | jq --indent 2 .

จะจัดรูปแบบเฉพาะบางส่วนของไฟล์ JSON โดยใช้ jq ได้อย่างไร?

ใช้ path expression ของ jq แทนตัวกรองเอกลักษณ์ (.) เพื่อดึงและจัดรูปแบบ object หรือ array ที่ซ้อนกัน ผลลัพธ์นั้นเองก็คือ JSON ที่จัดรูปแบบแล้ว

Bash
# จัดรูปแบบเฉพาะบล็อกการกำหนดค่าฐานข้อมูล
jq --indent 2 '.database' infra/app-config.json

# จัดรูปแบบ + กรอง events array เฉพาะระดับ error
jq '[.events[] | select(.level == "error") | {id, message, service}]' events.json

jq ส่งคืนรหัสออกอะไรสำหรับ JSON ที่ไม่ถูกต้อง?

jq ออกด้วยรหัส 1 สำหรับข้อผิดพลาดการ parse ใดๆ และยังออกเมื่อตั้งค่าแฟล็ก -e / --exit-status และเอาต์พุตเป็น false หรือ null รหัสออก 0 หมายความว่า JSON ที่ถูกต้องถูก parse และสร้างเอาต์พุตที่เป็น truthy รหัสออก 5 หมายความว่าระบบพบข้อผิดพลาดการใช้งาน

Bash
# ทดสอบรหัสออกโดยตรง
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: ออก 1 ถ้าเอาต์พุตเป็น false/null
echo 'null' | jq -e . > /dev/null 2>&1; echo "exit: $?"      # exit: 1

เครื่องมือที่เกี่ยวข้อง

ทางเลือกและส่วนเสริมที่ใช้เบราว์เซอร์สำหรับการจัดรูปแบบ JSON bash — มีประโยชน์เมื่อคุณต้องการ interface แบบ visual ลิงก์ที่แชร์ได้ หรือทำงานนอก terminal:

ตัวจัดรูปแบบ JSON
จัดรูปแบบ ตรวจสอบ และตรวจสอบ JSON ในเบราว์เซอร์ด้วยการเน้นสีไวยากรณ์และการตรวจจับข้อผิดพลาด — ไม่ต้องตั้งค่าบรรทัดคำสั่ง
ตัวตรวจสอบ JSON
ตรวจสอบไวยากรณ์ JSON ก่อนรวมไว้ใน script หรือไฟล์ config — ตรวจจับข้อผิดพลาดที่จะทำให้ jq หรือ python3 -m json.tool ออกด้วยรหัส 1
ตัวย่อ JSON
บีบอัด JSON ที่จัดรูปแบบแล้วกลับเป็นบรรทัดเดียวสำหรับ API payload และตัวแปรสภาพแวดล้อม — เทียบเท่าเบราว์เซอร์ของ jq -c
JSON Diff
เปรียบเทียบไฟล์ JSON ที่จัดรูปแบบสองไฟล์เพื่อค้นหาการเปลี่ยนแปลงโครงสร้างระหว่างเวอร์ชัน config — มีประโยชน์หลังจากรัน jq --sort-keys ทั้งสองด้าน
มีให้ในภาษาอื่นด้วย:PythonGoJavaScript
NO
Nadia OkonkwoSRE & Shell Scripting Specialist

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.

EL
Erik Lindqvistผู้ตรวจสอบทางเทคนิค

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.