JSON parsen
Wandeln Sie Text in JSON-Werte um.
JSON parsen ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 1 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 Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Warum Circe?
Circe ist eine beliebte JSON-Bibliothek für Scala, die auf dem funktionalen cats-Ökosystem aufbaut.
Sie setzt auf Typsicherheit und Unveränderlichkeit: Beim Parsen wird ein Either zurückgegeben, statt eine Ausnahme auszulösen, und beim Decodieren entstehen typisierte Werte statt untypisierter Maps.
In dieser Lektion lernen Sie, rohen JSON-Text in Circes Json-Modell umzuwandeln.
Die Abhängigkeit hinzufügen
Circe wird in mehreren Modulen bereitgestellt. Für das Parsen und das Kernmodell benötigen Sie circe-core und circe-parser.
Das Modul circe-generic fügt die automatische Ableitung von Codecs hinzu, die in späteren Lektionen behandelt wird.
libraryDependencies ++= Seq(
"io.circe" %% "circe-core" % "0.14.6",
"io.circe" %% "circe-parser" % "0.14.6"
)Die Funktion parse
Der Einstiegspunkt zum Lesen von JSON ist io.circe.parser.parse.
Sie nimmt einen String entgegen und gibt Either[ParsingFailure, Json] zurück. Die linke Seite enthält Syntaxfehler, die rechte Seite den geparsten Baum.
import io.circe.parser._
val result = parse("{\"name\": \"Ada\", \"age\": 36}")
// result: Either[ParsingFailure, Json]Parse-Fehler behandeln
Da parse ein Either zurückgibt, behandeln Sie Fehler explizit mit Pattern Matching oder Combinators statt mit try/catch.
Ein ParsingFailure enthält eine verständliche Nachricht, die das Syntaxproblem beschreibt.
parse("{ not valid }") match {
case Right(json) => println(json)
case Left(err) => println(s"Failed: ${err.message}")
}Das Json-Modell
Ein erfolgreich geparster Wert ist ein Json – ein unveränderlicher Baum, der einen von sechs JSON-Typen darstellt: Objekt, Array, String, Zahl, Boolean oder null.
Sie untersuchen ihn mit Prädikaten wie isObject oder falten seine Struktur.
val json = parse("[1, 2, 3]").getOrElse(Json.Null)
println(json.isArray) // true
println(json.isObject) // falseMit dem Cursor navigieren
Um verschachtelte Daten zu lesen, rufen Sie .hcursor für einen Json-Wert auf. Der HCursor ist ein Zipper, mit dem Sie sich durch den Baum bewegen können.
Verwenden Sie downField, um in einen Objektschlüssel abzusteigen.
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)Werte mit as extrahieren
Sobald die gewünschte Position erreicht ist, versucht .as[A], den fokussierten Wert in den Typ A zu decodieren.
Die Methode gibt Either[DecodingFailure, A] zurück, sodass ein Typkonflikt als Wert und nicht als Ausnahme gemeldet wird.
val json = parse("{\"age\": 36}").toOption.get
val age = json.hcursor.downField("age").as[Int]
println(age) // Right(36)parse vs decode
Verwenden Sie parse, wenn Sie den rohen Json-Baum manuell untersuchen möchten.
Verwenden Sie decode[A], wenn Sie in einem Schritt direkt von String zu einem typisierten Wert A gelangen möchten. Die Methode kombiniert Parsen und Decodieren.
import io.circe.parser.decode
val n: Either[io.circe.Error, Int] =
decode[Int]("42")
println(n) // Right(42)Optionale Felder
JSON aus der Praxis enthält häufig fehlende Schlüssel. Die Cursor-Methode get[A] für ein ausgewähltes Feld schlägt bei Abwesenheit fehl, während getOrElse einen Standardwert liefert.
Beim Decodieren in Option[A] wird ein fehlendes oder null-Feld als None behandelt.
val json = parse("{\"name\": \"Ada\"}").toOption.get
val nick = json.hcursor.get[Option[String]]("nickname")
println(nick) // Right(None)Arrays parsen
Sie können ein JSON-Array direkt in eine Scala-Kollektion decodieren, indem Sie List[A] oder Vector[A] anfordern.
Circe bildet jedes Element ab und bricht mit einem DecodingFailure ab, sobald ein Element den falschen Typ hat.
import io.circe.parser.decode
val xs = decode[List[Int]]("[1, 2, 3]")
println(xs) // Right(List(1, 2, 3))Pretty Printing
Jeder Json-Wert wird mit .noSpaces als kompakter Text oder mit .spaces2 als eingerückter Text ausgegeben.
Damit können geparste Daten ohne Informationsverlust wieder als Text ausgegeben werden; außerdem ist dies für Logging und Debugging praktisch.
val json = parse("{\"a\":1,\"b\":2}").toOption.get
println(json.noSpaces)
println(json.spaces2)Kurzer Test
Testen Sie Ihr Verständnis des Parsens mit Circe.
Zusammenfassung
Sie haben gelernt, JSON-Text in Circes Modell umzuwandeln. parse liefert Either[ParsingFailure, Json]; decode[A] führt direkt zu einem typisierten Wert.
Der HCursor navigiert mit downField, und .as[A] extrahiert typisierte Werte. Fehler sind Werte und keine Ausnahmen.
Lerne Scala mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 39
- Lektionen
- 143
Häufig gestellte Fragen
Ist die Lektion „JSON parsen“ kostenlos?
Ja — der vollständige Text von „JSON parsen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „JSON parsen“?
Wandeln Sie Text in JSON-Werte um. Du übst Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming zu starten?
Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming 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 1 von 4.
Wie lange dauert die Lektion „JSON parsen“?
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 Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?
Ja. Jede Scala for Backend Engineering & Functional Programming-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.