Analyser du JSON
Transformez du texte en valeurs JSON.
Analyser du JSON est une leçon Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Pourquoi Circe ?
Circe est une bibliothèque JSON populaire pour Scala, construite au-dessus de l’écosystème fonctionnel cats.
Elle privilégie la sûreté des types et l’immuabilité : l’analyse renvoie un Either au lieu de lever une erreur, et le décodage produit des valeurs typées plutôt que des cartes non typées.
Cette leçon explique comment transformer du texte JSON brut en modèle Json de Circe.
Ajouter la dépendance
Circe est distribué sous forme de plusieurs modules. Pour l’analyse syntaxique et le modèle central, vous avez besoin de circe-core et de circe-parser.
Le module circe-generic ajoute la dérivation automatique des codecs, abordée dans les leçons suivantes.
libraryDependencies ++= Seq(
"io.circe" %% "circe-core" % "0.14.6",
"io.circe" %% "circe-parser" % "0.14.6"
)La fonction parse
Le point d’entrée pour lire du JSON est io.circe.parser.parse.
Elle prend une String et renvoie Either[ParsingFailure, Json]. Le côté gauche contient les erreurs de syntaxe ; le côté droit contient l’arbre analysé.
import io.circe.parser._
val result = parse("{\"name\": \"Ada\", \"age\": 36}")
// result: Either[ParsingFailure, Json]Gérer les échecs d’analyse
Comme parse renvoie un Either, vous gérez explicitement les erreurs avec la correspondance de motifs ou des combinateurs, plutôt qu’avec try/catch.
Un ParsingFailure contient un message lisible décrivant le problème de syntaxe.
parse("{ not valid }") match {
case Right(json) => println(json)
case Left(err) => println(s"Failed: ${err.message}")
}Le modèle Json
Une valeur analysée avec succès est un Json : un arbre immuable représentant l’un des six types JSON : objet, tableau, chaîne, nombre, booléen ou valeur nulle.
Vous l’inspectez avec des prédicats tels que isObject ou vous parcourez sa structure avec un pliage.
val json = parse("[1, 2, 3]").getOrElse(Json.Null)
println(json.isArray) // true
println(json.isObject) // falseNaviguer avec le curseur
Pour accéder à des données imbriquées, appelez .hcursor sur une valeur Json. Le HCursor est une fermeture éclair qui vous permet de vous déplacer dans l’arbre.
Utilisez downField pour descendre jusqu’à une clé d’objet.
val json = parse("{\"user\": {\"name\": \"Ada\"}}").toOption.get
val cursor = json.hcursor
val name = cursor.downField("user").downField("name").as[String]
// name: Either[DecodingFailure, String] = Right(Ada)Extraire des valeurs avec as
Une fois positionné, .as[A] tente de décoder la valeur ciblée en un type A.
Il renvoie Either[DecodingFailure, A] ; une incompatibilité de types est donc signalée comme une valeur et non comme une exception.
val json = parse("{\"age\": 36}").toOption.get
val age = json.hcursor.downField("age").as[Int]
println(age) // Right(36)parse ou decode
Utilisez parse lorsque vous voulez inspecter manuellement l’arbre Json brut.
Utilisez decode[A] lorsque vous voulez passer directement de String à une valeur typée A en une seule étape. Cette opération combine l’analyse et le décodage.
import io.circe.parser.decode
val n: Either[io.circe.Error, Int] =
decode[Int]("42")
println(n) // Right(42)Champs facultatifs
Les fichiers JSON du monde réel comportent souvent des clés manquantes. La méthode de curseur get[A] appliquée à un champ ciblé échoue s’il est absent, tandis que getOrElse fournit une valeur par défaut.
Le décodage vers Option[A] traite un champ manquant ou nul comme None.
val json = parse("{\"name\": \"Ada\"}").toOption.get
val nick = json.hcursor.get[Option[String]]("nickname")
println(nick) // Right(None)Analyser des tableaux
Vous pouvez décoder directement un tableau JSON vers une collection Scala en demandant List[A] ou Vector[A].
Circe transforme chaque élément et s’arrête en renvoyant un DecodingFailure si l’un des éléments est du mauvais type.
import io.circe.parser.decode
val xs = decode[List[Int]]("[1, 2, 3]")
println(xs) // Right(List(1, 2, 3))Mise en forme
Toute valeur Json peut être reconvertie en texte avec .noSpaces pour une sortie compacte ou .spaces2 pour une sortie indentée.
Cela permet de reconvertir les données analysées dans leur format d’origine et s’avère pratique pour la journalisation ou le débogage.
val json = parse("{\"a\":1,\"b\":2}").toOption.get
println(json.noSpaces)
println(json.spaces2)Vérification rapide
Vérifiez votre compréhension de l’analyse avec Circe.
Récapitulatif
Vous avez appris à transformer du texte JSON en modèle Circe. parse renvoie Either[ParsingFailure, Json] ; decode[A] mène directement à une valeur typée.
Le HCursor permet de naviguer avec downField, et .as[A] extrait des valeurs typées. Les échecs sont des valeurs, pas des exceptions.
Questions Fréquemment Posées
La leçon « Analyser du JSON » est-elle gratuite ?
Oui — le texte complet de « Analyser du JSON » 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 Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Analyser du JSON » ?
Transformez du texte en valeurs JSON. Tu pratiques Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming ?
Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming 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 » ?
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 Scala for Backend Engineering & Functional Programming ?
Oui. Chaque leçon Scala for Backend Engineering & Functional Programming 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.