Трейт scala.util.matching.UnanchoredRegex

трейт UnanchoredRegex extends Regex

A Regex, который находит первое совпадение при использовании в совпадении с шаблоном.

Конкретные методы

Исходный код

переопределение защищенного метода runMatcher(m: Matcher): Boolean

Исходный код

переопределение метода unanchored: UnanchoredRegex

Унаследованные методы

Исходный код

метод anchored: Regex

Исходный код

метод findAllIn(source: CharSequence): MatchIterator

Возвращает все неперекрывающиеся совпадения этого Regex в заданной последовательности символов в виде scala.util.matching.Regex.MatchIterator, который является специальным scala.collection.Iterator, возвращающим совпадающие строки, но также может быть запрошен для получения дополнительных данных о последнем совпадении, таких как группы захвата и начальная позиция.

A MatchIterator также может быть преобразован в итератор, который возвращает объекты типа scala.util.matching.Regex.Match, как это обычно возвращается findAllMatchIn.

В случае потенциального перекрытия совпадений возвращается первое возможное совпадение, за которым следует следующее совпадение, следующее за входом, потребленным первым совпадением:

val hat  = "hat[^a]+".r
val hathaway = "hathatthattthatttt"
val hats = hat.findAllIn(hathaway).toList                     // List(hath, hattth)
val pos  = hat.findAllMatchIn(hathaway).map(_.start).toList   // List(0, 7)

Для возвращения перекрывающихся совпадений можно сформулировать регулярное выражение с предпросмотром (?=) , которое не потребляет перекрывающуюся область.

val madhatter = "(h)(?=(at[^a]+))".r
val madhats   = madhatter.findAllMatchIn(hathaway).map {
  case madhatter(x,y) => s"$x$y"
}.toList                                       // List(hath, hatth, hattth, hatttt)

Попытка получить информацию о совпадении после исчерпания итератора приводит к java.lang.IllegalStateException. См. scala.util.matching.Regex.MatchIterator для получения подробностей.

for (words <- """\w+""".r findAllIn "A simple example.") yield words

Исходный код

метод findAllMatchIn(source: CharSequence): Iterator[Match]

Возвращает все неперекрывающиеся совпадения этого регулярного выражения в заданной последовательности символов как scala.collection.Iterator объектов scala.util.matching.Regex.Match.

for (words <- """\w+""".r findAllMatchIn "A simple example.") yield words.start

Исходный код

def findFirstIn(source: CharSequence): Option[String]

Возвращает необязательную первую совпадающую строку этого Regex в заданной последовательности символов или None, если совпадения нет.

"""\w+""".r findFirstIn "A simple example." foreach println // prints "A"

Исходный код

def findFirstMatchIn(source: CharSequence): Option[Match]

Возвращает необязательное первое совпадение этого Regex в заданной последовательности символов или None, если оно не существует.

Если совпадение успешно, объект scala.util.matching.Regex.Match можно использовать для получения дополнительных данных.

("""[a-z]""".r findFirstMatchIn "A simple example.") map (_.start) // returns Some(2), the index of the first match in the text

Исходный код

def findPrefixMatchOf(source: CharSequence): Option[Match]

Возвращает необязательное совпадение этого Regex в начале заданной последовательности символов или None, если оно не соответствует никакому префиксу последовательности символов.

В отличие от findFirstMatchIn, этот метод вернёт совпадение только в начале входных данных.

"""\w+""".r findPrefixMatchOf "A simple example." map (_.after) // returns Some(" simple example.")

Исходный код

def findPrefixOf(source: CharSequence): Option[String]

Возвращает необязательное совпадение этого Regex в начале заданной последовательности символов или None, если оно не соответствует никакому префиксу последовательности символов.

В отличие от findFirstIn, этот метод вернёт совпадение только в начале входных данных.

"""\p{Lower}""".r findPrefixOf "A simple example." // returns None, since the text does not begin with a lowercase letter

Исходный код

def matches(source: CharSequence): Boolean

Возвращает, соответствует ли это Regex заданной последовательности символов.

Как и экстракт, этот метод учитывает привязку.

"""\d+""".r matches "123" // returns true

Исходный код

def regex: String

Источник

def replaceAllIn(target: CharSequence, replacer: Match => String): String

Заменяет все совпадения с использованием функции замены. Функция замены принимает scala.util.matching.Regex.Match, чтобы получить дополнительную информацию из совпадения. Например:

import scala.util.matching.Regex
val datePattern = new Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day")
val text = "From 2011-07-15 to 2011-07-17"
val repl = datePattern replaceAllIn (text, m => s"${m group "month"}/${m group "day"}")

В строке замены знак доллара ($) за которым следует число будет интерпретирован как ссылка на группу в совпавшем шаблоне, при этом числа от 1 до 9 соответствуют первым девяти группам, а 0 — всему совпадению. Любой другой символ является ошибкой. Символ обратной косой черты (\) будет интерпретирован как символ экранирования и может использоваться для экранирования знака доллара. Используйте Regex.quoteReplacement для экранирования этих символов.

Источник

def replaceAllIn(target: CharSequence, replacement: String): String

Заменяет все совпадения строкой.

В строке замены знак доллара ($) за которым следует число будет интерпретирован как ссылка на группу в совпавшем шаблоне, при этом числа от 1 до 9 соответствуют первым девяти группам, а 0 — всему совпадению. Любой другой символ является ошибкой. Символ обратной косой черты (\) будет интерпретирован как символ экранирования и может использоваться для экранирования знака доллара. Используйте Regex.quoteReplacement для экранирования этих символов.

"""\d+""".r replaceAllIn ("July 15", "<NUMBER>") // returns "July <NUMBER>"

Источник

def replaceFirstIn(target: CharSequence, replacement: String): String

Заменяет первое совпадение строкой.

В строке замены знак доллара ($) за которым следует число будет интерпретирован как ссылка на группу в совпавшем шаблоне, при этом числа от 1 до 9 соответствуют первым девяти группам, а 0 — всему совпадению. Любой другой символ является ошибкой. Символ обратной косой черты (\) будет интерпретирован как символ экранирования и может использоваться для экранирования знака доллара. Используйте Regex.quoteReplacement для экранирования этих символов.

Источник

def replaceSomeIn(target: CharSequence, replacer: Match => Option[String]): String

Заменяет некоторые совпадения с использованием функции замены, возвращающей scala.Option. Функция замены принимает scala.util.matching.Regex.Match, чтобы получить дополнительную информацию из совпадения. Например:

import scala.util.matching.Regex._

val vars = Map("x" -> "a var", "y" -> """some $ and \ signs""")
val text = "A text with variables %x, %y and %z."
val varPattern = """%(\w+)""".r
val mapper = (m: Match) => vars get (m group 1) map (quoteReplacement(_))
val repl = varPattern replaceSomeIn (text, mapper)

В строке замены знак доллара ($) за которым следует число будет интерпретирован как ссылка на группу в совпавшем шаблоне, при этом числа от 1 до 9 соответствуют первым девяти группам, а 0 — всему совпадению. Любой другой символ является ошибкой. Символ обратной косой черты (\) будет интерпретирован как символ экранирования и может использоваться для экранирования знака доллара. Используйте Regex.quoteReplacement для экранирования этих символов.

Источник

def split(toSplit: CharSequence): Array[String]

Разбивает предоставленную последовательность символов вокруг совпадений с этим регулярным выражением.

Источник

override def toString: String

Строка, определяющая регулярное выражение

Источник

def unapplySeq(m: Match): Option[List[String]]

Попытка сопоставить с scala.util.matching.Regex.Match.

Предыдущий неудачный поиск приводит к None.

Если успешное совпадение было выполнено для текущего шаблона, то используется этот результат.

В противном случае это регулярное выражение применяется к ранее сопоставленному входу, и результат этого сопоставления используется.

Источник

def unapplySeq(c: Char): Option[List[Char]]

Попытка сопоставить строковое представление scala.Char.

Если поиск успешен, результатом является первая совпадающая группа, если группы определены, или пустая последовательность в противном случае.

Например:

val cat = "cat"
// the case must consume the group to match
val r = """(\p{Lower})""".r
cat(0) match { case r(x) => true }
cat(0) match { case r(_) => true }
cat(0) match { case r(_*) => true }
cat(0) match { case r() => true }     // no match

// there is no group to extract
val r = """\p{Lower}""".r
cat(0) match { case r(x) => true }    // no match
cat(0) match { case r(_) => true }    // no match
cat(0) match { case r(_*) => true }   // matches
cat(0) match { case r() => true }     // matches

// even if there are multiple groups, only one is returned
val r = """((.))""".r
cat(0) match { case r(_) => true }    // matches
cat(0) match { case r(_,_) => true }  // no match

Источник

def unapplySeq(s: CharSequence): Option[List[String]]

Попытка сопоставить java.lang.CharSequence.

Если поиск успешен, результатом является список совпадающих групп (или элемент null если группа не соответствует никакому вводу). Если шаблон не содержит групп, то результатом будет пустой список при успешном сопоставлении.

Этот метод по умолчанию пытается сопоставить весь входной данные; чтобы найти следующую подпоследовательность совпадений, используйте не закрепленное Regex.

Например:

val p1 = "ab*c".r
val p1Matches = "abbbc" match {
  case p1() => true               // no groups
  case _    => false
}
val p2 = "a(b*)c".r
val p2Matches = "abbbc" match {
  case p2(_*) => true             // any groups
  case _      => false
}
val numberOfB = "abbbc" match {
  case p2(b) => Some(b.length)    // one group
  case _     => None
}
val p3 = "b*".r.unanchored
val p3Matches = "abbbc" match {
  case p3() => true               // find the b's
  case _    => false
}
val p4 = "a(b*)(c+)".r
val p4Matches = "abbbcc" match {
  case p4(_*) => true             // multiple groups
  case _      => false
}
val allGroups = "abbbcc" match {
  case p4(all @ _*) => all mkString "/" // "bbb/cc"
  case _            => ""
}
val cGroup = "abbbcc" match {
  case p4(_, c) => c
  case _        => ""
}

Унаследованные поля

Источник

val pattern: Pattern