什么`JObject(rec)< - someJArray`意味着内在的理解

Question

我正在学习Json4s库.

我有一个像这样的json片段:

{
    "records":[
        {
            "name":"John Derp",
            "address":"Jem Street 21"
        },
        {
            "name":"Scala Jo",
            "address":"in my sweet dream"
        }
    ]
}

而且,我有Scala代码,它将json字符串转换为List of Maps,如下所示:

import org.json4s._
import org.json4s.JsonAST._
import org.json4s.native.JsonParser

  val json = JsonParser.parse( """{"records":[{"name":"John Derp","address":"Jem Street 21"},{"name":"Scala Jo","address":"in my sweet dream"}]}""")

  val records: List[Map[String, Any]] = for {
    JObject(rec) <- json \ "records"
    JField("name", JString(name)) <- rec
    JField("address", JString(address)) <- rec
  } yield Map("name" -> name, "address" -> address)

  println(records)

records屏幕的输出给出了:

列表(地图(名称 - > John Derp,地址 - > Jem Street 21),地图(名称 - > Scala Jo,地址 - >在我的甜蜜梦想中))

我想了解for循环内部的线条是什么意思.例如,这一行的含义是什么:

JObject(rec) <- json \ "records"

我知道json \ "records"生成一个JArray对象,但为什么它会JObject(rec)在左边生成<-？JObject(rec)语法是什么意思？rec变量来自哪里？是否JObject(rec)意味着JObject从rec输入中实例化一个新类？

顺便说一下,我有一个Java编程背景,所以如果你能告诉我上面循环的Java等效代码也会有所帮助.

Answer 1

您具有以下类型层次结构:

  sealed abstract class JValue {
    def \(nameToFind: String): JValue = ???
    def filter(p: (JValue) => Boolean): List[JValue] = ???
  }

  case class JObject(val obj: List[JField]) extends JValue
  case class JField(val name: String, val value: JValue) extends JValue
  case class JString(val s: String) extends JValue
  case class JArray(val arr: List[JValue]) extends JValue {
    override def filter(p: (JValue) => Boolean): List[JValue] = 
      arr.filter(p)
  }

您的JSON解析器返回以下对象:

  object JsonParser {
    def parse(s: String): JValue = {
      new JValue {
        override def \(nameToFind: String): JValue =
          JArray(List(
            JObject(List(
              JField("name", JString("John Derp")),
              JField("address", JString("Jem Street 21")))),
            JObject(List(
              JField("name", JString("Scala Jo")),
              JField("address", JString("in my sweet dream"))))))
      }
    }
  }

  val json = JsonParser.parse("Your JSON")

在引擎盖下Scala编译器生成以下内容:

  val res = (json \ "records")
    .filter(_.isInstanceOf[JObject])
    .flatMap { x =>
      x match {
        case JObject(obj) => //
          obj //
            .withFilter(f => f match {
              case JField("name", _) => true
              case _                 => false
            }) //
            .flatMap(n => obj.withFilter(f => f match {
              case JField("address", _) => true
              case _                    => false
            }).map(a => Map(
              "name" -> (n.value match { case JString(name) => name }),
              "address" -> (a.value match { case JString(address) => address }))))
      }
    }

第一行JObject(rec) <- json \ "records"是可能的,因为JArray.filter返回List[JValue](即List[JObject]).这里List[JValue]映射的每个值都JObject(rec)带有模式匹配.

其余的调用是一系列flatMap和map(这就是Scala for comprehensions的工作方式)和模式匹配.

我使用了Scala 2.11.4.

当然,match上面的表达式是使用一系列类型检查和强制转换来实现的.

更新:

当您使用Json4s库时,隐式转换JValue为org.json4s.MonadicJValue.见package object json4s:

implicit def jvalue2monadic(jv: JValue) = new MonadicJValue(jv)

此转换用于此处:JObject(rec) <- json \ "records".首先,json被转换成MonadicJValue,然后def \("records")被施加,然后def filter被用在结果def \被JValue,然后它再次隐式转换为MonadicJValue,然后def filter的MonadicJValue被使用.结果MonadicJValue.filter是List[JValue].之后执行上述步骤.

Answer 2

你正在使用Scala进行理解,我相信很多困惑都是关于理解如何运作的.这是Scala语法,用于以简洁的方式访问monad的map,flatMap和filter方法,以迭代集合.你需要对monad和理解有所了解才能完全理解这一点.该斯卡拉文档可以帮助,所以会为"斯卡拉理解"的搜索.您还需要了解Scala中的提取器.

你问过这条线的含义:

JObject(rec) <- json \ "records"

这是理解的一部分.

你的陈述:

我知道json \"records"会产生一个JArray对象,

有点不正确.\ function List[JSObject]从解析器结果中提取a ,json

但是为什么它在< - ？左边的JObject(rec)中被取出？

在json \ "records"使用json4s提取\选择JSON数据的"记录"构件和产生List[JObject].在<-为"摘自"可以被读取,并暗示你迭代的列表.列表的元素具有类型JObject,构造JObject(rec)应用提取器来创建一个值,该值rec保存JObject(其字段)的内容.

怎么会在< - ？左边的JObject(rec)中取出它？

这是用于迭代集合的Scala语法.例如,我们也可以写:

for (x <- 1 to 10)

这只会给我们1到10的值x.在您的示例中,我们使用类似的迭代但是在JObject列表的内容上.

JObject(rec)是什么意思？

这是一个Scala提取器.如果查看json4s代码,您会发现JObject的定义如下:

case class JObject(obj: List[JField]) extends JValue

当我们在Scala中有一个case类时,会自动定义两个方法:apply和unapply.JObject(rec)then 的意思是调用unapply方法并生成一个值,rec该值对应obj于JObject构造函数中的值(apply方法).所以,rec将有类型List[JField].

rec变量来自哪里？

它来自于简单地使用它并被声明为objJObject的apply方法的参数的占位符.

JObject(rec)是否意味着从rec输入实例化新的JObject类？

不,它没有.它的出现是因为JArray json \ "records"只包含JObject值.

所以,解释一下:

JObject(rec) <- json \ "records"

我们可以用英文写下面的伪代码:

在解析的json中找到"记录"作为JArray并迭代它们.JArray的元素应该是JObject类型.将每个JObject的"obj"字段作为JField列表拉出,并将其分配给名为"rec"的值.

希望这能使所有这一切更清楚一点？

如果你能告诉我上面循环的Java等效代码,它也会有所帮助.

当然,这可以做到,但这比我愿意在这里贡献的工作要多得多.您可以做的一件事是使用Scala编译代码,找到关联的.class文件,并将它们反编译为Java.对于您来说,学习Scala简化Java编程的程度可能非常有益.:)

为什么我不能这样做？for(rec < - json \"records",所以rec成为JObject.在< - ？左边的JObject(rec)是什么原因？

你可以!但是,您需要获取JObject的内容.你可以用这种方式写出for comprehension:

val records: List[Map[String, Any]] = for {
    obj: JObject <- json \ "records"
    rec = obj.obj
    JField("name", JString(name)) <- rec
    JField("address", JString(address)) <- rec
  } yield Map("name" -> name, "address" -> address)

它具有相同的含义,但它更长.

我只想了解N(x)模式的含义,因为我只看到过(x < - y模式之前).

如上所述,这是一个提取器,它只是使用为案例类自动创建的unapply方法.类似的事情是在Scala的case语句中完成的.

更新: 您提供的代码不能为我编译针对3.2.11版本的json4s-native.这个导入:

import org.json4s.JsonAST._

这个导入是多余的:

import org.json4s._

这样JObject定义了两次.如果我删除JsonAST导入,那么它编译就好了.

为了进一步测试,我将你的代码放在一个scala文件中,如下所示:

package example

import org.json4s._
// import org.json4s.JsonAST._
import org.json4s.native.JsonParser

class ForComprehension {
  val json = JsonParser.parse(
    """{
      |"records":[
      |{"name":"John Derp","address":"Jem Street 21"},
      |{"name":"Scala Jo","address":"in my sweet dream"}
      |]}""".stripMargin
  )

  val records: List[Map[String, Any]] = for {
    JObject(rec) <- json \ "records"
    JField("name", JString(name)) <- rec
    JField("address", JString(address)) <- rec
  } yield Map("name" -> name, "address" -> address)

  println(records)
}

然后开始Scala REPL会话调查:

scala> import example.ForComprehension
import example.ForComprehension

scala> val x = new ForComprehension
List(Map(name -> John Derp, address -> Jem Street 21), Map(name -> Scala Jo, address -> in my sweet dream))
x: example.ForComprehension = example.ForComprehension@5f9cbb71

scala> val obj = x.json \ "records"
obj: org.json4s.JValue = JArray(List(JObject(List((name,JString(John Derp)), (address,JString(Jem Street 21)))), JObject(List((name,JString(Scala Jo)), (address,JString(in my sweet dream))))))

scala> for (a <- obj) yield { a }
res1: org.json4s.JValue = JArray(List(JObject(List((name,JString(John Derp)), (address,JString(Jem Street 21)))), JObject(List((name,JString(Scala Jo)), (address,JString(in my sweet dream))))))

scala> import org.json4s.JsonAST.JObject
for ( JObject(rec) <- obj ) yield { rec }
import org.json4s.JsonAST.JObject

scala> res2: List[List[org.json4s.JsonAST.JField]] = List(List((name,JString(John Derp)), (address,JString(Jem Street 21))), List((name,JString(Scala Jo)), (address,JString(in my sweet dream))))

所以:

• 你是对的,\ _运算符的结果是JArray
• JArray上的"迭代"只是将整个数组视为列表中的唯一值
• 必须有从JArray到JObject的隐式转换,允许提取器将JArray的内容作为List [JField]生成.
• 一旦所有内容都是List,for comprehension就会正常进行.

希望有助于您理解这一点.

有关分配中模式匹配的更多信息,请尝试此博客

更新#2:我在这里挖了一点,发现隐含的转换.罪魁祸首是\运营商.要了解如何json \ "records"变成monadic iterable的东西,你必须看看这段代码:

• org.json4s包对象:该行声明从JValue到的隐式转换MonadicJValue.那是什么MonadicJValue？
• org.json4s.MonadicJValue:这定义了使JValues在for comprehension中可迭代的所有东西:filter,map,flatMap,还提供了\和\\类似XPath的运算符

因此,基本上,使用\ _运算符会导致以下操作序列: - 将json(JValue)隐式转换为MonadicJValue - 在MonadicJValue中应用\运算符以生成JArray("记录") - 隐式转换JArray进入MonadicJValue - 使用MonadicJValue.filter和MonadicJValue.map方法实现for comprehension