Трейт UnanchoredRegex.UnanchoredRegex

trait UnanchoredRegex extends Regex

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

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

Исходный код

override protected def runMatcher(m: Matcher): Boolean

Исходный код

override def unanchored: UnanchoredRegex

Создаёт новый Regex с тем же шаблоном, но без требования, чтобы весь строковый текст соответствовал шаблону в шаблонах извлекателей и Regex#matches.

Обычно соответствие date ведёт себя так, как будто шаблон заключён в якоря, "^pattern$".

Отсутствующий якорь Regex ведет себя так, как если бы эти якоря были удалены.

Обратите внимание, что этот метод на самом деле не удаляет никакие соответствия из шаблона.

Вызов anchored возвращает исходный Regex.

val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r.unanchored

val date(year, month, day) = "Date 2011-07-15"                       // OK

val copyright: String = "Date of this document: 2011-07-15" match {
  case date(year, month, day) => s"Copyright $year"                  // OK
  case _                      => "No copyright"
}

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

Исходный код

def anchored: Regex

Исходный код

def findAllIn(source: CharSequence): MatchIterator

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

А 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

Источник

def 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