Scala Regex unia

Question

W Ruby, jeśli mam dwóch wyrażeń regularnych, mam możliwość stworzenia innego wyrażenia regularnego tak:

a = /\d+/ # Matches digits 
b = /\s+/ # Matches whitespaces 
c = Regexp.union(a, b) # Matches sequences that consist only of digits or only of whitespaces 

chcę zrobić to samo w Scala, ale nie znaleźliśmy się jak mogłem to zrobić. Zauważ, że nie pytam o składnię, aby utworzyć połączenie klas znaków, takich jak (\d+)|(\s+) w poprzednim przykładzie. Naprawdę szukam możliwości utworzenia nowego Regexp z dwóch danych Regexp.

Właściwie, w końcu nie zrobię tego tylko dla dwóch Regeksów, ale dużej liczby. Nie dbam o grupowanie ani nic, po prostu chcę wiedzieć, czy ciąg pasuje do jednej z listy podanych Regeksów. Mogłem po prostu sprawdzić wszystkie z nich w pętli, ale to zbyt nieefektywne, dlatego potrzebuję jednego Regexp, aby sprawdzić związek.

Answer 1

Scala używa mechanizmu regex Java, który opiera się na klasie java.util.regex.Pattern. Pattern ma dokładnie jedną metodę, która może utworzyć regex:

public static Pattern compile(String regex) 

to wszystko, i Scala nie daje żadnych istotnych ulepszeń.

Ale jedno można zrobić, to skorzystać z wbudowanego w unioning w sprawozdaniach meczu, tutaj pokazane z przechwytywanie grup w przypadku, gdy chcesz wyciągnąć coś z napisu:

val Dig = """(\d+)""".r 
val Wsp = """(\s+)""".r 

scala> "45" match { case Dig(_) | Wsp(_) => println("found"); case _ => } 

znaleźć

scala> " " match { case Dig(_) | Wsp(_) => println("found"); case _ => } 

Znaleziono

Jeśli naprawdę chcesz połączyć wyrażenie regularne, musisz to zrobić na poziomie ciągu znaków. Możesz pobrać java Pattern z regex Scala z .pattern, a następnie .pattern następnie dostaje ciąg. Większość Wyrażenia regularne mogą być pakowane bezpiecznie w (?:) uzyskać blok non-przechwytywania, więc można połączyć tak:

val Both = ("(?:"+Dig.pattern.pattern+")|(?:"+Wsp.pattern.pattern+")").r 

Jednakże wszelkie przechwytywanie grupy wewnątrz będzie zarówno być reprezentowane, ale nie wykorzystane oddział będzie być null (nie dokładnie to dobry sposób, aby napisać idiomatyczne Scala, ale w każdym razie, to co używa Java):

scala> "2" match { case Both(d,w) => if (w!=null) println("white") else println(d) } 
2 

scala> " " match { case Both(d,w) => if (w!=null) println("white") else println(d) } 
white 

Answer 2

Jeśli chcesz połączyć i ponownego użycia części regex pisałem REL biblioteka/DSL, który nie tylko że. Przykład użycia dla ciebie sprawy:

import fr.splayce.rel._ 
import Implicits._ 

val a: RE = "\\d+" 
val b: RE = "\\s+" 
val c: RE = a | b 

c ma r sposób, aby uzyskać regex obiekt. Jest również w wersji Implicits, więc można go używać jako wyrażeń regularnych, na przykład c findAllIn someText. Jeśli zajdzie taka potrzeba, automatycznie zapakuje a i b w grupy niezapisujące.

Jeśli masz kolekcję regexes, można po prostu zrobić reduceLeft:

val regexes: List[RE] = List("a", "b", "c") 
regexes.reduceLeft(_ | _) 

Na marginesie:

• jeśli importować Symbols._, masz krótkie notacje dla rzeczy jak \d i \s
• implementuje większość zwykłych operacji regex w celu uzyskania maksymalnej przydatności do użycia

Zatem z REL, można napisać pierwszy przykład bezpośrednio jako:

val c = δ.+ | σ.+ 

Zapewnia również sposoby ponownego użycia i łączą związane wyciągami.

Jeśli wolisz waniliową scala, to nie mam nic do dodania do odpowiedzi Rexa Kerra.

Answer 3

Podczas gdy te odpowiedzi mogą działać, mogą być nieco przestarzałe lub skomplikowane.

val reg1 = "\\d+".r 
val reg2 = "\\s+".r 
val reg3 = s"${reg1}{$reg2}".r 
"123 " match { 
    case reg3(_*) => println("match") 
    case _ => println("no match") 
} 

Answer 4

@akauppi jeśli chcesz listę regexes dopasować dany ciąg można zrobić coś takiego:

val regexes = List("\\d+".r, "\\s+".r, "a".r) 
val single = s"(${regexes.mkString("|")})".r 
"123" match { 
    case single(_*) = println("match") 
    case _ => println("no match") 
} 
// above prints: match 

"123 " match { 
    case single(_*) = println("match") 
    case _ => println("no match") 
} 
// above prints: no match 

Najlepszym sposobem wykorzystania listę regexes jest użycie notacji regex. To naprawdę jest to samo, co powiedzenie: