PricingLoginStart free
Kem Intensif DevOps · Pelajaran

Menapis dan Memilih JSON dengan Saluran Paip jq

Navigasi objek dan tatasusunan bersarang menggunakan pemilih jq, saluran paip dan penapis select

Pelajaran 1 daripada 413 langkah

Menapis dan Memilih JSON dengan Saluran Paip jq ialah pelajaran Kem Intensif DevOps percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif DevOps, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif DevOps merangkumi sejumlah 4 pelajaran.

Apakah jq dan Mengapa Menggunakannya?

jq ialah alat baris perintah yang ringan dan berkuasa untuk menghurai, menapis dan mengubah data JSON. Ia ialah sed bagi JSON — anda menyalurkan JSON kepadanya dan menerima output berstruktur.

  • Telah dipasang pada kebanyakan distro Linux atau tersedia melalui apt install jq / brew install jq
  • Berfungsi dengan lancar dalam saluran paip shell bersama curl, cat dan alat lain
  • Menyokong penapisan, pemetaan, pengurangan dan penukaran format

Panggilan asas ialah: jq '<filter>' file.json atau melalui saluran paip sebagai cat file.json | jq '<filter>'. Penapis . (titik) ialah identiti — ia mencetak keseluruhan dokumen dengan format yang lebih mudah dibaca.

# Pretty-print a JSON file
jq '.' data.json

# Or pipe from curl
curl -s https://api.github.com/users/torvalds | jq '.'

Memilih Medan Objek dengan Tatatanda Titik

Untuk mengakses medan dalam objek JSON, gunakan tatatanda titik: .fieldName. Anda boleh merangkaikan pemilih untuk menavigasi objek bersarang.

  • .name — medan peringkat teratas
  • .address.city — medan bersarang
  • ."field-with-dash" — medan dengan aksara khas memerlukan tanda petikan

Jika medan itu tidak wujud, jq mengembalikan null dan bukannya menghasilkan ralat. Ini menjadikannya selamat digunakan dalam skrip tanpa semakan null tambahan untuk medan pilihan.

# Given: {"name":"Alice","address":{"city":"Berlin","zip":"10115"}}
echo '{"name":"Alice","address":{"city":"Berlin","zip":"10115"}}' | jq '.name'
# Output: "Alice"

echo '{"name":"Alice","address":{"city":"Berlin","zip":"10115"}}' | jq '.address.city'
# Output: "Berlin"

Mengakses Elemen Tatasusunan dan Melakukan Lelaran

Tatasusunan JSON diakses dengan tatatanda kurungan. jq menggunakan pengindeksan bermula daripada sifar.

  • .items[0] — elemen pertama
  • .items[-1] — elemen terakhir
  • .items[1:3] — hirisan (indeks 1 hingga sebelum 3)
  • .items[] — menguraikan tatasusunan: menghasilkan setiap elemen sebagai nilai berasingan (inilah penglelai)

Penglelai [] ialah asas saluran paip jq — ia membolehkan anda menggunakan penapis seterusnya pada setiap elemen secara berasingan.

# Given an array of users
echo '[{"name":"Alice"},{"name":"Bob"},{"name":"Carol"}]' | jq '.[0]'
# Output: {"name":"Alice"}

# Iterate all elements and extract .name from each
echo '[{"name":"Alice"},{"name":"Bob"},{"name":"Carol"}]' | jq '.[].name'
# Output:
# "Alice"
# "Bob"
# "Carol"

Membina Saluran Paip jq dengan Pengendali Paip

Sama seperti paip shell |, jq mempunyai pengendali paip dalamannya sendiri. Pengendali ini menghantar output daripada satu penapis sebagai input kepada penapis seterusnya.

  • jq '.users[] | .name' — mengulangi pengguna, kemudian mengekstrak nama daripada setiap pengguna
  • jq '.data | .items[] | .id' — menavigasi ke data, menguraikan item dan mengekstrak id

Paip dalam ungkapan jq membolehkan transformasi kompleks dibina langkah demi langkah. Setiap peringkat menerima apa sahaja yang dihasilkan oleh peringkat sebelumnya — termasuk berbilang nilai daripada penglelai.

Petunjuk utama: apabila penglelai menghasilkan N nilai, setiap penapis hiliran berjalan N kali, sekali bagi setiap nilai.

# Nested pipeline: navigate -> iterate -> extract
echo '{"users":[{"name":"Alice","age":30},{"name":"Bob","age":25}]}' \
  | jq '.users[] | .name'
# Output:
# "Alice"
# "Bob"

# Chain more stages
echo '{"users":[{"name":"Alice","age":30},{"name":"Bob","age":25}]}' \
  | jq '.users[] | .age'
# Output:
# 30
# 25

Menapis dengan select()

Penapis select(condition) hanya meneruskan nilai jika syaratnya benar; jika tidak, ia tidak menghasilkan output. Ia ialah padanan jq bagi grep atau WHERE dalam SQL.

  • select(.age > 18) — kekalkan objek yang umur melebihi 18
  • select(.status == "active") — semakan kesamaan
  • select(.name | startswith("A")) — ujian rentetan bersarang

Gabungkan select dengan penglelai untuk menapis tatasusunan: .items[] | select(.active) hanya menghasilkan elemen yang .active-nya bernilai benar.

# Filter array elements by a condition
echo '[{"name":"Alice","age":30},{"name":"Bob","age":17},{"name":"Carol","age":25}]' \
  | jq '.[] | select(.age >= 18) | .name'
# Output:
# "Alice"
# "Carol"

# Filter by string equality
echo '[{"name":"Alice","role":"admin"},{"name":"Bob","role":"user"}]' \
  | jq '.[] | select(.role == "admin") | .name'
# Output: "Alice"

Membina Semula Objek dan Tatasusunan dengan {} dan []

jq membolehkan anda membentuk semula data dengan membina objek baharu menggunakan {} dan tatasusunan baharu menggunakan [].

  • {name: .name, city: .address.city} — memilih dan menamakan semula medan ke dalam objek baharu
  • [.items[] | .id] — mengumpulkan nilai yang dileraikan kembali ke dalam tatasusunan
  • Bentuk ringkas: {name, age} bersamaan dengan {name: .name, age: .age}

Membungkus saluran paip dalam [...] dipanggil pembinaan tatasusunan dan penting apabila anda mahukan tatasusunan JSON sebagai output, bukannya strim nilai.

# Reshape: keep only selected fields
echo '[{"id":1,"name":"Alice","password":"secret"},{"id":2,"name":"Bob","password":"secret"}]' \
  | jq '[.[] | {id, name}]'
# Output:
# [
#   {"id": 1, "name": "Alice"},
#   {"id": 2, "name": "Bob"}
# ]

# Collect filtered names into an array
echo '[{"name":"Alice","active":true},{"name":"Bob","active":false}]' \
  | jq '[.[] | select(.active) | .name]'
# Output: ["Alice"]

Mengendalikan Tatasusunan Bersarang dan Penurunan Rekursif

JSON dunia sebenar selalunya bersarang secara mendalam. jq menyediakan dua alat untuk navigasi mendalam:

  • .a.b.c — laluan eksplisit apabila struktur diketahui
  • .. | .fieldName? — penurunan rekursif: merentasi setiap nod dalam pepohon dan menghasilkan nilai apabila kunci tersebut wujud

Pengendali ? (cuba) menyekat ralat apabila medan tidak wujud pada nod tertentu, yang amat penting apabila menggunakan penurunan rekursif pada pepohon heterogen.

Gunakan penurunan rekursif secara berhemat pada dokumen besar — ia melawati setiap nod dan boleh menjadi perlahan. Utamakan laluan eksplisit apabila struktur boleh dijangka.

# Explicit deep path
echo '{"a":{"b":{"c":42}}}' | jq '.a.b.c'
# Output: 42

# Recursive descent: find all "id" values anywhere in the tree
echo '{"users":[{"id":1,"profile":{"id":99}},{"id":2}]}' \
  | jq '.. | .id?'
# Output:
# 1
# 99
# 2

Contoh Praktikal: Menghurai Respons API curl

Salah satu kegunaan jq yang paling lazim ialah menghurai respons API REST yang diperoleh dengan curl. Menggabungkan curl -s (senyap) dengan saluran paip jq memberikan pengekstrakan data yang bersih dan boleh diskripkan.

  • Ekstrak satu nilai: curl -s URL | jq '.field'
  • Bina jadual ringkasan: lakukan lelaran pada tatasusunan dan bina semula objek hanya dengan medan yang diperlukan
  • Gunakan -r (output mentah) untuk membuang tanda petikan yang mengelilingi nilai rentetan — penting apabila menetapkan nilai kepada pemboleh ubah shell

Petua: sentiasa tambahkan -r apabila output jq akan digunakan sebagai pemboleh ubah shell atau disalurkan kepada arahan lain.

#!/usr/bin/env bash
# Fetch GitHub repo info and extract specific fields
REPO="torvalds/linux"
RESPONSE=$(curl -s "https://api.github.com/repos/${REPO}")

# Extract fields
STARS=$(echo "$RESPONSE" | jq -r '.stargazers_count')
LANG=$(echo  "$RESPONSE" | jq -r '.language')
DESC=$(echo  "$RESPONSE" | jq -r '.description')

echo "Stars : $STARS"
echo "Lang  : $LANG"
echo "Desc  : $DESC"

Menggunakan map() dan map_values()

jq menyediakan dua fungsi tertib lebih tinggi yang mudah untuk mengubah koleksi:

  • map(f) — menggunakan penapis f pada setiap elemen tatasusunan dan mengembalikan tatasusunan baharu. Bersamaan dengan [.[] | f].
  • map_values(f) — menggunakan f pada setiap nilai dalam objek atau tatasusunan sambil mengekalkan kunci/indeks.

Fungsi ini lebih mudah dibaca berbanding membungkus saluran paip secara manual dalam [] dan merupakan gaya jq idiomatik untuk transformasi yang sepatutnya kekal sebagai tatasusunan.

# map: extract a field from each element
echo '[{"name":"Alice","score":95},{"name":"Bob","score":80}]' \
  | jq 'map(.name)'
# Output: ["Alice", "Bob"]

# map with select: filter + transform in one step
echo '[{"name":"Alice","score":95},{"name":"Bob","score":60}]' \
  | jq 'map(select(.score >= 70) | .name)'
# Output: ["Alice"]

# map_values: multiply every value in an object by 2
echo '{"a":1,"b":2,"c":3}' | jq 'map_values(. * 2)'
# Output: {"a":2,"b":4,"c":6}

Mengendalikan Medan Pilihan dan Nilai Lalai dengan //

Data JSON daripada sumber luaran selalunya tidak konsisten — medan mungkin tiada atau bernilai null. jq menyediakan pengendali alternatif // (garis miring berganda) untuk membekalkan nilai lalai.

  • .nickname // "anonymous" — gunakan .nickname jika nilainya bukan null/palsu, jika tidak gunakan "anonymous"
  • .count // 0 — nilai lalai berangka
  • Gabungkan dengan select: select((.status // "inactive") == "active")

Ini jauh lebih ringkas berbanding padanan shell ${VAR:-default} dan mudah digabungkan dalam saluran paip yang lebih panjang.

# Provide defaults for missing/null fields
echo '[{"name":"Alice","role":"admin"},{"name":"Bob"}]' \
  | jq '[.[] | {name, role: (.role // "user")}]'
# Output:
# [
#   {"name": "Alice", "role": "admin"},
#   {"name": "Bob",   "role": "user"}
# ]

# Numeric default
echo '{"items":[1,2,3]}' | jq '.total // 0'
# Output: 0

Skrip Praktikal: Penghurai Log JSON

Pembalakan JSON berstruktur ialah amalan standard dalam sistem moden. Berikut ialah skrip realistik yang membaca fail log JSON bersempadan baris baharu, menapis entri ralat dan memformat ringkasan yang boleh dibaca manusia.

Corak utama yang digunakan:

  • -c (output padat) — satu objek JSON bagi setiap baris, berguna untuk menyalurkan output ke gelung shell
  • --arg name value — menyuntik pemboleh ubah shell sebagai argumen rentetan jq
  • select untuk penapisan mengikut tahap log
  • -r untuk output rentetan mentah yang sesuai bagi echo
#!/usr/bin/env bash
# Parse newline-delimited JSON logs and report ERRORs
# Each log line: {"level":"ERROR","msg":"...","ts":"2024-01-15T10:23:00Z","svc":"auth"}

LOG_FILE="/var/log/app/app.log"
LEVEL="ERROR"

echo "=== $LEVEL entries in $LOG_FILE ==="

jq -r --arg lvl "$LEVEL" \
  'select(.level == $lvl) | "[\(.ts)] [\(.svc)] \(.msg)"' \
  "$LOG_FILE"

# Count errors per service
echo ""
echo "=== Error count by service ==="
jq -r --arg lvl "$LEVEL" \
  'select(.level == $lvl) | .svc' "$LOG_FILE" \
  | sort | uniq -c | sort -rn

Semakan Pengetahuan: Tingkah Laku jq select()

Uji pemahaman Anda tentang cara select() berfungsi dalam saluran paip jq.

Diberikan perintah berikut:

echo '[{"name":"Alice","age":30},{"name":"Bob","age":17},{"name":"Carol","age":22}]' | jq '[.[] | select(.age >= 18) | .name]'

Apakah outputnya?

Jawab dalam pelajaran interaktif

Rumusan Pelajaran: Saluran Paip jq untuk Menapis JSON

Anda telah mempelajari kit alat teras jq untuk menavigasi dan menapis JSON daripada baris perintah:

  • Notasi titik (.field, .a.b.c) memilih medan daripada objek
  • Akses tatasusunan (.[0], .[]) mengindeks dan mengulangi tatasusunan
  • Operator paip (|) merangkaikan penapis; setiap peringkat memproses semua nilai daripada peringkat sebelumnya
  • select(cond) menapis nilai, dengan hanya meneruskan nilai yang syaratnya benar
  • Pembinaan objek/tatasusunan ({}, [], map()) membentuk semula data menjadi struktur baharu
  • Operator alternatif (//) menyediakan nilai lalai untuk medan null atau yang tiada
  • Bendera -r membuang tanda petik untuk penetapan pemboleh ubah shell; --arg menyuntik pemboleh ubah shell dengan selamat
  • Penurunan rekursif (.. | .field?) mencari pepohon bersarang secara mendalam apabila laluan tidak diketahui

Dengan blok binaan ini, Anda boleh mengubah respons API JSON, fail log atau konfigurasi kepada data tepat yang diperlukan oleh skrip Anda — semuanya tanpa meninggalkan terminal.

Percuma untuk bermula

Pelajari Kem Intensif DevOps dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
142
Pelajaran
568
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Menapis dan Memilih JSON dengan Saluran Paip jq” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kem Intensif DevOps, termasuk “Menapis dan Memilih JSON dengan Saluran Paip jq”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kem Intensif DevOps merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Menapis dan Memilih JSON dengan Saluran Paip jq”?

Navigasi objek dan tatasusunan bersarang menggunakan pemilih jq, saluran paip dan penapis select Anda berlatih Kem Intensif DevOps menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif DevOps?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif DevOps di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Menapis dan Memilih JSON dengan Saluran Paip jq” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif DevOps ini?

Ya. Setiap pelajaran Kem Intensif DevOps menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Menapis dan Memilih JSON dengan Saluran Paip jq
  2. Mengubah dan Membina Objek JSON dengan jq
  3. Menggunakan API REST dengan curl dan jq Bersama-sama
  4. Mengedit Fail Konfigurasi YAML dengan yq
← Kembali ke Kem Intensif DevOps