solo - ¿Cómo verificar si una Cadena coincide completamente con una Regex en Scala?

simplificar expresiones regulares online

Question

Supongamos que tengo un patrón Regex con el que quiero unir muchas cadenas.

val Digit = """/d""".r

Solo quiero comprobar si una cadena determinada coincide por completo con la Regex. ¿Cuál es una forma buena e idiomática de hacer esto en Scala?

Sé que puedo emparejar patrones en Regexes, pero sintácticamente no es muy agradable en este caso, porque no tengo grupos para extraer:

scala> "5" match { case Digit() => true case _ => false }
res4: Boolean = true

O podría recurrir al patrón subyacente de Java:

scala> Digit.pattern.matcher("5").matches
res6: Boolean = true

que tampoco es elegante.

¿Hay una mejor solución?

Answer 1

La respuesta está en la expresión regular:

val Digit = """^/d$""".r

Luego usa uno de los métodos existentes.

Answer 2

No conozco muy bien a Scala, pero parece que puedes hacer lo siguiente:

"5".matches("//d")

Referencias

• http://langref.org/scala/pattern-matching/matching

Answer 3

Para la coincidencia completa, puede usar unapplySeq . Este método intenta hacer coincidir el objetivo (coincidencia completa) y devuelve las coincidencias.

scala> val Digit = """/d""".r
Digit: scala.util.matching.Regex = /d

scala> Digit unapplySeq "1"
res9: Option[List[String]] = Some(List())

scala> Digit unapplySeq "123"
res10: Option[List[String]] = None

scala> Digit unapplySeq "string"
res11: Option[List[String]] = None

Answer 4

Respondiendo a mi propia pregunta usaré el "patrón de proxeneta de mi biblioteca"

object RegexUtils {
  implicit class RichRegex(val underlying: Regex) extends AnyVal {
    def matches(s: String) = underlying.pattern.matcher(s).matches
  }
}

y úsalo así

import RegexUtils._
val Digit = """/d""".r
if (Digit matches "5") println("match")
else println("no match")

a menos que a alguien se le ocurra una mejor solución (estándar).

Notas

• No pedí String para limitar el alcance de los posibles efectos secundarios.

• unapplySeq no lee muy bien en ese contexto.

Answer 5

Utilizando la biblioteca Standard Scala y un patrón de expresiones regulares precompilado y una coincidencia de patrones (que es el estado actual de la escala):

val digit = """(/d)""".r

"2" match {
  case digit( a) => println(a + " is Digit")
  case _ => println("it is something else")
}

más para leer: http://www.scala-lang.org/api/2.12.1/scala/util/matching/index.html

Answer 6

  """/d""".r.unapplySeq("5").isDefined            //> res1: Boolean = true
  """/d""".r.unapplySeq("a").isDefined            //> res2: Boolean = false