web-dev-qa-db-ja.com

Scalaで正規表現を使用してパターンマッチする方法は？

単語の最初の文字と、「ABC」などのグループ内の文字の1つとの一致を見つけたいと思います。擬似コードでは、これは次のようになります。

case Process(Word) =>
   Word.firstLetter match {
      case([a-c][A-C]) =>
      case _ =>
   }
}

しかし、JavaではなくScalaの最初の文字を取得するにはどうすればよいですか？正規表現を適切に表現するにはどうすればよいですか？ ケースクラス 内でこれを行うことは可能ですか？

regexscalapattern-matching
118
Bruce Ferguson

正規表現はエクストラクターを定義するため、これを行うことができますが、最初に正規表現パターンを定義する必要があります。これをテストするためのScala REPLへのアクセス権はありませんが、このようなものは機能するはずです。

val Pattern = "([a-cA-C])".r
Word.firstLetter match {
   case Pattern(c) => c bound to capture group here
   case _ =>
}
227
asm

バージョン2.10以降、Scalaの文字列補間機能を使用できます。

implicit class Regex(sc: StringContext) {
  def r = new util.matching.Regex(sc.parts.mkString, sc.parts.tail.map(_ => "x"): _*)
}

scala> "123" match { case r"\d+" => true case _ => false }
res34: Boolean = true

さらに良いのは、正規表現グループをバインドできることです。

scala> "123" match { case r"(\d+)$d" => d.toInt case _ => 0 }
res36: Int = 123

scala> "10+15" match { case r"(\d\d)${first}\+(\d\d)${second}" => first.toInt+second.toInt case _ => 0 }
res38: Int = 25

より詳細なバインディングメカニズムを設定することもできます。

scala> object Doubler { def unapply(s: String) = Some(s.toInt*2) }
defined module Doubler

scala> "10" match { case r"(\d\d)${Doubler(d)}" => d case _ => 0 }
res40: Int = 20

scala> object isPositive { def unapply(s: String) = s.toInt >= 0 }
defined module isPositive

scala> "10" match { case r"(\d\d)${d @ isPositive()}" => d.toInt case _ => 0 }
res56: Int = 10

Dynamicで可能なことに関する印象的な例は、ブログ投稿Type Dynamicの紹介に示されています。

object T {

  class RegexpExtractor(params: List[String]) {
    def unapplySeq(str: String) =
      params.headOption flatMap (_.r unapplySeq str)
  }

  class StartsWithExtractor(params: List[String]) {
    def unapply(str: String) =
      params.headOption filter (str startsWith _) map (_ => str)
  }

  class MapExtractor(keys: List[String]) {
    def unapplySeq[T](map: Map[String, T]) =
      Some(keys.map(map get _))
  }

  import scala.language.dynamics

  class ExtractorParams(params: List[String]) extends Dynamic {
    val Map = new MapExtractor(params)
    val StartsWith = new StartsWithExtractor(params)
    val Regexp = new RegexpExtractor(params)

    def selectDynamic(name: String) =
      new ExtractorParams(params :+ name)
  }

  object p extends ExtractorParams(Nil)

  Map("firstName" -> "John", "lastName" -> "Doe") match {
    case p.firstName.lastName.Map(
          Some(p.Jo.StartsWith(fn)),
          Some(p.`.*(\\w)$`.Regexp(lastChar))) =>
      println(s"Match! $fn ...$lastChar")
    case _ => println("nope")
  }
}
115
kiritsuku

Delnanが指摘したように、Scalaのmatchキーワードは正規表現とは関係ありません。文字列が正規表現に一致するかどうかを調べるには、String.matchesメソッドを使用できます。文字列が小文字で大文字、a、bまたはcで始まるかどうかを調べるには、正規表現は次のようになります。

Word.matches("[a-cA-C].*")

この正規表現は、「a、b、c、A、B、またはCのいずれかの文字に続いて何か」と読むことができます（.は「任意の文字」を意味し、*は「0回以上」を意味します、「。*」は任意の文字列です）。

48
sepp2k

Andrew's answer を少し拡張するには：正規表現がエクストラクターを定義するという事実は、Scalaのパターンマッチングを使用して、正規表現と一致する部分文字列を非常にうまく分解するために使用できます。

val Process = """([a-cA-C])([^\s]+)""".r // define first, rest is non-space
for (p <- Process findAllIn "aha bah Cah dah") p match {
  case Process("b", _) => println("first: 'a', some rest")
  case Process(_, rest) => println("some first, rest: " + rest)
  // etc.
}
24
Fabian Steeg

String.matchesは、正規表現の意味でパターンマッチングを行う方法です。

ただし、便利な点として、実際のScalaコードのWord.firstLetterは次のようになります。

Word(0)

Scalaは文字列をCharのシーケンスとして扱うため、何らかの理由で文字列の最初の文字を明示的に取得して一致させたい場合は、次のようなものを使用できます。

"Cat"(0).toString.matches("[a-cA-C]")
res10: Boolean = true

正規表現のパターンマッチングを行う一般的な方法としてこれを提案しているわけではありませんが、最初に文字列の最初の文字を見つけてから正規表現と照合するという提案されたアプローチと一致しています。

編集：明確にするために、私がこれを行う方法は、他の人が言ったように：

"Cat".matches("^[a-cA-C].*")
res14: Boolean = true

最初の擬似コードに可能な限り近い例を示したいだけです。乾杯！

8
Janx

@AndrewMyersの答えからのアプローチは、全体文字列を正規表現に一致させ、^および$を使用して文字列の両端に正規表現を固定する効果があることに注意してください。 。例：

scala> val MY_RE = "(foo|bar).*".r
MY_RE: scala.util.matching.Regex = (foo|bar).*

scala> val result = "foo123" match { case MY_RE(m) => m; case _ => "No match" }
result: String = foo

scala> val result = "baz123" match { case MY_RE(m) => m; case _ => "No match" }
result: String = No match

scala> val result = "abcfoo123" match { case MY_RE(m) => m; case _ => "No match" }
result: String = No match

最後に.*なし：

scala> val MY_RE2 = "(foo|bar)".r
MY_RE2: scala.util.matching.Regex = (foo|bar)

scala> val result = "foo123" match { case MY_RE2(m) => m; case _ => "No match" }
result: String = No match
8
Mikhail at YugaByte

最初に、正規表現を個別に使用できることを知っておく必要があります。以下に例を示します。

import scala.util.matching.Regex
val pattern = "Scala".r // <=> val pattern = new Regex("Scala")
val str = "Scala is very cool"
val result = pattern findFirstIn str
result match {
  case Some(v) => println(v)
  case _ =>
} // output: Scala

次に、正規表現とパターンマッチングを組み合わせることは非常に強力であることに注意してください。以下に簡単な例を示します。

val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r
"2014-11-20" match {
  case date(year, month, day) => "hello"
} // output: hello

実際、正規表現自体はすでに非常に強力です。行う必要があるのは、Scalaでより強力にすることだけです。 Scala Documentのその他の例を次に示します。 http://www.scala-lang.org/files/archive/api/current/index.html#scala.util.matching.Regex

6
Haimei