Analizar JSON
Convierta texto en valores JSON
Analizar JSON es una lección gratuita de Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
¿Por qué Circe?
Circe es una biblioteca popular de JSON para Scala, construida sobre el ecosistema funcional de cats.
Prioriza la seguridad de tipos y la inmutabilidad: el análisis devuelve un Either en lugar de lanzar excepciones, y la decodificación produce valores tipados en vez de mapas sin tipo.
En esta lección aprenderá a convertir texto JSON sin procesar en el modelo Json de Circe.
Añadir la dependencia
Circe se distribuye como varios módulos. Para analizar JSON y usar el modelo principal necesita circe-core y circe-parser.
El módulo circe-generic añade la derivación automática de códecs, que se aborda en lecciones posteriores.
libraryDependencies ++= Seq(
"io.circe" %% "circe-core" % "0.14.6",
"io.circe" %% "circe-parser" % "0.14.6"
)La función parse
El punto de entrada para leer JSON es io.circe.parser.parse.
Recibe un String y devuelve Either[ParsingFailure, Json]. El lado izquierdo contiene los errores de sintaxis; el derecho contiene el árbol analizado.
import io.circe.parser._
val result = parse("{\"name\": \"Ada\", \"age\": 36}")
// result: Either[ParsingFailure, Json]Gestionar errores de análisis
Como parse devuelve un Either, debe gestionar los errores explícitamente mediante pattern matching o combinadores, en lugar de usar try/catch.
Un ParsingFailure incluye un mensaje legible que describe el problema de sintaxis.
parse("{ not valid }") match {
case Right(json) => println(json)
case Left(err) => println(s"Failed: ${err.message}")
}El modelo Json
Un valor analizado correctamente es un Json: un árbol inmutable que representa uno de los seis tipos de JSON: objeto, array, cadena, número, booleano o null.
Puede inspeccionarlo con predicados como isObject o plegarlo según su estructura.
val json = parse("[1, 2, 3]").getOrElse(Json.Null)
println(json.isArray) // true
println(json.isObject) // falseNavegar con el cursor
Para acceder a datos anidados, llame a .hcursor sobre un valor Json. El HCursor es un zipper que le permite desplazarse por el árbol.
Use downField para descender hasta una clave de un objeto.
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)Extraer valores con as
Una vez situado en la posición deseada, .as[A] intenta decodificar el valor enfocado al tipo A.
Devuelve Either[DecodingFailure, A], por lo que una incompatibilidad de tipos se informa como un valor y no como una excepción.
val json = parse("{\"age\": 36}").toOption.get
val age = json.hcursor.downField("age").as[Int]
println(age) // Right(36)parse frente a decode
Use parse cuando quiera inspeccionar manualmente el árbol Json sin procesar.
Use decode[A] cuando quiera pasar directamente de String a un valor tipado A en un solo paso. Combina el análisis y la decodificación.
import io.circe.parser.decode
val n: Either[io.circe.Error, Int] =
decode[Int]("42")
println(n) // Right(42)Campos opcionales
El JSON del mundo real suele tener claves ausentes. El método del cursor get[A] aplicado a un campo seleccionado falla si este no existe, mientras que getOrElse proporciona un valor predeterminado.
La decodificación en Option[A] trata un campo ausente o nulo como None.
val json = parse("{\"name\": \"Ada\"}").toOption.get
val nick = json.hcursor.get[Option[String]]("nickname")
println(nick) // Right(None)Analizar arrays
Puede decodificar directamente un array JSON en una colección de Scala solicitando List[A] o Vector[A].
Circe transforma cada elemento y se detiene con un DecodingFailure si algún elemento tiene un tipo incorrecto.
import io.circe.parser.decode
val xs = decode[List[Int]]("[1, 2, 3]")
println(xs) // Right(List(1, 2, 3))Imprimir con formato
Cualquier valor Json se convierte de nuevo en texto con .noSpaces para una salida compacta o .spaces2 para una salida indentada.
Esto permite serializar de ida y vuelta los datos analizados y resulta útil para registrar información o depurar.
val json = parse("{\"a\":1,\"b\":2}").toOption.get
println(json.noSpaces)
println(json.spaces2)Comprobación rápida
Compruebe lo que ha aprendido sobre el análisis con Circe.
Repaso
Ha aprendido a convertir texto JSON en el modelo de Circe. parse produce Either[ParsingFailure, Json]; decode[A] pasa directamente a un valor tipado.
El HCursor permite navegar con downField, y .as[A] extrae valores tipados. Los errores son valores, no excepciones.
Preguntas frecuentes
¿La lección «Analizar JSON» es gratis?
Sí — el texto completo de «Analizar JSON» 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 Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
¿Qué aprenderé en «Analizar JSON»?
Convierta texto en valores JSON Practicas Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?
No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming 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 «Analizar JSON»?
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 Scala for Backend Engineering & Functional Programming?
Sí. Cada lección de Scala for Backend Engineering & Functional Programming 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.