Analisando JSON
Transforme texto em valores JSON.
Analisando JSON é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.
Por que o Circe?
Circe é uma biblioteca popular de JSON para Scala, construída sobre o ecossistema funcional do cats.
Ela privilegia a segurança de tipos e a imutabilidade: a análise retorna um Either em vez de lançar uma exceção, e a decodificação produz valores tipados em vez de mapas sem tipo.
Nesta lição, você aprenderá a transformar texto JSON bruto no modelo Json do Circe.
Adicionando a dependência
O Circe é distribuído como vários módulos. Para fazer a análise e usar o modelo principal, você precisa de circe-core e circe-parser.
O módulo circe-generic adiciona a derivação automática de codificadores, assunto abordado em lições posteriores.
libraryDependencies ++= Seq(
"io.circe" %% "circe-core" % "0.14.6",
"io.circe" %% "circe-parser" % "0.14.6"
)A função parse
O ponto de entrada para ler JSON é io.circe.parser.parse.
Ela recebe uma String e retorna Either[ParsingFailure, Json]. O lado esquerdo registra erros de sintaxe; o lado direito contém a árvore analisada.
import io.circe.parser._
val result = parse("{\"name\": \"Ada\", \"age\": 36}")
// result: Either[ParsingFailure, Json]Tratando falhas de análise
Como parse retorna um Either, você trata os erros explicitamente com correspondência de padrões ou combinadores, em vez de usar try/catch.
Um ParsingFailure inclui uma mensagem legível que descreve o problema de sintaxe.
parse("{ not valid }") match {
case Right(json) => println(json)
case Left(err) => println(s"Failed: ${err.message}")
}O modelo Json
Um valor analisado com sucesso é um Json — uma árvore imutável que representa um dos seis tipos de JSON: objeto, matriz, texto, número, booleano ou nulo.
Você o inspeciona com predicados como isObject ou percorre sua estrutura com uma dobra.
val json = parse("[1, 2, 3]").getOrElse(Json.Null)
println(json.isArray) // true
println(json.isObject) // falseNavegando com o cursor
Para ler dados aninhados, chame .hcursor em um valor Json. O HCursor é um zíper que permite percorrer a árvore.
Use downField para descer até uma chave de 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)Extraindo valores com as
Depois de se posicionar, .as[A] tenta decodificar o valor em foco para o tipo A.
Ele retorna Either[DecodingFailure, A], portanto uma incompatibilidade de tipos é relatada como um valor, não como uma exceção.
val json = parse("{\"age\": 36}").toOption.get
val age = json.hcursor.downField("age").as[Int]
println(age) // Right(36)parse versus decode
Use parse quando quiser inspecionar manualmente a árvore Json bruta.
Use decode[A] quando quiser ir diretamente de String para um valor tipado A em uma única etapa. Essa operação combina análise e decodificação.
import io.circe.parser.decode
val n: Either[io.circe.Error, Int] =
decode[Int]("42")
println(n) // Right(42)Campos opcionais
O JSON do mundo real frequentemente contém chaves ausentes. O método get[A] do cursor, quando aplicado a um campo acessado, falha se ele estiver ausente, enquanto getOrElse fornece um valor padrão.
Decodificar para Option[A] trata um campo ausente ou nulo como None.
val json = parse("{\"name\": \"Ada\"}").toOption.get
val nick = json.hcursor.get[Option[String]]("nickname")
println(nick) // Right(None)Analisando matrizes
Você pode decodificar uma matriz JSON diretamente para uma coleção Scala solicitando List[A] ou Vector[A].
O Circe mapeia cada elemento e interrompe a operação com um DecodingFailure se algum elemento tiver o tipo incorreto.
import io.circe.parser.decode
val xs = decode[List[Int]]("[1, 2, 3]")
println(xs) // Right(List(1, 2, 3))Formatação legível
Qualquer valor Json pode ser convertido novamente em texto com .noSpaces, para uma saída compacta, ou .spaces2, para uma saída indentada.
Isso preserva os dados analisados e é útil para registrar informações ou depurar.
val json = parse("{\"a\":1,\"b\":2}").toOption.get
println(json.noSpaces)
println(json.spaces2)Verificação rápida
Teste sua compreensão da análise com Circe.
Recapitulação
Você aprendeu a transformar texto JSON no modelo do Circe. parse produz Either[ParsingFailure, Json]; decode[A] vai diretamente para um valor tipado.
O HCursor navega com downField, e .as[A] extrai valores tipados. As falhas são valores, não exceções.
Perguntas Frequentes
A aula “Analisando JSON” é grátis?
Sim — o texto completo de “Analisando JSON” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.
O que vou aprender em “Analisando JSON”?
Transforme texto em valores JSON. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?
Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Analisando JSON”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?
Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.