R Academy · Ders

İç İçe JSON Yapılarını İşleme

Derin iç içe geçmiş JSON verilerini analiz için düzenli veri çerçevelerine dönüştürün.

İç İçe JSON Yapılarını İşleme, CoddyKit'te ücretsiz bir R Academy dersidir. Bu, 4 dersinin 4. 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, R Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. R Academy kursu toplamda 4 dersten oluşur.

İç İçe JSON Neden Zordur

REST API'leri genellikle tek bir alanın nesne dizisi, bu nesnelerin de başka nesneler içerdiği, derin biçimde iç içe JSON döndürür. Bu yapıyı düzenli bir veri çerçevesine dönüştürmek için jsonlite, purrr ve tidyr paketlerinin birlikte nasıl çalıştığını anlamak gerekir.

# Example nested JSON from a REST API:
json_str <- '{
  "user": {
    "id": 1,
    "name": "Alice",
    "orders": [
      {"order_id": 101, "total": 59.99, "status": "shipped"},
      {"order_id": 102, "total": 24.50, "status": "pending"}
    ]
  }
}'

# The challenge: 'orders' is an array of objects inside 'user'
cat('Nested JSON loaded as string, length:', nchar(json_str))

fromJSON() — Temel Ayrıştırma

jsonlite::fromJSON(), bir JSON dizesini veya dosya yolunu R nesnelerine dönüştürür. Basit düz JSON, bir listeye veya veri çerçevesine dönüşür. İç içe JSON ise iç içe bir listeye dönüşür — nesne dizileri, liste sütunlarında saklanan veri çerçevelerine dönüşür.

library(jsonlite)

# Parse flat JSON
flat_json <- '{"name": "Alice", "age": 30, "score": 95.5}'
result <- fromJSON(flat_json)
cat('Name:', result$name, '\n')
cat('Age: ', result$age,  '\n')

# Parse an array of objects — becomes a data frame
array_json <- '[{"id":1,"val":10},{"id":2,"val":20},{"id":3,"val":30}]'
df <- fromJSON(array_json)
cat('Class:', class(df), '\n')
print(df)

flatten = TRUE ile fromJSON()

flatten = TRUE bağımsız değişkeni, fromJSON() işlevine iç içe veri çerçevelerini özyinelemeli olarak açıp noktayla ayrılmış adlara sahip sütunlara dönüştürmesini söyler. Bu yaklaşım, bir düzey iç içelik için iyi çalışır ve orta düzeyde iç içe JSON'ı işlemenin en hızlı yoludur.

library(jsonlite)

json_str <- '[{
  "id": 1,
  "name": "Alice",
  "address": {"city": "Berlin", "country": "Germany"}
},{
  "id": 2,
  "name": "Bob",
  "address": {"city": "Paris", "country": "France"}
}]'

# Without flatten:
nested_df <- fromJSON(json_str, flatten = FALSE)
cat('address class:', class(nested_df$address), '\n')

# With flatten = TRUE:
flat_df <- fromJSON(json_str, flatten = TRUE)
cat('Columns:', names(flat_df), '\n')
print(flat_df)

İç İçe Diziler Liste Sütunlarına Dönüşür

Bir JSON alanı nesne dizisi içerdiğinde fromJSON(), bunu veri çerçevesinde bir liste sütunu olarak saklar — her hücre bir veri çerçevesi içerir. Bunlara açıkça erişmeniz veya iç içelikten çıkarmanız gerekir.

library(jsonlite)

json_str <- '[{
  "user_id": 1,
  "tags": ["R", "Python", "SQL"]
},{
  "user_id": 2,
  "tags": ["Java", "Kotlin"]
}]'

df <- fromJSON(json_str)
cat('tags column class:', class(df$tags), '\n')

# Access tags for user 1:
cat('User 1 tags:', df$tags[[1]], '\n')
cat('User 2 tags:', df$tags[[2]])

purrr::map() — İç İçe Alanları Çıkarma

purrr::map(), bir listedeki her öğeye bir işlev uygular. Her öğe adlandırılmış bir liste olduğunda (ayrıştırılmış JSON nesnesi), her öğeden adlandırılmış bir alanı çıkarmak için bir dize iletebilirsiniz — bu, döngünün kısa bir alternatifidir.

library(jsonlite)
library(purrr)

json_str <- '[{
  "id": 1,
  "meta": {"score": 88, "grade": "B"}
},{
  "id": 2,
  "meta": {"score": 95, "grade": "A"}
},{
  "id": 3,
  "meta": {"score": 72, "grade": "C"}
}]'

records <- fromJSON(json_str, simplifyDataFrame = FALSE)

# Extract 'score' from each record's 'meta' object
scores <- map_dbl(records, function(r) r$meta$score)
grades <- map_chr(records, function(r) r$meta$grade)

cat('Scores:', scores, '\n')
cat('Grades:', grades)

Dize Kısa Yolu ile purrr::map()

purrr::map(list, 'field_name'), her öğeden adlandırılmış bir alanı çıkarmanın kısa yoludur — map(list, function(x) x[['field_name']]) ile eşdeğerdir. Liste yerine türü belirli atomik vektörler elde etmek için map_chr(), map_dbl() vb. kullanın.

library(jsonlite)
library(purrr)

json_str <- '[{"name":"Alice","score":90},{"name":"Bob","score":78},{"name":"Carol","score":85}]'

# Parse as list of lists
records <- fromJSON(json_str, simplifyDataFrame = FALSE)

# String shortcut to extract field
names_vec  <- map_chr(records, 'name')
scores_vec <- map_dbl(records, 'score')

cat('Names: ', names_vec, '\n')
cat('Scores:', scores_vec, '\n')

# Build a clean data frame
clean_df <- data.frame(name = names_vec, score = scores_vec)
print(clean_df)

map() Zincirleriyle Derin İç İçe Yapılar

Derin biçimde iç içe JSON için birden fazla map() çağrısını zincirleyin. Her çağrı bir düzey aşağı iner. Her düzeyde map(list, 'field') kullanın ve en iç düzeyde son değeri çıkarmak için türü belirli bir map_*() uygulayın.

library(jsonlite)
library(purrr)

json_str <- '[{
  "id": 1,
  "company": {"hq": {"city": "Berlin", "country": "Germany"}}
},{
  "id": 2,
  "company": {"hq": {"city": "Tokyo",  "country": "Japan"}}
}]'

records <- fromJSON(json_str, simplifyDataFrame = FALSE)

# Navigate: records -> company -> hq -> city
cities <- map_chr(records, function(r) r$company$hq$city)
cat('Cities:', cities, '\n')

# Or using nested map shortcut:
ids <- map_int(records, 'id')
cat('IDs:', ids)

tidyr::unnest() — Liste Sütunlarını Düzleştirme

tidyr::unnest(), veri çerçeveleri içeren bir liste sütununu genişleterek her iç içe öğe için bir satır oluşturur. Bu, JSON verilerindeki bire-çok ilişkileri düzleştirmenin standart düzenli veri yaklaşımıdır.

library(jsonlite)
library(tidyr)
library(dplyr)

json_str <- '[{
  "user_id": 1,
  "orders": [{"oid":101,"total":50},{"oid":102,"total":30}]
},{
  "user_id": 2,
  "orders": [{"oid":103,"total":80}]
}]'

df <- fromJSON(json_str)
cat('Before unnest, rows:', nrow(df), '\n')
cat('orders class:', class(df$orders), '\n')

# Unnest expands one row per order
expanded <- unnest(df, cols = orders)
cat('After unnest, rows:', nrow(expanded), '\n')
print(expanded)

Veri Çerçevelerinde jsonlite::flatten()

jsonlite::flatten(), zaten ayrıştırılmış bir veri çerçevesi üzerinde çalışır (JSON dizesi üzerinde değil) ve iç içe veri çerçevesi sütunlarını noktayla ayrılmış ad sütunlarına özyinelemeli olarak genişletir. fromJSON(..., flatten = FALSE) sonrasında, düzleştirmeyi sonradan işleme adımı olarak yapmak istediğinizde kullanışlıdır.

library(jsonlite)

json_str <- '[{
  "id": 1,
  "profile": {"age": 25, "city": "Rome"}
},{
  "id": 2,
  "profile": {"age": 31, "city": "Oslo"}
}]'

# Parse without auto-flatten
nested <- fromJSON(json_str, flatten = FALSE)
cat('Columns before flatten:', names(nested), '\n')
cat('profile class:', class(nested$profile), '\n')

# Apply flatten() post-hoc
flat <- flatten(nested)
cat('Columns after flatten:', names(flat), '\n')
print(flat)

İç İçe JSON'da Null Değerleri Ele Alma

JSON null değerleri R'de NULL olarak ayrıştırılır; bu da veri çerçeveleri oluştururken sorunlara yol açar — listedeki bir NULL, öğenin tamamını düşürür. Eksik değerleri güvenli şekilde değiştirmek için purrr::map() işlevini .default bağımsız değişkeniyle veya %||% ile kullanın.

library(jsonlite)
library(purrr)

json_str <- '[{"id":1,"email":"alice@example.com"},{"id":2,"email":null},{"id":3,"email":"carol@example.com"}]'

records <- fromJSON(json_str, simplifyDataFrame = FALSE)

# Unsafe: NULL drops the element
# emails <- map_chr(records, 'email')  # ERROR on null

# Safe: provide a default for missing values
emails <- map_chr(records, function(r) {
  if (is.null(r$email)) NA_character_ else r$email
})

cat('Emails:', emails)
cat('NAs:', sum(is.na(emails)))

Eksiksiz Hat: API JSON'ından Düzenli Veri Çerçevesine

Tüm parçaları bir araya getirelim: bir API'den gelen iç içe JSON'ı ayrıştıran, alanları purrr ile çıkaran, null değerleri ele alan ve analiz için hazır düzenli bir veri çerçevesi üreten gerçekçi bir hat.

library(jsonlite)
library(purrr)
library(dplyr)

# Simulated API response
api_json <- '[{
  "id": 1, "name": "Alice",
  "stats": {"score": 92, "rank": 1}
},{
  "id": 2, "name": "Bob",
  "stats": null
},{
  "id": 3, "name": "Carol",
  "stats": {"score": 85, "rank": 3}
}]'

records <- fromJSON(api_json, simplifyDataFrame = FALSE)

result <- tibble(
  id    = map_int(records,  'id'),
  name  = map_chr(records,  'name'),
  score = map_dbl(records,  function(r) if (is.null(r$stats)) NA_real_ else r$stats$score),
  rank  = map_int(records,  function(r) if (is.null(r$stats)) NA_integer_ else r$stats$rank)
)

print(result)

Hızlı Kontrol

orders sütunu kullanıcı başına bir veri çerçevesi içeren bir liste sütunu olan bir df veri çerçeveniz var. Bunu sipariş başına bir satıra genişleten işlev hangisidir?

İç içe JSON — Temel Çıkarımlar

R'de iç içe JSON verilerini işlemek katmanlı bir araç seti gerektirir:

fromJSON(json, flatten = TRUE) — iç içeliğin bir düzeyini otomatik olarak düzleştirir
fromJSON(json, simplifyDataFrame = FALSE) — elle işlemek üzere listelerden oluşan bir liste elde eder
İç içe diziler → elde edilen veri çerçevesinde liste sütunlarına dönüşür
purrr::map_chr/dbl/int(list, 'field') — her öğeden türü belirli değerleri çıkarır
Zincirlenmiş map() çağrıları, derin iç içelik düzeylerinde ilerlemenizi sağlar
tidyr::unnest(df, cols = col) — veri çerçevelerinden oluşan liste sütunlarını genişletir
jsonlite::flatten(df) — ayrıştırma sonrasında iç içe veri çerçevesi sütunlarını düzleştirir
NULL değerlerini her zaman if (is.null(x)) NA else x ile güvenli şekilde ele alın

library(jsonlite)
library(purrr)

# Quick reference:
json <- '[{"id":1,"info":{"val":10}},{"id":2,"info":null}]'
recs <- fromJSON(json, simplifyDataFrame = FALSE)

# Safe extraction with null guard
vals <- map_dbl(recs, function(r) {
  if (is.null(r$info)) NA_real_ else r$info$val
})

result <- data.frame(id = map_int(recs, 'id'), val = vals)
print(result)

Sıkça Sorulan Sorular

“İç İçe JSON Yapılarını İşleme” dersi ücretsiz mi?

Evet — “İç İçe JSON Yapılarını İşleme” 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 R Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. R Academy kursu toplamda 4 dersten oluşur.

“İç İçe JSON Yapılarını İşleme” dersinde ne öğreneceğim?

Derin iç içe geçmiş JSON verilerini analiz için düzenli veri çerçevelerine dönüştürün. R Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

R Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te R Academy, 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 4. dersidir.

“İç İçe JSON Yapılarını İşleme” 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.

Bu R Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her R Academy 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.

Bu kursun tüm dersleri

← R Academy Sayfasına Dön