scala之正则表达式（二）内部匹配函数

1、scala解析正则表达式步骤

以下面表达为例：

val dateP1 = new scala.util.matching.Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day")

图1：提取匹配信息

在上面的基础上我们在来做一些事情，如下：

val terday = "terday is 2016-8-2"
dateP1 findAllIn terday toList

2、findAllIn函数

功能：把全部的匹配值找出

def findAllIn(source: java.lang.CharSequence) = new Regex.MatchIterator(source, this, groupNames)

3、findFirstIn函数

功能：把第一个的匹配值找出

def findFirstIn(source: java.lang.CharSequence): Option[String] = {
val m = pattern.matcher(source)
if (m.find) Some(m.group) else None
}

4、findAllMatchIn函数

def findAllMatchIn(source: java.lang.CharSequence): Iterator[Match] = {
val matchIterator = findAllIn(source)
new Iterator[Match] {
def hasNext = matchIterator.hasNext
def next: Match = {
matchIterator.next;
new Match(matchIterator.source, matchIterator.matcher, matchIterator.groupNames).force
}
}
}

5、findPrefixOf函数

功能：找出前缀为正则表达式

def findPrefixOf(source: java.lang.CharSequence): Option[String] = {
val m = pattern.matcher(source)
if (m.lookingAt) Some(m.group) else None
}

6、findPrefixMatchOf函数

def findPrefixMatchOf(source: java.lang.CharSequence): Option[Match] = {
val m = pattern.matcher(source)
if (m.lookingAt) Some(new Match(source, m, groupNames)) else None
}

比较

1、findAllIn和findAllMatchIn的区别

也就是返回类型Option[Match]和Option[String]的区别

(1)类型上的区别



可以说findAllMatchIn比findAllIn更加抽象，功能更加多样，findAllMatchIn可以在返回类型Match中可以增加一些操作

比如从那个位置开始，那个位置结束的。并可以提取他们的值。

以下是 返回Option[Match]可以有的操作函数：

traitMatchData {

/** The source from where the match originated */
val source: java.lang.CharSequence

/** The names of the groups, or some empty sequence if one defined */
val groupNames: Seq[String]

/** The number of subgroups in the pattern (not all of these need to match!) */
def groupCount: Int

/** The index of the first matched character, or -1 if nothing was matched */
def start: Int

/** The index of the first matched character in group `i`,
*  or -1 if nothing was matched for that group */
def start(i: Int): Int

/** The index of the last matched character, or -1 if nothing was matched */
def end: Int

/** The index following the last matched character in group `i`,
*  or -1 if nothing was matched for that group */
def end(i: Int): Int

/** The matched string, or `null` if nothing was matched */
def matched: String =
if (start >= 0) source.subSequence(start, end).toString
else null
/** The matched string in group `i`,
*  or `null` if nothing was matched */
def group(i: Int): String =
if (start(i) >= 0) source.subSequence(start(i), end(i)).toString
else null
/** All matched subgroups, i.e. not including group(0) */
def subgroups: List[String] = (1 to groupCount).toList map group

/** The char sequence before first character of match,
*  or `null` if nothing was matched */
def before: java.lang.CharSequence =
if (start >= 0) source.subSequence(0, start)
else null
/** The char sequence before first character of match in group `i`,
*  or `null` if nothing was matched for that group  */
def before(i: Int): java.lang.CharSequence =
if (start(i) >= 0) source.subSequence(0, start(i))
else null
/** Returns char sequence after last character of match,
*  or `null` if nothing was matched */
def after: java.lang.CharSequence =
if (end >= 0) source.subSequence(end, source.length)
else null
/** The char sequence after last character of match in group `i`,
*  or `null` if nothing was matched for that group  */
def after(i: Int): java.lang.CharSequence =
if (end(i) >= 0) source.subSequence(end(i), source.length)
else null
  private lazy val nameToIndex: Map[String, Int] = Map[String, Int]() ++ ("" :: groupNames.toList).zipWithIndex

/** Returns the group with given name
*
*  @param id The group name
*  @return   The requested group
*  @throws   NoSuchElementException if the requested group name is not defined
*/
def group(id: String): String = nameToIndex.get(id) match {
case None => throw new NoSuchElementException("group name "+id+" not defined")
case Some(index) => group(index)
}

/** The matched string; equivalent to `matched.toString` */
override def toString = matched

}