从 Scala 中的字符串中读取案例类对象(类似于 Haskell 的 "read" 类型类)

>我想读取一个字符串作为案例类的实例。例如，如果函数被命名为"read"，它将允许我执行以下操作：

case class Person(name: String, age: Int)
val personString: String = "Person(Bob,42)"
val person: Person = read(personString)

这与 Haskell 中的读取类型类的行为相同。

dflemstr 对设置实际read方法的回答更多 - 我将为实际的解析方法回答更多。

我的方法有两个对象可以在 scala 的模式匹配块中使用。 AsInt允许您与表示 Int 的字符串进行匹配，PersonString是Person反序列化的实际实现。

object AsInt {
  def unapply(s: String) = try{ Some(s.toInt) } catch {
    case e: NumberFormatException => None
  }
}
val PersonRegex = "Person\((.*),(\d+)\)".r
object PersonString {
  def unapply(str: String): Option[Person] = str match {
    case PersonRegex(name, AsInt(age)) => Some(Person(name, age))
    case _ => None
  }
}

神奇之处在于unapply方法，scala 有语法糖。因此，使用 PersonString 对象，您可以

val person = PersonString.unapply("Person(Bob,42)")
//  person will be Some(Person("Bob", 42))

或者你可以使用模式匹配块来和这个人一起做一些事情：

"Person(Bob,42)" match {
  case PersonString(person) => println(person.name + " " + person.age)
  case _ => println("Didn't get a person")
}

Scala 没有类型类，在这种情况下，您

甚至无法使用继承自的 trait 来模拟类型类，因为 traits 只表示对象上的方法，这意味着它们必须由类"拥有"，因此您不能将"将字符串作为唯一参数的构造函数"（这是 OOP 语言中可能称为"read"的构造函数）的定义放在 trait 中。

相反，您必须自己模拟类型类。这是这样做的（在注释中等效于Haskell代码）：

// class Read a where read :: String -> a
trait Read[A] { def read(s: String): A }
// instance Read Person where read = ... parser for Person ...
implicit object ReadPerson extends Read[Person] {
  def read(s: String): Person = ... parser for Person ...
}

然后，当您有一个依赖于类型类的方法时，您必须将其指定为隐式上下文：

// readList :: Read a => [String] -> [a]
// readList ss = map read ss
def readList[A: Read] (ss: List[String]): List[A] = {
  val r = implicitly[Read[A]] // Get the class instance of Read for type A
  ss.map(r.read _)
}

为了便于使用，用户可能会想要这样的多态方法：

object read {
  def apply[A: Read](s: String): A = implicitly[Read[A]].read(s)
}

然后可以写：

val person: Person = read[Person]("Person(Bob,42)")

特别是我不知道这种类型的类有任何标准实现。

另外，免责声明：我没有 Scala 编译器，并且多年没有使用该语言，所以我不能保证这段代码可以编译。

从 Scala 2.13 开始，可以通过取消应用字符串插值器来模式匹配 String s：

// case class Person(name: String, age: Int)
"Person(Bob,42)" match { case s"Person($name,$age)" => Person(name, age.toInt) }
// Person("Bob", 42)

请注意，您还可以在提取器中使用 regex es。

在这种情况下，例如，这有助于匹配"Person（Bob，42）"（带有前导空格的年龄）并强制年龄为整数：

val Age = "[ ?*](\d+)".r
"Person(Bob, 42)" match {
  case s"Person($name,${Age(age)})" => Some(Person(name, age.toInt))
  case _ => None
}
// Person = Some(Person(Bob,42))

这个问题的答案有些过时了。Scala已经获得了一些新功能，特别是typeclasses和宏，使这更容易实现。

使用

Scala Pickling 库，您可以序列化/反序列化任意类，以使用各种序列化格式：

import scala.pickling._
import json._
case class Person(name: String, age: Int)
val person1 = Person("Bob", 42)
val str = person1.pickle.value // { tpe: "Person", name: "Bob", age: 42 }
val person2 = JSONPickle(str).unpickle[Person]
assert(person1 == person2) // Works!

序列化程序

/反序列化程序在编译时自动生成，因此无需反射！如果需要使用特定格式（例如案例类toString格式）解析案例类，则可以使用自己的格式扩展此系统。

uPickle 库为这个问题提供了一个解决方案。

Scala使用Java的序列化内容，没有String表示。

相关内容

最新更新

热门标签：