2

我经常有如下代码

if (operator == Equal || operator == Missing || operator == Unknown) {

为了使它不那么冗长并且更具可读性，有时我会发出：

if (List(Equal, Missing, Unknown).contains(operator)) {

我知道我也可以像这样发出模式匹配

operator match {
  case Equal | Missing | Unknown => {

这带来了另一个层次的嵌套括号

我想知道是否有某种方法

if (operator.isOneOf(List(Equal, Missing, Unknown))) {

--

编辑：

展示如何使用此处出现的不同选项：

使用 Set 作为函数

if (Set(1, 2, 3)(3)) {
  "Gotcha"
} else {
  "no luck..."
}

使用 PartialFunction.cond

import PartialFunction.cond

if (cond(3) { case 1 | 2 | 3 => true }) {
  "Gotcha"
} else {
  "no luck..."
}

实现 isOneOf

class ComparableWithIsOneOf[T](val value: T) {
  def isOneOf(values: T*): Boolean = {
    values.contains(value)
  }
}
object Comparison {
  object implicits {
    implicit def AnyToComparableWithIsOneOf[T](value: T): ComparableWithIsOneOf[T] = {
      return new ComparableWithIsOneOf(value)
    }
  }
}

import Comparison.implicits._

if (3.isOneOf(1, 2, 3)) {
  "Gotcha"
} else {
  "no luck..."
}

最后我更喜欢 Set() 版本，但我认为最好是坚持模式匹配，更标准和惯用......

4

4 回答 4

4

你可以写

if (Set(Equal, Missing, Unknown)(operator)) { ...

Set作为一个函数等...

于 2012-09-16T17:01:11.680 回答
2

我们还可以使用 PartialFunction中定义的cond 或 condOpt对您的模式匹配解决方案进行拉皮条：

condOpt(operator) { case Equal | Missing | Unknown =>  ... }
于 2012-09-16T17:04:48.887 回答
2

自己写吧：

scala> implicit class IsOneOf[A](a: A) { def isOneOf(as: A*) = as contains a }
defined class IsOneOf

scala> trait Trait
defined trait Trait

scala> case object Equal extends Trait
defined module Equal

scala> case object Missing extends Trait
defined module Missing

scala> case object Unknown extends Trait
defined module Unknown

scala> case object Else extends Trait
defined module Else

scala> def test(t: Trait) = t.isOneOf(Equal, Missing, Unknown)
test: (t: Trait)Boolean

scala> test(Missing)
res25: Boolean = true

scala> test(Else)
res26: Boolean = false

这也是类型安全的：

scala> 1.isOneOf("")
<console>:12: error: type mismatch;
 found   : String("")
 required: Int
              1.isOneOf("")
                        ^
于 2012-09-16T17:08:42.147 回答
0

我试图实现它，这就是我得到的

首先我用 isOneOf 方法定义一个泛型类，像这样

class ComparableWithIsOneOf[T](val value: T) {
  def isOneOf(values: T*): Boolean = {
    values.contains(value)
  }
}

然后我定义了一个隐式转换器（双重嵌套比较.implicits 只是为了使导入更容易......）

object Comparison {
  object implicits {
    implicit def AnyToComparableWithIsOneOf[T](value: T): ComparableWithIsOneOf[T] = {
      return new ComparableWithIsOneOf(value)
    }
  }
}

要使用它，我只需发出：

import Comparison.implicits._

if (3.isOneOf(1, 2, 3)) {
  "Gotcha"
} else {
  "no luck..."
}

代码不多，结果是类型安全的

反正我觉得还是用模式匹配比较好，感觉比较地道……

于 2012-09-16T17:28:49.140 回答