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

Проверка двух объектов на неравенство.

Эквивалентно x.hashCode за исключением упакованных числовых типов и null. Для чисел возвращает значение хеш-кода, согласованное с равенством значений: если два экземпляра типа значения сравниваются как true, то ## для каждого из них вернёт одинаковое значение хеш-кода. Для null возвращает хеш-код, где null.hashCode вызывает NullPointerException.

Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

Преобразует объект получателя к типу T0.

Обратите внимание, что успешность преобразования во время выполнения определяется семантикой стирания Scala. Таким образом, выражение 1.asInstanceOf[String] вызовет ClassCastException во время выполнения, в то время как выражение List(1).asInstanceOf[List[String]] этого не сделает. В последнем примере, поскольку аргумент типа стирается во время компиляции, невозможно проверить, содержат ли элементы списка требуемый тип.

Создаёт копию объекта получателя.

По умолчанию реализация метода clone зависит от платформы.

Проверяет, является ли аргумент (that) ссылкой на объект-получатель (this).

Метод eq реализует отношение эквивалентности на непустых экземплярах AnyRef, и имеет три дополнительных свойства:

Он согласован: для любых непустых экземпляров x и y типа AnyRef, многократные вызовы x.eq(y) последовательно возвращают true или последовательно возвращают false. Для любого непустого экземпляра x типа AnyRef, x.eq(null) и null.eq(x) возвращают false. null.eq(null) возвращает true.

При переопределении методов equals или hashCode важно обеспечить согласованность их поведения с равенством по ссылке. Поэтому, если два объекта являются ссылками друг на друга (o1 eq o2), они должны быть равны друг другу (o1 == o2) и они должны хешироваться к одному значению (o1.hashCode == o2.hashCode).

Метод равенства для типов ссылок. Реализация по умолчанию делегирует вызов методу eq.

См. также equals в scala.Any.

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

Детали вызова метода finalize, а также взаимодействие между finalize и нелокальными возвратами и исключениями зависят от платформы.

Возвращает все неперекрывающиеся совпадения этого 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 для получения дополнительных сведений.

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

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

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

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

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

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

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

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

Возвращает строку, отформатированную согласно заданной format строке. Форматные строки аналогичны String.format (@см. java.lang.String.format).

Возвращает представление класса объекта во время выполнения.

Метод hashCode для ссылочных типов. См. hashCode в scala.Any.

Проверьте, является ли динамический тип объекта-получателя T0.

Обратите внимание, что результат теста зависит от семантики стирания Scala. Поэтому выражение 1.isInstanceOf[String] вернёт false, в то время как выражение List(1).isInstanceOf[List[String]] вернёт true. В последнем примере, поскольку аргумент типа стирается во время компиляции, невозможно проверить, соответствуют ли содержимое списка указанному типу.

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

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

Эквивалентно !(this eq that).

Разбудите один поток, ждущий на мониторе объекта-получателя.

Разбудите все потоки, ждущие на мониторе объекта-получателя.

Заменяет все совпадения с помощью функции замены. Функция замены принимает 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 для экранирования этих символов.

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

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

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

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

Заменяет некоторые совпадения с помощью функции replacer, которая возвращает scala.Option. Функция replacer принимает 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 для экранирования этих символов.

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

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

Создает новый 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"
}

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

Ранее неудачное сопоставление приводит к None.

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

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

Пытается сопоставить строковое представление 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

Пытается сопоставить 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 _        => ""
}