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)
  }
}

次に、暗黙的なコンバーターを定義します（ダブルネストのComparison.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 に答える