Трейт 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 реализует отношение эквивалентности на не-null экземплярах AnyRef, и обладает тремя дополнительными свойствами:

Он согласован: для любых не-null экземпляров x и y типа AnyRef, многократные вызовы x.eq(y) последовательно возвращают true или последовательно возвращают false.Для любого не-null экземпляра 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. В последнем примере, поскольку тип аргумента стирается во время компиляции, проверить, являются ли элементы списка указанного типа, нельзя.

Эквивалентно !(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 для экранирования этих символов.

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

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

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

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

Обычно сопоставление с 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.

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

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

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