0Pricing
R Academy · Lección

Análisis de JSON con jsonlite

Convierta cadenas JSON en listas y marcos de datos de R con fromJSON().

Análisis de JSON con jsonlite es una lección gratuita de R Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

¿Qué es JSON?

JSON (JavaScript Object Notation) es el formato universal de intercambio de datos para API y servicios web. El paquete jsonlite de R convierte JSON en objetos de R (listas y marcos de datos) y viceversa, siguiendo convenciones 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(): análisis básico

fromJSON(txt) analiza una cadena JSON, una URL o una ruta de archivo. Convierte automáticamente los tipos JSON: cadenas → character, números → numeric, booleanos → logical, null → NA, matrices → vectores y objetos → listas con nombre.

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(): serialización de R a JSON

toJSON(x) convierte objetos de R en cadenas JSON. Utilice auto_unbox=TRUE para convertir vectores de longitud 1 en escalares JSON (no en matrices). pretty=TRUE añade sangría para mejorar la legibilidad.

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]
# }

Matrices JSON a data frames

Las matrices JSON de objetos se convierten automáticamente en data frames con fromJSON(). Esta es una de las funciones más útiles de jsonlite: las respuestas de las API suelen ser matrices de registros, perfectamente adecuadas para los data frames.

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

De data frame a JSON

Convertir un data frame a JSON con toJSON(df) produce una matriz JSON de objetos, uno por fila. Este es el formato estándar para enviar datos tabulares a las API web.

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() desde una URL

fromJSON(url) puede obtener y analizar directamente JSON desde una URL. Es la forma más sencilla de llamar a una API JSON pública que no requiere autenticación.

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() y minify()

prettify(json_string) añade sangría y saltos de línea para facilitar la lectura. minify(json_string) elimina los espacios en blanco para una transmisión compacta. Ambas funciones operan sobre cadenas JSON sin procesar.

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 para objetos anidados

Cuando el JSON contiene objetos anidados, fromJSON(json, flatten=TRUE) aplana las claves anidadas y las convierte en nombres de columna separados por puntos. Esto facilita trabajar con los datos como un data frame sin tener que desanidarlos manualmente.

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

Gestión de NA y claves ausentes en JSON

El valor JSON null se convierte en el NA de R. Las claves ausentes en las matrices JSON, cuando un registro tiene un campo que otro no tiene, se rellenan con NA en el data frame resultante.

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>

Escritura de JSON en archivos

Use write_json() (o writeLines(toJSON(x), file)) para guardar objetos de R como archivos JSON. Este es el formato de salida estándar para compartir datos con aplicaciones web o 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')

Validación de JSON

validate(json_string), de jsonlite, comprueba si una cadena contiene un JSON válido y devuelve TRUE/FALSE. Resulta útil antes de analizar los datos, especialmente al gestionar entradas del usuario o respuestas de API que podrían tener un formato incorrecto.

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

Comprobación rápida

Compruebe sus conocimientos sobre el análisis de JSON con jsonlite en R.

Resumen: JSON con jsonlite

Ideas clave: fromJSON() analiza cadenas JSON, URL y archivos, y los convierte en listas o data frames de R. toJSON() convierte objetos de R a JSON; use auto_unbox=TRUE para valores escalares. prettify()/minify() da formato a las cadenas. flatten=TRUE aplana los objetos anidados. El valor JSON null se convierte en NA. validate() comprueba que el JSON sea válido antes de analizarlo.

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

Preguntas frecuentes

¿La lección «Análisis de JSON con jsonlite» es gratis?

Sí — el texto completo de «Análisis de JSON con jsonlite» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Análisis de JSON con jsonlite»?

Convierta cadenas JSON en listas y marcos de datos de R con fromJSON(). Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar R Academy?

No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Análisis de JSON con jsonlite»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de R Academy?

Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Análisis de JSON con jsonlite
  2. Realización de solicitudes HTTP con httr2
  3. Consumo de API REST en R
  4. Gestión de estructuras JSON anidadas
← Volver a R Academy