Класс scala.util.matching.Regex

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

Эквивалентно 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 (@see 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 обозначает всё совпадение. Любой другой символ является ошибкой. Обратный слэш (\) будет интерпретироваться как escape-символ и может использоваться для экранирования знака доллара. Используйте Regex.quoteReplacement для экранирования этих символов.

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

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

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

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

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

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

Создает новый Regex с тем же шаблоном, но без требования, чтобы весь String соответствовал шаблону в шаблонах извлекателей и 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.

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

В противном случае этот 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 _        => ""
}