scala - Scala 中具有默认值的通用类型解析

Question

我正在寻找一种通用的函数方式来在 Scala 字符串和任何数字类型之间进行转换。我需要在无法传递默认值的情况下。

例如，我需要从 String 转换为 Int 但以防 String 到 Int 的转换失败。我需要在没有 throws java.lang.NumberFormatException 的情况下传递默认值。我尝试了 this 方式，但没有得到我的想法，因为我需要它 通用 以及 默认 值以防万一

Answer 1

编辑 :我更新了解决方案以从任何类型解析为任何类型。这使得基于所请求问题的解决方案更加通用。我认为您可以使用 Scala 函数方式来拥有泛型类型 [T] 但您需要将其拆分为两部分。

首先实现从任何类型 [U] 解析到的解析类型
任何类型 [T] 。 parseTypes 使用 Scala 函数方式将函数 canBuildFrom 作为参数。然后根据此函数的输出，您将检查它是否正确解析或是否有异常。此外，如果解析失败，您可以传递一个默认参数。

  def parseTypes[T,U](str: U, canBuildFrom: U ⇒ T): Either[java.lang.NumberFormatException, T] =
    Try(canBuildFrom(str)).map(Right(_)).getOrElse {
      Left(new java.lang.NumberFormatException(str.toString))
    }

  def safeParse[T,U](attributeValue: U, canBuildFrom: U ⇒ T, defaultValue: T): T = {
    parseTypes(attributeValue, canBuildFrom) match {
      case Right(x) ⇒ x
      case Left(x)  ⇒ defaultValue
      case _        ⇒ defaultValue
    }
  }


  def safeParseDoubleToBigDecimal(attributeValue: Double): BigDecimal = safeParse[BigDecimal,Double](attributeValue, toBigDecimal, 0.0)

您可以使用它将字符串解析为 Int、Double 和 Decimal，如下所示:

  def safeParseStringToInt(attributeValue: String): Int = safeParse[Int,String](attributeValue, _.toInt, 0)

  def safeParseStringToDouble(attributeValue: String): Double = safeParse[Double ,String](attributeValue, _.toDouble, 0.0)

  def safeParseStringToBigDecimal(attributeValue: String): BigDecimal = safeParse[BigDecimal ,String](attributeValue, BigDecimal(_), 0.0)
  // example of usage
  val x:Int = safeParseStringToInt("123",0)
  val y:Int = safeParseStringToInt("aaa",0)

更新:我更新了这个答案，因为我意识到@Dima 的答案在某种程度上比我的答案更实用，更好我添加了下面从@Dima 的答案复制的答案作为我的答案标记为正确答案。

 trait ParseIt[T] {
     protected def parse(s: String): T
     def apply(s: String) = Try(parse(s)).toOption
 }

 implicit object ParseInt extends ParseIt[Int] {
   protected def parse(s: String) = s.toInt
 }

 implicit object ParseDouble extends ParseIt[Double] {
   protected def parse(s: String) = s.toDouble
 }
 // etc ...

 def parse[T : ParseIt](s: String, orElse: => T) = 
   implicitly[ParseIt[T]](s).getOrElse(orElse)

 val n: Int = parse("123", 0)
 val d: Double = parse("123", 0.0)