0Pricing
Scala for Backend Engineering & Functional Programming · Lección

Decodificar en case classes

Asigne JSON a sus tipos

Decodificar en case classes es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 2 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.

Los decodificadores asignan JSON a tipos

Un Decoder[A] sabe leer un valor Json y convertirlo en un tipo de Scala A.

Circe proporciona decodificadores para tipos primitivos y colecciones de forma integrada, y puede crear automáticamente decodificadores para sus propias case classes.

Una case class de destino

Suponga que su API devuelve registros de usuarios. Modele su estructura con una case class cuyos nombres de campo coincidan con las claves JSON.

La coincidencia de nombres permite que Circe derive un decodificador sin configuración manual.

case class User(name: String, age: Int, admin: Boolean)

Derivación automática

Importe io.circe.generic.auto._ y Circe derivará implícitamente un Decoder[User] cuando sea necesario.

A continuación, puede llamar a decode[User] sin código adicional.

import io.circe.generic.auto._
import io.circe.parser.decode

val json = "{\"name\":\"Ada\",\"age\":36,\"admin\":true}"
val user = decode[User](json)
println(user)  // Right(User(Ada,36,true))

Derivación semiautomática

Para obtener tiempos de compilación mejores y un control explícito, use io.circe.generic.semiauto.deriveDecoder.

Defina el decodificador una sola vez, normalmente en el objeto complementario, y reutilice esa única instancia en todas partes.

import io.circe.Decoder
import io.circe.generic.semiauto._

object User {
  implicit val dec: Decoder[User] = deriveDecoder[User]
}

Errores de decodificación

Si falta un campo obligatorio o tiene un tipo incorrecto, la decodificación falla con un DecodingFailure.

El error contiene un historial de operaciones del cursor que señala exactamente qué campo causó el problema.

val bad = decode[User]("{\"name\":\"Ada\"}")
println(bad)
// Left(DecodingFailure at .age: Missing required field)

Campos opcionales en clases

Haga que un campo sea Option[A] cuando la clave JSON pueda faltar o ser nula.

Circe decodifica automáticamente una clave ausente como None, por lo que no necesita un decodificador personalizado solo para admitir opcionalidad.

case class Account(id: Long, nickname: Option[String])

val a = decode[Account]("{\"id\":7}")
println(a)  // Right(Account(7,None))

Valores predeterminados

Los valores predeterminados de una case class pueden completar las claves JSON ausentes, pero solo cuando utiliza una derivación configured que habilite los valores predeterminados.

El módulo circe-generic-extras proporciona esta funcionalidad mediante Configuration.default.withDefaults.

import io.circe.generic.extras._

implicit val cfg: Configuration =
  Configuration.default.withDefaults

@ConfiguredJsonCodec
case class Settings(theme: String = "dark")

Case classes anidadas

La decodificación es composicional: si Circe puede decodificar el tipo de cada campo, también puede decodificar una clase que anide otras case classes.

La derivación recurre automáticamente, por lo que una sola importación gestiona estructuras profundamente anidadas.

case class Address(city: String)
case class Person(name: String, address: Address)

val p = decode[Person](
  "{\"name\":\"Ada\",\"address\":{\"city\":\"London\"}}")
println(p)

Cambiar el nombre de los campos

Cuando las claves JSON difieren de los nombres de Scala, por ejemplo, al usar snake_case, utilice la derivación configurada con Configuration.default.withSnakeCaseMemberNames.

Esto asigna created_at al campo de Scala createdAt sin escribir un decodificador manual.

import io.circe.generic.extras._

implicit val cfg: Configuration =
  Configuration.default.withSnakeCaseMemberNames

@ConfiguredJsonCodec
case class Event(createdAt: String)

Acumular errores

De forma predeterminada, la decodificación falla rápidamente ante el primer error. decodeAccumulating, en cambio, recopila todos los errores en un ValidatedNel.

Esto resulta útil para validar formularios cuando desea informar de todos los problemas a la vez.

import io.circe.Decoder

val result = Decoder[User]
  .decodeAccumulating(json.hcursor)
// Validated[NonEmptyList[DecodingFailure], User]

Elegir un estilo de derivación

Use auto para prototipos rápidos y semiauto para código de producción cuando quiera instancias fijas y compilaciones más rápidas.

Recurra a generic-extras cuando necesite cambiar nombres, usar valores predeterminados o trabajar con discriminadores.

Comprobación rápida

Compruebe lo que ha aprendido sobre la decodificación en case classes.

Repaso

Un Decoder[A] convierte JSON en valores tipados. Use generic.auto o semiauto.deriveDecoder para case classes cuyos nombres coincidan con las claves.

Las claves ausentes decodifican los campos Option como None; generic-extras añade valores predeterminados y cambios de nombre; decodeAccumulating recopila todos los errores.

Preguntas frecuentes

¿La lección «Decodificar en case classes» es gratis?

Sí — el texto completo de «Decodificar en case classes» 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 «Decodificar en case classes»?

Asigne JSON a sus tipos 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 2 de 4.

¿Cuánto tiempo toma la lección «Decodificar en case classes»?

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.

Todas las lecciones de este curso

  1. Analizar JSON
  2. Decodificar en case classes
  3. Codificar en JSON
  4. Codecs personalizados
← Volver a Scala for Backend Engineering & Functional Programming