Linux Command Line & Bash Scripting Mastery · Ders

jq ile JSON Nesnelerini Dönüştürme ve Oluşturma

Q: “jq ile JSON Nesnelerini Dönüştürme ve Oluşturma” dersi ücretsiz mi?

Evet — “jq ile JSON Nesnelerini Dönüştürme ve Oluşturma” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Linux Command Line & Bash Scripting Mastery kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Linux Command Line & Bash Scripting Mastery kursu toplamda 4 dersten oluşur.

Q: Linux Command Line & Bash Scripting Mastery öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Linux Command Line & Bash Scripting Mastery, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

Q: “jq ile JSON Nesnelerini Dönüştürme ve Oluşturma” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Q: Bu Linux Command Line & Bash Scripting Mastery dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Linux Command Line & Bash Scripting Mastery dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Yeni JSON yükleri oluşturmak için map, to_entries ve nesne oluşturma işlemleriyle verileri yeniden şekillendirin.

jq ile JSON Nesnelerini Dönüştürme ve Oluşturma, CoddyKit'te ücretsiz bir Linux Command Line & Bash Scripting Mastery dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Linux Command Line & Bash Scripting Mastery öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Linux Command Line & Bash Scripting Mastery kursu toplamda 4 dersten oluşur.

JSON'ı Neden Dönüştürmelisiniz?

API'lerden veya günlük dosyalarından gelen ham JSON, nadiren tam olarak ihtiyaç duyduğunuz biçimdedir. Büyük bir nesne alıp yalnızca belirli alanları isteyebilir, anahtarları yeniden adlandırmanız, iç içe yapıları düzleştirmeniz veya başka bir hizmete göndermek üzere tamamen yeni bir veri yükü oluşturmanız gerekebilir.

jq, bu dönüşümleri tek bir işlem hattında mümkün kılan, hafif ve güçlü bir komut satırı JSON işlemcisidir. Bu derste verileri yeniden biçimlendirmenin üç temel tekniğini öğreneceksiniz:

Nesne oluşturma — sıfırdan yeni bir JSON nesnesi oluşturma
map — bir dönüşümü dizinin her öğesine uygulama
to_entries / from_entries — bir nesnenin anahtar-değer çiftlerini filtreleyip yeniden oluşturabilmeniz için dizi olarak ele alma

Tüm örneklerde jq'nun yüklü olduğu varsayılır (apt install jq / brew install jq).

Nesne Oluşturmanın Temelleri

jq'nun en temel özelliği nesne oluşturma işlemidir: yeni bir JSON nesnesi oluşturmak için ifadeleri {} içine alırsınız. Hangi alanların ekleneceğini ve bunlara ne ad verileceğini siz seçersiniz.

Söz dizimi:

{ newKey: .existingField } — bir alanı yeniden adlandırır
{ name, age } — yeni anahtar alan adıyla eşleştiğinde kullanılan kısa yazım
{ total: (.price * .qty) } — bir değeri satır içinde hesaplar

Aşağıdaki parça bir ürün JSON'ını okur ve hesaplanmış bir subtotal alanı içeren daha yalın bir biçim üretir.

#!/usr/bin/env bash
# Object construction: pick and rename fields
product='{
  "id": 42,
  "name": "Widget Pro",
  "price": 9.99,
  "qty": 3,
  "warehouse": "EU-West"
}'

echo "$product" | jq '{
  productId: .id,
  name,
  subtotal: (.price * .qty)
}'

İç İçe Verilerden Nesne Oluşturma

Gerçek dünyadaki JSON çoğunlukla iç içe yapıdadır. jq, bir nesne oluşturucunun içinde iç içe yollara erişmenizi ve aynı anda yapıyı düzleştirmenizi sağlar.

Oluşturucunun değer ifadesi içinde nokta-yolu gösterimini kullanın:

{ city: .address.city }
{ lat: .location.coords.lat }

Aşağıdaki örnek, derin biçimde iç içe bir kullanıcı kaydını alır ve CSV başlık satırına veya API istek gövdesine uygun düz bir özet üretir.

#!/usr/bin/env bash
user='{
  "id": "u-001",
  "profile": {
    "displayName": "Ada Lovelace",
    "contact": { "email": "ada@example.com", "phone": "+44-700" }
  },
  "plan": "pro"
}'

echo "$user" | jq '{
  id,
  name: .profile.displayName,
  email: .profile.contact.email,
  plan
}'

Dizileri map ile Dönüştürme

map(expr), jq'da her öğe için işleminin karşılığıdır: expr ifadesini girdi dizisinin her öğesine uygular ve aynı uzunlukta yeni bir dizi döndürür.

Önemli noktalar:

map(expr), [.[] | expr] için kullanılan kısa yazımdır
İçindeki ifade, nesne oluşturma da dahil olmak üzere herhangi bir jq filtresi olabilir
Dönüştürmeden önce filtrelemek için select() ile zincirleyebilirsiniz

Aşağıdaki parça bir sipariş listesini işler ve yalnızca sevkiyat manifestosu için gereken alanları tutar.

#!/usr/bin/env bash
orders='[
  {"orderId": 1, "customer": "Alice", "total": 42.50, "status": "shipped"},
  {"orderId": 2, "customer": "Bob",   "total": 18.00, "status": "pending"},
  {"orderId": 3, "customer": "Carol", "total": 99.99, "status": "shipped"}
]'

# Produce a shipping manifest: only shipped orders, slim fields
echo "$orders" | jq '[
  .[] | select(.status == "shipped") | {
    id: .orderId,
    recipient: .customer,
    amount: .total
  }
]'

map ile Hesaplanmış Alanlar

map içinde yalnızca alanları kopyalamakla kalmaz, yeni değerler hesaplayabilir, türleri dönüştürebilir ve alanları birleştirebilirsiniz. Yaygın örüntüler şunlardır:

Dize araya ekleme: "\(.first) \(.last)"
Aritmetik: %20 kâr eklemek için (.price * 1.2 | round)
Koşullu ifadeler: if .score >= 90 then "A" else "B" end

Aşağıdaki örnek, bir çalışan listesini deneyime dayalı hesaplanmış bir fullName ve seniority etiketi ekleyerek zenginleştirir.

#!/usr/bin/env bash
staff='[
  {"first": "Grace", "last": "Hopper",  "years": 15},
  {"first": "Alan",  "last": "Turing",  "years": 4},
  {"first": "Linus", "last": "Torvalds","years": 9}
]'

echo "$staff" | jq 'map({
  fullName: "\(.first) \(.last)",
  years,
  seniority: (if .years >= 10 then "senior" elif .years >= 5 then "mid" else "junior" end)
})'

to_entries'i Anlama

to_entries, bir JSON nesnesini {key, value} çiftlerinden oluşan bir diziye dönüştürür. Böylece bir nesnenin alanları üzerinde dizi işlemlerini (map, select, sort) kullanabilirsiniz; bunu doğrudan bir nesne üzerinde yapamazsınız.

Örnek dönüşüm:

Girdi: {"a": 1, "b": 2}
Çıktı: [{"key": "a", "value": 1}, {"key": "b", "value": 2}]

Ters işlem olan from_entries, bu diziyi yeniden nesneye dönüştürür. Birlikte, nesne düzeyinde dönüşümler için to_entries | map(...) | from_entries deyimini oluştururlar.

#!/usr/bin/env bash
# Demonstrate to_entries and from_entries
config='{"host": "db.local", "port": 5432, "ssl": true}'

echo "--- to_entries output ---"
echo "$config" | jq 'to_entries'

echo "--- round-trip back to object ---"
echo "$config" | jq 'to_entries | from_entries'

to_entries ile Anahtarları Filtreleme

to_entries kullanımının en pratik örneklerinden biri, tutulacak veya kaldırılacak anahtarları dinamik olarak filtrelemektir. Bu işlem, anahtar adlarını önceden bilmiyorsanız nesne oluşturmayla yapılamaz.

Örüntü:

to_entries | map(select(.key | test("regex"))) | from_entries
to_entries | map(select(.key != "secret")) | from_entries

Aşağıdaki parça, bir yapılandırma nesnesini harici bir hizmete iletmeden önce alt çizgiyle başlayan tüm anahtarları (dahili/özel alanları) kaldırır.

#!/usr/bin/env bash
raw_config='{
  "endpoint": "https://api.example.com",
  "timeout": 30,
  "_internalToken": "s3cr3t",
  "_debugMode": true,
  "retries": 3
}'

# Remove any key starting with underscore
echo "$raw_config" | jq '
  to_entries
  | map(select(.key | startswith("_") | not))
  | from_entries
'

to_entries ile Anahtarları Dinamik Olarak Yeniden Adlandırma

Nesne oluşturma, anahtar adlarını yazma sırasında biliyorsanız onları yeniden adlandırır. to_entries ise anahtarları programlı olarak yeniden adlandırmanızı sağlar; örneğin camelCase'i snake_case'e dönüştürebilir veya bir ön ek ekleyebilirsiniz.

map içinde her girdinin .key alanını günceller, ardından from_entries'e yönlendirirsiniz:

map(.key |= gsub("(?<=[a-z])(?=[A-Z])"; "_") | .key |= ascii_downcase) — camelCase'i snake_case'e dönüştürür
map(.key |= "app_" + .) — her anahtara bir ön ek ekler

Örnek, bir kapsayıcıya eklemeden önce ad alanı oluşturmak için tüm ortam değişkeni adlarına APP_ ön ekini ekler.

#!/usr/bin/env bash
env_vars='{"host": "localhost", "port": "8080", "debug": "false"}'

# Add APP_ prefix and uppercase all keys
echo "$env_vars" | jq '
  to_entries
  | map({ key: ("APP_" + (.key | ascii_upcase)), value })
  | from_entries
'

with_entries: Kullanışlı Kısa Yazım

to_entries | map(...) | from_entries örüntüsü o kadar yaygındır ki jq bunun için with_entries(expr) adlı bir kısa yazım sunar.

Tam olarak aynı işlemi daha kısa biçimde gerçekleştirir:

with_entries(.value |= . * 2) — her sayısal değeri iki katına çıkarır
with_entries(select(.value != null)) — null değerli anahtarları kaldırır
with_entries(.key |= ascii_upcase) — tüm anahtarları büyük harfe dönüştürür

Aşağıdaki parça, REST API'ye bir PATCH isteği göndermeden önce değeri null veya boş dize olan tüm anahtarları kaldırır; bu yaygın bir temizleme adımıdır.

#!/usr/bin/env bash
patch_body='{
  "name": "Mehmet",
  "email": "",
  "phone": null,
  "city": "Istanbul"
}'

# Drop empty/null fields before PATCH
cleaned=$(echo "$patch_body" | jq '
  with_entries(select(.value != null and .value != ""))
')

echo "Cleaned payload:"
echo "$cleaned"

# In practice you would pipe to curl:
# curl -s -X PATCH https://api.example.com/users/1 \
#   -H "Content-Type: application/json" \
#   -d "$cleaned"

Bir İşlem Hattında map ile Nesne Oluşturmayı Birleştirme

Gerçek dönüşümler birden fazla jq işlemini birbirine bağlar. Bir API veri yükünü hazırlayan tipik bir işlem hattı şunları yapabilir:

Girdi dizisini map(select(...)) ile filtrelemek
Nesne oluşturmayla her öğeyi yeniden biçimlendirmek
Hesaplanmış alanlar eklemek
Sonucu sıralamak

Aşağıdaki örnek bir sunucu ölçümleri listesini okur, yalnızca CPU kullanımı yüksek sunucuları tutar ve bir webhook'a POST edilmeye hazır, yalın bir uyarı veri yükü üretir.

#!/usr/bin/env bash
metrics='[
  {"host": "web-01", "cpu": 23, "mem": 60, "region": "eu"},
  {"host": "web-02", "cpu": 91, "mem": 88, "region": "eu"},
  {"host": "db-01",  "cpu": 78, "mem": 95, "region": "us"},
  {"host": "db-02",  "cpu": 12, "mem": 40, "region": "us"}
]'

alerts=$(echo "$metrics" | jq '[
  .[] | select(.cpu > 75 or .mem > 85) | {
    server: .host,
    region,
    severity: (if .cpu > 90 or .mem > 90 then "critical" else "warning" end),
    metrics: { cpu: .cpu, mem: .mem }
  }
] | sort_by(.severity)')

echo "$alerts"

Birden Fazla Kaynaktan Yeni JSON Nesnesi Oluşturma

jq, toplama işleci + ve as $var ile değişken bağlama kullanarak girdileri birleştirebilir ve birden fazla JSON kaynağından veri alan nesneler oluşturabilir.

Yararlı örüntüler:

obj1 + obj2 — iki nesneyi birleştirir (anahtar çakışmalarında sağ taraf kazanır)
--argjson — ikinci bir JSON belgesini değişken olarak geçirir
$ENV — ortam değişkenlerini doğrudan jq içinde okur

Aşağıdaki parça, temel yapılandırmayı ortama özgü geçersiz kılmalarla birleştirir; bu, kabuk betiklerindeki 12 faktörlü uygulama yapılandırma yönetiminde yaygın bir örüntüdür.

#!/usr/bin/env bash
base_config='{
  "logLevel": "info",
  "timeout": 30,
  "retries": 3,
  "database": "postgres://db.local/app"
}'

env_overrides='{
  "logLevel": "debug",
  "database": "postgres://db.staging/app_staging"
}'

# Merge: overrides win on conflicts
merged=$(echo "$base_config" | jq --argjson overrides "$env_overrides" '. + $overrides')

echo "Merged config:"
echo "$merged"

Bilgi Kontrolü: to_entries ve map Karşılaştırması

Aşağıdaki JSON nesnesine sahipsiniz ve değeri 0'dan küçük olan tüm anahtarları kaldırarak yalnızca negatif olmayan değerleri içeren yeni bir nesne oluşturmanız gerekiyor. Bunu hangi jq ifadesi doğru şekilde gerçekleştirir?

Girdi: {"a": 10, "b": -3, "c": 0, "d": 5}

Ders Özeti: JSON'ı jq ile Dönüştürme

JSON'ı jq ile yeniden biçimlendirmek için gereken temel teknikleri ele aldınız:

Nesne oluşturma {} — girdiden alanları seçerek, yeniden adlandırarak ve hesaplayarak yeni nesneler oluşturur
map(expr) — iç içe nesne oluşturma ve filtreleme için select() dahil olmak üzere herhangi bir dönüşümü dizinin her öğesine uygular
to_entries / from_entries — bir nesneyi {key, value} çiftlerinden oluşan diziye dönüştürerek anahtarlar ve değerler üzerinde dizi işlemlerini mümkün kılar, ardından yeniden nesneye dönüştürür
with_entries(expr) — eksiksiz to_entries → map → from_entries işlem hattının kısa yazımıdır
Birden fazla kaynaktan gelen veri yükleri için + ve --argjson ile nesneleri birleştirme

Bu yapı taşları bir arada kullanılabilir: select ile filtreleyin, nesne oluşturmayla yeniden biçimlendirin, hesaplanmış alanlarla zenginleştirin ve tümünü tek bir okunabilir jq ifadesinde birbirine bağlayın. Bu örüntülere hâkim olduğunuzda, Python veya Node ile özel bir betik yazmadan, neredeyse tüm JSON veri yüklerini doğrudan kabukta işleyebilirsiniz.

Sıkça Sorulan Sorular