Scala Tutorial — регулярные выражения, сопоставления и замены с помощью API scala.util.matching

Предисловие

Это шестая часть руководств для начинающих программистов, попадающих в Scala. Другие посты находятся в этом блоге, и вы можете получить ссылки на эти и другие ресурсы на странице ссылок курса по компьютерной лингвистике, для которого я их создаю. Кроме того, вы можете найти эту и другие серии учебников на странице JCG Java Tutorials .

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

Использование регулярных выражений для захвата значений для назначения переменных и падежей в выражениях совпадений — это очень чистый, продуманный и очень полезный признак поддержки регулярных выражений в языке Scala. Однако их использование для более сложного сопоставления строк и подстановки, честно говоря, гораздо менее прямолинейно, чем в языках со встроенной поддержкой регулярных выражений, таких как Perl (который, если говорить как тот, кто много кодировал в Perl, — вы * не * хотите использовать для общего программирования). Scala полностью совместим с тем, что вы можете полностью использовать регулярные выражения, но вам нужно будет использовать его через Regex API. Другими словами, вам нужно использовать несколько команд, не все из которых так просты, как могли бы быть. (Это не напыщенная речь, хотя я, конечно, хотел бы, чтобы регулярные выражения поддерживались более естественным образом в Scala.)

Хотя я буду ссылаться на то, что я делаю ниже, как на использование API-интерфейса Regex, я сначала отмечу, что это звучит как нечто большее, чем на самом деле. Это просто означает, что вы напрямую используете классы и объекты из пакета scala.util.matching , а не используете специальный синтаксис и интеграцию с сопоставлением с шаблоном Scala, которое мы видели в предыдущем посте.

Более обширное соответствие

Во-первых, давайте сделаем то, что мы сделали с сопоставлением с шаблоном в предыдущем посте, но теперь используем класс Regex и доступные ему методы для достижения тех же целей. Затем мы можем начать работать с поиском нескольких совпадений и выполнением замен.

Напомним, вспомним регулярное выражение name и то, как мы можем использовать его для инициализации группы переменных на основе соответствия заданной строке.

Вместо того, чтобы делать это таким образом, давайте вместо этого будем использовать методы API. Мы начнем с использования регулярного выражения, чтобы найти совпадения, если таковые имеются. Метод findAllIn из Regex делает это для нас.

Результатом является итератор , который представляет собой объект, похожий на список, в котором вы можете перебирать его элементы с помощью выражений и foreach , использовать map для преобразования его значений и многое другое.

Однако, в отличие от списков, вы можете сделать это только один раз. Как показано ниже, после того, как вы выполните итерацию один раз, его элементы израсходованы.

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

Если вы хотите сделать это, вам нужно просто вызвать toList в MatchIterator .

В основном, я буду работать с результатами матчей в виде Списка до конца этого урока. Однако обратите внимание, что когда вы программируете, вы должны подумать, действительно ли вам нужно это делать — обычно итератора будет достаточно, и у него будет преимущество в том, что он будет более эффективным.

Обратите внимание, что у нас есть List [String] . Это означает, что мы можем видеть, какие части строки совпадают, что может включать в себя несколько совпадений.

Это будет полезно во многих контекстах, но не позволит нам получить доступ к группам совпадений, которые были определены в регулярном выражении. Для этого нам нужно использовать метод matchData , который преобразует MatchIterator (который предлагает Strings в качестве его элементов) в Iterator [Match] (который предлагает объекты Match в качестве своих элементов).

Давайте преобразовать это в список, а затем захватить первый элемент.

Этот объект Match содержит захваченные группы, к которым мы можем получить доступ с помощью метода group. Первый индекс 0 возвращает все совпадения, а остальные получают доступ к захваченным группам.

Мы можем немного приблизиться к исходному сопоставлению переменных с шаблоном, упаковав их как кортеж.

Обновление : есть более краткий способ сделать это, используя диапазон от 1 до 3 и сопоставить firstMatch.group с этим диапазоном. Это создает Seq (uence), по которому мы можем сопоставить шаблон. (Спасибо @missingfaktor.)

Это должно продемонстрировать, почему поддержка Scala для регулярных выражений в сопоставлении паттернов очень хороша для этого. Что вы получаете с API — это возможность сопоставлять несколько экземпляров шаблона в строке, а затем выполнять вычисления с результатами сопоставления на лету. Например, давайте вернемся к предложению с несколькими именами в нем и используем регулярное выражение Name, чтобы передать привет каждому найденному в нем имени.

Конечно, вы можете распечатать только части имен, такие как заголовок и фамилия.

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

Обратите внимание, что в приведенных выше строках я не конвертировал MatchIterator в список, так как был рад просто просмотреть список один раз и выполнить некоторые действия.

Выполнение замен

Другая вещь, которую вы получаете, — это возможность использовать регулярные выражения для замены одного класса выражений другим. Например, предположим, что (по какой-то странной причине) вы хотели бы изменить имя каждого, чтобы « Мистер Джон Смит » стал « Мистер Смит Джон ». Это достигается с помощью метода Regex replaceAllIn , который принимает два аргумента: первый — исходная строка, а второй — функция, которая принимает объект Match и возвращает строку.

Переменная m выше ссылается на каждый из идентифицированных объектов Match, по очереди. Это означает, что мы можем получить доступ к группам, как мы делали раньше. Сначала может показаться странным, что анонимная функция m => m.group (1) + «. ”+ M.group (3) +” ”+ m.group (2) является аргументом. Это не очень отличается от следующего, где мы сначала создаем именованную функцию, а затем передаем ее в качестве аргумента.

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

Разница в том, что использование findAllIn дает нам сами результаты Match, тогда как replaceAllIn заменяет их в String in situ. Нужно ли вам делать то или другое, зависит от ваших потребностей программирования.

Определение соответствия всей строки с помощью Regex API

Если вы просто хотите узнать, соответствует ли вся данная строка регулярному выражению, Scala, к сожалению, имеет несколько обходных путей для вас. Во-первых, вот синтаксис, проверяющий, соответствует ли Name переменным smith и предложению .

Таким образом, предложение не совпадает (несмотря на наличие трех имен в нем), поскольку вся строка не совпадает с именем.

Здесь происходит то, что мы на самом деле используем классы, определенные в Java, для работы с регулярными выражениями. Сначала мы получаем объект java.util.regex.Pattern, связанный с нашим объектом scala.util.matching.Regex .

Затем мы используем этот шаблон, чтобы получить java.util.regex.Matcher для строки.

Класс Matcher имеет метод match, который сообщает нам, было ли совпадение для этой строки.

Итак, многословно, но вы можете это сделать.

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

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

Простые подстановки со вторым регулярным выражением

Есть другой метод replaceAllIn, который принимает строку, определяющую (довольно) стандартную подстановку регулярного выражения в качестве второго аргумента, а не функцию из соответствий в строки. Этот аргумент определяет регулярное выражение, аналогичное тому, которое используется в стандартных подстановках s /// из языка программирования Perl, например, в следующем, который превращает строки вроде « xyzaaaabbb123 » в « xyzbbbaaaa123 ».

В отличие от Perl (который аналогичен синтаксису, обсуждаемому в книге Юрафски и Мартина), Scala использует $ 1 , $ 2 и т. Д. В качестве примера рассмотрим обмен фамилиями на фамилии, который мы делали ранее. Здесь это повторяется:

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

Это гораздо более кратко и читабельно, чем стиль m.group (), описанный выше, поэтому он предпочтителен для подобных случаев. Однако иногда вам захочется сделать более интересную обработку значений в каждой группе, например, изменить названия на другой язык и вывести только первый инициал имени: например, « Мистер Джон Смит » станет « Sr». Дж. Смит »и« Миссис Джейн Хилл »станут« Сра. Дж. Хилл ». Мне не ясно, как можно это сделать с помощью подстановок $ n (если кто-то из читателей знает, пожалуйста, дайте мне знать). Чтобы сделать это с помощью функции Match => String , это просто. Сначала давайте определим метод, который отображает названия с английского на испанский.

Затем мы передаем m.group (1) через эту функцию, используя engTitle2Esp (m.group (1)) , и получаем только первый символ группы 2, индексируя в нем m.group (2) (0) .

Это дает вам значительный контроль над тем, как обрабатывать замены.

Ссылка: Первые шаги в Scala для начинающих программистов, часть 6 от нашего партнера JCG Джейсона Болдриджа в блоге Bcomposes .

Статьи по Теме :

• Scala Tutorial — Scala REPL, выражения, переменные, основные типы, простые функции, сохранение и запуск программ, комментарии
• Scala Tutorial — кортежи, списки, методы для списков и строк
• Scala Tutorial — условное исполнение с блоками if-else и соответствием
• Scala Tutorial — итерация, для выражений, yield, map, filter, count
• Scala Tutorial — регулярные выражения, сопоставление
• Учебник по Scala — Карты, Наборы, groupBy, Параметры, Flatten, FlatMap
• Scala Tutorial — scala.io.Source, доступ к файлам, flatMap, изменяемые Карты
• Scala Tutorial — объекты, классы, наследование, черты, списки с несколькими связанными типами, применение
• Scala Tutorial — скриптинг, компиляция, основные методы, возвращаемые значения функций
• Scala Tutorial — SBT, scalabha, пакеты, системы сборки
• Scala Tutorial — блоки кода, стиль кодирования, замыкания, проект документации scala
• Веселье с функцией композиции в Scala
• Как Scala изменил мой взгляд на мой Java-код
• Тестирование с помощью Scala
• Вещи, которые должен знать каждый программист