假设我需要解码看起来如下所示的JSON数组，其中开头有几个字段，一些任意数量的同类元素，然后是其他一些字段：
[ "Foo", "McBar", true, false, false, false, true, 137 ]
我不知道为什么有人会选择像这样编码他们的数据，但人们做了奇怪的事情，并且假设在这种情况下我只需要处理它。
我想将这个JSON解码为这样的案例类：
case class Foo(firstName: String, lastName: String, age: Int, stuff: List[Boolean])
我们可以这样写：
import cats.syntax.either._
import io.circe.{ Decoder, DecodingFailure, Json }
implicit val fooDecoder: Decoder[Foo] = Decoder.instance { c =>
c.focus.flatMap(_.asArray) match {
case Some(fnJ +: lnJ +: rest) =>
rest.reverse match {
case ageJ +: stuffJ =>
for {
fn <- fnJ.as[String]
ln <- lnJ.as[String]
age <- ageJ.as[Int]
stuff <- Json.fromValues(stuffJ.reverse).as[List[Boolean]]
} yield Foo(fn, ln, age, stuff)
case _ => Left(DecodingFailure("Foo", c.history))
}
case None => Left(DecodingFailure("Foo", c.history))
}
}
......有效：
scala> fooDecoder.decodeJson(json"""[ "Foo", "McBar", true, false, 137 ]""")
res3: io.circe.Decoder.Result[Foo] = Right(Foo(Foo,McBar,137,List(true, false)))
但是，这太可怕了。此外，错误消息完全无用：
scala> fooDecoder.decodeJson(json"""[ "Foo", "McBar", true, false ]""")
res4: io.circe.Decoder.Result[Foo] = Left(DecodingFailure(Int, List()))
当然有一种方法可以做到这一点，不涉及在游标之间来回切换 Json 价值观，在我们的错误信息中抛弃历史，一般只是一个眼睛？
一些上下文：关于编写这样的自定义JSON数组解码器的问题经常出现（例如 今天早上）。有关如何执行此操作的具体细节可能会在即将发布的版本中更改（尽管API类似;请参阅 这个实验项目 对于一些细节），所以我真的不想花很多时间在文档中添加这样的例子，但它足以让我觉得它确实值得一个Stack Overflow Q＆A。
使用游标
有一个更好的方法！您可以通过直接使用游标一直保持有用的错误消息来更简洁地编写此内容：
case class Foo(firstName: String, lastName: String, age: Int, stuff: List[Boolean])
import cats.syntax.either._
import io.circe.Decoder
implicit val fooDecoder: Decoder[Foo] = Decoder.instance { c =>
val fnC = c.downArray
for {
fn <- fnC.as[String]
lnC = fnC.deleteGoRight
ln <- lnC.as[String]
ageC = lnC.deleteGoLast
age <- ageC.as[Int]
stuffC = ageC.delete
stuff <- stuffC.as[List[Boolean]]
} yield Foo(fn, ln, age, stuff)
}
这也有效：
scala> fooDecoder.decodeJson(json"""[ "Foo", "McBar", true, false, 137 ]""")
res0: io.circe.Decoder.Result[Foo] = Right(Foo(Foo,McBar,137,List(true, false)))
但它也告诉我们错误发生的地方：
scala> fooDecoder.decodeJson(json"""[ "Foo", "McBar", true, false ]""")
res1: io.circe.Decoder.Result[Foo] = Left(DecodingFailure(Int, List(DeleteGoLast, DeleteGoRight, DownArray)))
它也更短，更具声明性，并且不需要不可读的嵌套。
怎么运行的
关键的想法是我们交错“阅读”操作（ .as[X] 通过导航/修改操作调用光标）（downArray 和三个 delete 方法调用）。
当我们开始时， c 是一个 HCursor 我们希望指向阵列。 c.downArray 将光标移动到数组中的第一个元素。如果输入根本不是数组，或者是一个空数组，则此操作将失败，我们将收到有用的错误消息。如果成功，第一行 for-comprehension将尝试将第一个元素解码为字符串，并将光标指向第一个元素。
第二行 for-comprehension说“好吧，我们已经完成了第一个元素，所以让我们忘记它并转移到第二个元素”。该 delete 方法名称的一部分并不意味着它实际上是在改变任何东西 - 在任何情况下，用户都无法以任何方式改变任何用户可以观察到的东西 - 它只是意味着该元素将不会对结果游标的任何未来操作可用。
第三行尝试将原始JSON数组中的第二个元素（现在是新游标中的第一个元素）解码为字符串。完成后，第四行“删除”该元素并移动到数组的末尾，然后第五行尝试将该最终元素解码为 Int。
下一行可能是最有趣的：
stuffC = ageC.delete
这说，好吧，我们在JSON数组的修改视图中的最后一个元素（之前我们删除了前两个元素）。现在我们删除最后一个元素并移动光标 向上 所以它指向整个（修改过的）数组，然后我们可以将其解码为布尔列表，我们就完成了。
更多的错误积累
实际上你可以写一个更简洁的方法：
import cats.syntax.all._
import io.circe.Decoder
implicit val fooDecoder: Decoder[Foo] = (
Decoder[String].prepare(_.downArray),
Decoder[String].prepare(_.downArray.deleteGoRight),
Decoder[Int].prepare(_.downArray.deleteGoLast),
Decoder[List[Boolean]].prepare(_.downArray.deleteGoRight.deleteGoLast.delete)
).map4(Foo)
这也可以工作，并且它还有一个额外的好处，即如果多个成员的解码失败，您可以同时获得所有故障的错误消息。例如，如果我们有这样的东西，我们应该期望三个错误（对于非字符串名字，非整数年龄和非布尔填充值）：
val bad = """[["Foo"], "McBar", true, "true", false, 13.7 ]"""
val badResult = io.circe.jawn.decodeAccumulating[Foo](bad)
这就是我们所看到的（连同每个故障的具体位置信息）：
scala> badResult.leftMap(_.map(println))
DecodingFailure(String, List(DownArray))
DecodingFailure(Int, List(DeleteGoLast, DownArray))
DecodingFailure([A]List[A], List(MoveRight, DownArray, DeleteGoParent, DeleteGoLast, DeleteGoRight, DownArray))
您应该更喜欢这两种方法中的哪一种是品味问题以及您是否关心错误累积 - 我个人认为第一种方法更具可读性。