R Academy · Lektion

Verschachtelte JSON-Strukturen verarbeiten

Flachen Sie tief verschachteltes JSON für Analysen zu aufgeräumten Data Frames ab

Verschachtelte JSON-Strukturen verarbeiten ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum verschachteltes JSON schwierig ist

REST-APIs liefern häufig tief verschachteltes JSON zurück, bei dem ein einzelnes Feld ein Array von Objekten enthalten kann, die wiederum weitere Objekte enthalten. Um diese Struktur in einen aufgeräumten Data Frame umzuwandeln, müssen Sie verstehen, wie jsonlite, purrr und tidyr zusammenspielen.

# 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() – Grundlegendes Parsen

jsonlite::fromJSON() wandelt eine JSON-Zeichenfolge oder einen Dateipfad in R-Objekte um. Einfaches, flaches JSON wird zu einer Liste oder einem Data Frame. Verschachteltes JSON wird zu einer verschachtelten Liste – Arrays aus Objekten werden zu Data Frames, die in Listenspalten gespeichert sind.

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)

fromJSON() mit flatten = TRUE

Das Argument flatten = TRUE weist fromJSON() an, verschachtelte Data Frames rekursiv in Spalten mit durch Punkte getrennten Namen aufzulösen. Das funktioniert gut bei einer Verschachtelungsebene und ist die schnellste Möglichkeit, mäßig verschachteltes JSON zu verarbeiten.

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)

Verschachtelte Arrays werden zu Listenspalten

Wenn ein JSON-Feld ein Array aus Objekten enthält, speichert fromJSON() es als Listenspalte im Data Frame – jede Zelle enthält einen Data Frame. Sie müssen auf diese Daten ausdrücklich zugreifen oder sie entpacken.

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() – Verschachtelte Felder extrahieren

purrr::map() wendet eine Funktion auf jedes Element einer Liste an. Wenn jedes Element eine benannte Liste (ein geparstes JSON-Objekt) ist, können Sie eine Zeichenfolge übergeben, um aus jedem Element ein benanntes Feld zu extrahieren – eine kompakte Alternative zu einer Schleife.

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)

purrr::map() mit Kurzschreibweise für Zeichenfolgen

purrr::map(list, 'field_name') ist eine Kurzschreibweise zum Extrahieren eines benannten Felds aus jedem Element – gleichbedeutend mit map(list, function(x) x[['field_name']]). Verwenden Sie map_chr(), map_dbl() usw., um typisierte atomare Vektoren statt Listen zu erhalten.

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)

Tiefe Verschachtelung mit map()-Ketten

Bei tief verschachteltem JSON verketten Sie mehrere Aufrufe von map(). Jeder Aufruf steigt eine Ebene tiefer. Verwenden Sie auf jeder Ebene map(list, 'field') und wenden Sie beim innersten Schritt ein typisiertes map_*() an, um den endgültigen Wert zu extrahieren.

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() – Listenspalten entpacken

tidyr::unnest() erweitert eine Listenspalte, die Data Frames enthält, und erstellt eine Zeile pro verschachteltem Element. Dies ist der standardmäßige Tidy-Ansatz, um Eins-zu-viele-Beziehungen in JSON-Daten abzuflachen.

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)

jsonlite::flatten() auf Data Frames

jsonlite::flatten() arbeitet mit einem bereits geparsten Data Frame (nicht mit einer JSON-Zeichenfolge) und erweitert rekursiv alle verschachtelten Data-Frame-Spalten in Spalten mit durch Punkte getrennten Namen. Das ist nützlich nach fromJSON(..., flatten = FALSE), wenn Sie die Daten in einem nachgelagerten Verarbeitungsschritt abflachen möchten.

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)

Nullwerte in verschachteltem JSON verarbeiten

JSON-null-Werte werden in R zu NULL. Das verursacht beim Erstellen von Data Frames Probleme, da ein NULL in einer Liste das Element vollständig entfernt. Verwenden Sie purrr::map() mit einem .default-Argument oder %||%, um fehlende Werte sicher zu ersetzen.

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)))

Vollständige Pipeline: Von API-JSON zum Tidy Data Frame

Hier wird alles zusammengeführt: eine realistische Pipeline, die verschachteltes JSON aus einer API parst, mit purrr Felder extrahiert, Nullwerte verarbeitet und einen aufgeräumten Data Frame für die Analyse erzeugt.

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)

Kurzer Test

Sie haben einen Data Frame df, dessen Spalte orders eine Listenspalte mit Data Frames enthält (einen pro Benutzer). Welche Funktion erweitert diese Struktur zu einer Zeile pro Bestellung?

Verschachteltes JSON – wichtigste Erkenntnisse

Für die Verarbeitung von verschachteltem JSON in R benötigen Sie ein mehrstufiges Werkzeugset:

fromJSON(json, flatten = TRUE) – flacht eine Verschachtelungsebene automatisch ab
fromJSON(json, simplifyDataFrame = FALSE) – liefert eine Liste von Listen zur manuellen Verarbeitung
Verschachtelte Arrays → Listenspalten im resultierenden Dataframe
purrr::map_chr/dbl/int(list, 'field') – extrahiert typisierte Werte aus jedem Element
Verkettete map()-Aufrufe steigen durch tief verschachtelte Ebenen ab
tidyr::unnest(df, cols = col) – erweitert Listenspalten mit Dataframes
jsonlite::flatten(df) – flacht verschachtelte Dataframe-Spalten nach dem Parsen ab
Sichern Sie sich immer gegen NULL ab mit if (is.null(x)) NA else x

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)

Häufig gestellte Fragen

Ist die Lektion „Verschachtelte JSON-Strukturen verarbeiten“ kostenlos?

Ja — der vollständige Text von „Verschachtelte JSON-Strukturen verarbeiten“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Verschachtelte JSON-Strukturen verarbeiten“?

Flachen Sie tief verschachteltes JSON für Analysen zu aufgeräumten Data Frames ab Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um R Academy zu starten?

Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Verschachtelte JSON-Strukturen verarbeiten“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?

Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

JSON mit jsonlite parsen
HTTP-Anfragen mit httr2 senden
REST-APIs in R verwenden
Verschachtelte JSON-Strukturen verarbeiten

← Zurück zu R Academy