R Academy · Lekcja

Parsowanie JSON za pomocą jsonlite

Konwertuj ciągi JSON na listy i ramki danych R za pomocą fromJSON().

Lekcja 1 z 413 kroki

Parsowanie JSON za pomocą jsonlite to bezpłatna lekcja R Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.

Czym jest JSON?

JSON (JavaScript Object Notation) to uniwersalny format wymiany danych dla interfejsów API i usług internetowych. Pakiet jsonlite języka R konwertuje JSON na obiekty R (listy i ramki danych) oraz z powrotem, zgodnie z konwencjami tidy.

library(jsonlite)
# JSON looks like:
# { "name": "Alice", "age": 30, "active": true }

# fromJSON parses JSON string to R object
json_str <- '{"name":"Alice","age":30,"active":true}'
result <- fromJSON(json_str)
class(result)   # 'list'
result$name     # 'Alice'
result$age      # 30 (numeric)
result$active   # TRUE (logical)

fromJSON(): podstawowe parsowanie

fromJSON(txt) parsuje ciąg JSON, adres URL lub ścieżkę do pliku. Automatycznie konwertuje typy JSON: ciągi znaków → character, liczby → numeric, wartości logiczne → logical, null → NA, tablice → wektory, obiekty → nazwane listy.

library(jsonlite)
# Parsing different JSON types
fromJSON('"hello"')         # character: 'hello'
fromJSON('42')               # numeric: 42
fromJSON('true')             # logical: TRUE
fromJSON('null')             # NA
fromJSON('[1, 2, 3]')        # numeric vector: c(1,2,3)
fromJSON('["a", "b", "c"]') # character vector

# Nested object
json <- '{"x": 1, "y": [2, 3], "z": null}'
obj <- fromJSON(json)
obj$x  # 1
obj$y  # c(2, 3)
obj$z  # NA

toJSON(): serializacja R do JSON

toJSON(x) konwertuje obiekty R na ciągi JSON. Należy użyć auto_unbox=TRUE, aby konwertować wektory długości 1 na skalarne wartości JSON (a nie tablice). pretty=TRUE dodaje wcięcia, zwiększając czytelność.

library(jsonlite)
# Basic serialization
toJSON(c(1, 2, 3))          # '[1,2,3]'
toJSON(list(a=1, b='two'))  # '{"a":[1],"b":["two"]}'

# auto_unbox: length-1 vectors become scalars
toJSON(list(name='Bob', age=25), auto_unbox = TRUE)
# '{"name":"Bob","age":25}'

# pretty printing
cat(toJSON(list(x=1, y=c(2,3)), pretty = TRUE))
# {
#   "x": [1],
#   "y": [2, 3]
# }

Tablice JSON do ramek danych

Tablice JSON zawierające obiekty są automatycznie konwertowane na ramki danych za pomocą fromJSON(). To jedna z najbardziej użytecznych funkcji pakietu jsonlite — odpowiedzi API często mają postać tablic rekordów, które idealnie nadają się do ramek danych.

library(jsonlite)
# JSON array of objects -> data frame
json_array <- '[
  {"name": "Alice", "age": 30, "score": 95},
  {"name": "Bob",   "age": 25, "score": 87},
  {"name": "Carol", "age": 35, "score": 92}
]'

df <- fromJSON(json_array)
class(df)   # 'data.frame'
nrow(df)    # 3
print(df)
# name age score
# Alice  30    95
# Bob    25    87
# Carol  35    92

Ramka danych do JSON

Konwersja ramki danych do JSON za pomocą toJSON(df) tworzy tablicę obiektów JSON (po jednym dla każdego wiersza). To standardowy format przesyłania danych tabelarycznych do internetowych interfejsów API.

library(jsonlite)
df <- data.frame(
  product = c('Apple', 'Banana', 'Cherry'),
  price   = c(1.20, 0.50, 3.00),
  in_stock = c(TRUE, TRUE, FALSE),
  stringsAsFactors = FALSE
)

# Default: each value is an array (even scalars)
cat(toJSON(df, pretty = FALSE))

# auto_unbox: single values become JSON scalars
cat('\n---\n')
cat(toJSON(df, auto_unbox = TRUE, pretty = TRUE))

fromJSON() z adresu URL

fromJSON(url) może bezpośrednio pobrać i przeanalizować kod JSON z adresu URL. To najprostszy sposób wywoływania publicznego interfejsu JSON API, który nie wymaga uwierzytelniania.

library(jsonlite)
# Read JSON directly from a URL (requires internet)
# Example: JSONPlaceholder (free test API)
# result <- fromJSON('https://jsonplaceholder.typicode.com/todos/1')
# result$title   # todo title
# result$completed  # TRUE/FALSE

# Example: GitHub API
# repos <- fromJSON('https://api.github.com/users/hadley/repos')
# repos$name   # vector of repo names
# nrow(repos)  # number of repos returned

# Simulate with local JSON string:
result <- fromJSON('{"id":1,"title":"Learn R","completed":false}')
cat('Task:', result$title, '\nDone:', result$completed)

prettify() i minify()

prettify(json_string) dodaje wcięcia i znaki nowego wiersza, aby ułatwić odczyt przez człowieka. minify(json_string) usuwa białe znaki, aby uzyskać zwięzły format do przesyłania. Obie funkcje działają na surowych ciągach JSON.

library(jsonlite)
# Compact (minified) JSON
compact_json <- '{"name":"Alice","scores":[95,87,92],"active":true}'
cat('Minified:\n', compact_json, '\n\n')

# Prettify: add whitespace
cat('Prettified:\n')
cat(prettify(compact_json))
# {
#   "name": "Alice",
#   "scores": [95, 87, 92],
#   "active": true
# }

# Minify: remove whitespace
pretty_json <- prettify(compact_json)
cat('\nRe-minified:\n')
cat(minify(pretty_json))

flatten=TRUE dla zagnieżdżonych obiektów

Gdy kod JSON zawiera zagnieżdżone obiekty, fromJSON(json, flatten=TRUE) spłaszcza zagnieżdżone klucze do nazw kolumn rozdzielonych kropkami. Ułatwia to pracę z ramką danych bez ręcznego rozpakowywania zagnieżdżeń.

library(jsonlite)
json <- '[
  {"id": 1, "user": {"name": "Alice", "city": "NY"}},
  {"id": 2, "user": {"name": "Bob",   "city": "LA"}}
]'

# Without flatten: nested list column
df_nested <- fromJSON(json)
class(df_nested$user)   # data.frame (nested!)

# With flatten: flat column names
df_flat <- fromJSON(json, flatten = TRUE)
names(df_flat)     # c('id', 'user.name', 'user.city')
print(df_flat)
# id user.name user.city
#  1     Alice        NY
#  2       Bob        LA

Obsługa NA i brakujących kluczy w JSON

Wartość JSON null jest mapowana na NA w języku R. Brakujące klucze w tablicach JSON (gdy jeden rekord zawiera pole, którego brakuje w innym) są w wynikowej ramce danych uzupełniane wartością NA.

library(jsonlite)
# JSON with null values
json_nulls <- '{"a": 1, "b": null, "c": "hello"}'
obj <- fromJSON(json_nulls)
obj$b  # NA
is.na(obj$b)  # TRUE

# Array with missing keys
json_missing <- '[
  {"name": "Alice", "age": 30, "email": "a@b.com"},
  {"name": "Bob",   "age": 25}
]'
# 'email' missing from second record
df <- fromJSON(json_missing)
print(df)
# name age    email
# Alice  30  a@b.com
# Bob    25     <NA>

Zapisywanie JSON w plikach

Użyj funkcji write_json() (lub writeLines(toJSON(x), file)), aby zapisać obiekty R jako pliki JSON. To standardowy format wyjściowy służący do udostępniania danych aplikacjom internetowym lub interfejsom API.

library(jsonlite)
results <- list(
  model = 'linear_regression',
  coefficients = list(intercept = 2.5, slope = 1.3),
  r_squared = 0.87,
  n_obs = 100
)

# Convert to JSON string
json_output <- toJSON(results, auto_unbox = TRUE, pretty = TRUE)
cat(json_output)

# Save to file (uncomment):
# write_json(results, 'model_results.json',
#            auto_unbox = TRUE, pretty = TRUE)
# Or equivalently:
# writeLines(json_output, 'model_results.json')

Sprawdzanie poprawności JSON

Funkcja validate(json_string) z pakietu jsonlite sprawdza, czy ciąg znaków jest poprawnym kodem JSON, i zwraca TRUE/FALSE. Jest przydatna przed analizowaniem danych, szczególnie podczas obsługi danych wprowadzanych przez użytkownika lub odpowiedzi API, które mogą być niepoprawnie sformułowane.

library(jsonlite)
# Valid JSON
validate('{"name": "Alice", "age": 30}')  # TRUE
validate('[1, 2, 3]')                       # TRUE
validate('"just a string"')                # TRUE

# Invalid JSON
validate('{name: Alice}')     # FALSE (unquoted keys)
validate('[1, 2, 3,]')        # FALSE (trailing comma)
validate('')                   # FALSE

# Safe parsing pattern
safe_parse <- function(json) {
  if (!validate(json)) {
    warning('Invalid JSON')
    return(NULL)
  }
  fromJSON(json)
}
safe_parse('{"x": 1}')
safe_parse('{bad json}')

Szybki test

Sprawdź swoją wiedzę na temat analizowania kodu JSON za pomocą pakietu jsonlite w języku R.

Odpowiedz w interaktywnej lekcji

Podsumowanie: JSON z pakietem jsonlite

Najważniejsze informacje: fromJSON() analizuje ciągi JSON, adresy URL i pliki, przekształcając je w listy lub ramki danych R. toJSON() konwertuje obiekty R do JSON — w przypadku skalarów użyj auto_unbox=TRUE. Funkcje prettify()/minify() formatują ciągi. flatten=TRUE spłaszcza zagnieżdżone obiekty. JSON-owa wartość null staje się wartością NA. Funkcja validate() sprawdza poprawność JSON przed jego analizowaniem.

library(jsonlite)
# Complete jsonlite workflow:

# Parse
df <- fromJSON('[{"a":1,"b":2},{"a":3,"b":4}]')
print(df)

# Serialize
json <- toJSON(df, auto_unbox = TRUE, pretty = FALSE)
cat(json, '\n')

# Flatten nested
nested <- fromJSON(
  '[{"id":1,"x":{"val":10}},{"id":2,"x":{"val":20}}]',
  flatten = TRUE
)
print(nested)

# Validate before parse
validate('{"key": "value"}')  # TRUE

Bezpłatny start

Ucz się R dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 43
Lekcje: 159

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Parsowanie JSON za pomocą jsonlite” jest bezpłatna?

Tak — pełny tekst „Parsowanie JSON za pomocą jsonlite” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Parsowanie JSON za pomocą jsonlite”?

Konwertuj ciągi JSON na listy i ramki danych R za pomocą fromJSON(). Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć R Academy?

Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Parsowanie JSON za pomocą jsonlite”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?

Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do R Academy