R Academy · Leçon

Analyser du JSON avec jsonlite

Convertissez des chaînes JSON en listes et trames de données R avec fromJSON().

Leçon 1 sur 413 étapes

Analyser du JSON avec jsonlite est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que JSON ?

JSON (JavaScript Object Notation) est le format universel d'échange de données pour les API et les services web. Le paquet jsonlite de R convertit JSON en objets R (listes, tableaux de données) et inversement, conformément aux conventions 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() : analyse de base

fromJSON(txt) analyse une chaîne JSON, une URL ou un chemin de fichier. Il convertit automatiquement les types JSON : chaînes → caractères, nombres → numériques, booléens → logiques, null → NA, tableaux → vecteurs, objets → listes nommées.

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() : sérialiser R en JSON

toJSON(x) convertit des objets R en chaînes JSON. Utilisez auto_unbox=TRUE pour convertir les vecteurs de longueur 1 en scalaires JSON, et non en tableaux. pretty=TRUE ajoute une indentation pour faciliter la lecture.

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

Tableaux JSON vers des trames de données

Les tableaux JSON d’objets sont automatiquement convertis en trames de données avec fromJSON(). Il s’agit de l’une des fonctionnalités les plus utiles de jsonlite : les réponses d’API sont souvent des tableaux d’enregistrements, parfaitement adaptés aux trames de données.

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

Trame de données vers JSON

La conversion d’une trame de données en JSON avec toJSON(df) produit un tableau JSON d’objets, à raison d’un objet par ligne. Il s’agit du format standard pour envoyer des données tabulaires aux 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() à partir d’une URL

fromJSON(url) peut récupérer et analyser directement du JSON depuis une URL. C’est la manière la plus simple d’appeler une API JSON publique qui ne nécessite pas d’authentification.

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

prettify(json_string) ajoute une indentation et des retours à la ligne pour faciliter la lecture par une personne. minify(json_string) supprime les espaces pour une transmission compacte. Ces deux fonctions agissent sur des chaînes JSON brutes.

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 pour les objets imbriqués

Lorsque le JSON contient des objets imbriqués, fromJSON(json, flatten=TRUE) aplatit les clés imbriquées en noms de colonnes séparés par des points, ce qui facilite leur utilisation dans une trame de données sans désimbriquage manuel.

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

Gérer NA et les clés manquantes en JSON

La valeur JSON null correspond à NA dans R. Les clés manquantes dans les tableaux JSON, lorsqu’un enregistrement possède un champ absent d’un autre, sont remplacées par NA dans la trame de données obtenue.

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>

Écrire du JSON dans des fichiers

Utilisez write_json() (ou writeLines(toJSON(x), file)) pour enregistrer des objets R dans des fichiers JSON. Il s’agit du format de sortie standard pour partager des données avec des applications web ou des 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')

Valider du JSON

validate(json_string), fourni par jsonlite, vérifie qu’une chaîne est un JSON valide et renvoie TRUE/FALSE. Cette fonction est utile avant l’analyse, notamment lorsque vous gérez des données saisies par l’utilisateur ou des réponses d’API potentiellement malformées.

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

Vérification rapide

Testez vos connaissances sur l’analyse du JSON avec jsonlite dans R.

Réponds-y dans la leçon interactive

Récapitulatif : JSON avec jsonlite

Points essentiels : fromJSON() analyse des chaînes JSON, des URL et des fichiers pour les convertir en listes ou en trames de données R. toJSON() convertit R en JSON : utilisez auto_unbox=TRUE pour les valeurs scalaires. prettify()/minify() mettent les chaînes en forme. flatten=TRUE aplatit les objets imbriqués. La valeur JSON null devient NA. validate() vérifie la validité du JSON avant l’analyse.

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

Gratuit pour commencer

Apprends R avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 43
Leçons: 159

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Analyser du JSON avec jsonlite » est-elle gratuite ?

Oui — le texte complet de « Analyser du JSON avec jsonlite » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Analyser du JSON avec jsonlite » ?

Convertissez des chaînes JSON en listes et trames de données R avec fromJSON(). Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Analyser du JSON avec jsonlite » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à R Academy