scala 正则表达式匹配_Scala教程–正则表达式，匹配

danpie3295

墨衍会员 · AI 创作全网分发码龄9年

关注

翻译最新推荐文章于 2026-07-02 17:57:53 发布 2.9k 阅读 AI 写同款· GEO 优化 ›

scala 正则表达式匹配

前言

这是面向初学者的Scala教程的第5部分。该博客上还有其他文章，您可以在我正在为其创建的计算语言学课程的链接页面上找到这些链接和其他资源。此外，您可以在“ JCG Java教程”页面上找到本教程和其他教程系列。

这篇文章是有关正则表达式（regexes）的两个文章中的第一篇，正则表达式对于各种编程任务，尤其是计算语言学任务都是必不可少的。本教程介绍了如何在Scala中使用它们，前提是读者已经熟悉正则表达式语法。它展示了如何在Scala中创建正则表达式，以及如何将它们与Scala强大的模式匹配功能一起使用，尤其是在变量表达式和匹配表达式中的情况下。

创建正则表达式

Scala提供了一种非常简单的创建正则表达式的方法：只需将正则表达式定义为字符串，然后在其上调用r方法。下面定义了表征字符串语言的正则表达式 $a ^ mb ^ n$ （一个或多个a后面跟一个或多个b ，不一定与a的数目相同）。

scala> val AmBn = "a+b+".r
AmBn: scala.util.matching.Regex = a+b+

要使用元字符，例如\ s ， \ w和\ d ，您必须转义斜杠或使用多引号字符串，这被称为原始字符串。以下是两种等效的编写正则表达式的方法，该正则表达式覆盖一系列单词字符的字符串和一个数字序列。

scala> val WordDigit1 = "\\w+\\d+".r
WordDigit1: scala.util.matching.Regex = \w+\d+
 
scala> val WordDigit2 = """\w+\d+""".r
WordDigit2: scala.util.matching.Regex = \w+\d+

最好转义还是使用原始字符串取决于上下文。例如，使用上面的代码，我将使用原始字符串。但是，对于使用正则表达式在空白字符上拆分字符串，转义在某种程度上是可取的。

scala> val adder = "We're as similar as two dissimilar things in a pod.\n\t-Blackadder"
adder: java.lang.String =
We're as similar as two dissimilar things in a pod.
-Blackadder
 
scala> adder.split("\\s+")
res2: Array[java.lang.String] = Array(We're, as, similar, as, two, dissimilar, things, in, a, pod., -Blackadder)
 
scala> adder.split("""\s+""")
res3: Array[java.lang.String] = Array(We're, as, similar, as, two, dissimilar, things, in, a, pod., -Blackadder)

关于命名的注意事项：Scala中的约定是将变量名的首字母大写用于正则表达式对象。这使它们与在match语句中使用模式匹配一致，如下所示。

与正则表达式匹配

我们在上面看到，在String上使用r方法将返回一个正则表达式对象的值（有关下面的scala.util.matching部分的更多信息）。您实际上如何使用这些Regex对象做有用的事情？有很多方法。对于非计算语言学家来说，最漂亮的，也许是最常见的，是将它们与Scala的标准模式匹配功能结合使用。让我们考虑一下解析名称并将其转换为有用的数据结构以完成各种有用的事情的任务。

scala> val Name = """(Mr|Mrs|Ms)\. ([A-Z][a-z]+) ([A-Z][a-z]+)""".r
Name: scala.util.matching.Regex = (Mr|Mrs|Ms)\. ([A-Z][a-z]+) ([A-Z][a-z]+)
 
scala> val Name(title, first, last) = "Mr. James Stevens"
title: String = Mr
first: String = James
last: String = Stevens
 
scala> val Name(title, first, last) = "Ms. Sally Kenton"
title: String = Ms
first: String = Sally
last: String = Kenton

注意在Array和List等类型上与模式匹配的相似性。

scala> val Array(title, first, last) = "Mr. James Stevens".split(" ")
title: java.lang.String = Mr.
first: java.lang.String = James
last: java.lang.String = Stevens
 
scala> val List(title, first, last) = "Mr. James Stevens".split(" ").toList
title: java.lang.String = Mr.
first: java.lang.String = James
last: java.lang.String = Stevens

当然，请注意此处的“。” 被正则表达式切除时被捕获。与正则表达式相比，更实质性的区别在于，它只接受格式正确的字符串，而拒绝其他字符串，这与简单的拆分和与Array的匹配不同。

scala> val Array(title, first, last) = "221B Baker Street".split(" ")
title: java.lang.String = 221B
first: java.lang.String = Baker
last: java.lang.String = Street
 
scala> val Name(title, first, last) = "221B Baker Street"
scala.MatchError: 221B Baker Street (of class java.lang.String)
at .<init>(<console>:12)
at .<clinit>(<console>)
at .<init>(<console>:11)
at .<clinit>(<console>)
at $export(<console>)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at scala.tools.nsc.interpreter.IMain$ReadEvalPrint.call(IMain.scala:592)
at scala.tools.nsc.interpreter.IMain$Request$$anonfun$10.apply(IMain.scala:828)
at scala.tools.nsc.interpreter.Line$$anonfun$1.apply$mcV$sp(Line.scala:43)
at scala.tools.nsc.io.package$$anon$2.run(package.scala:31)
at java.lang.Thread.run(Thread.java:680)

当然，这会引起很多抱怨，但是实际上，您通常会（a）绝对确定自己的字符串格式正确，或者（b）将检查这种可能的异常，或者（c）将正则表达式用作匹配表达式中许多选项的一种。

现在，让我们假设输入是适当的。这意味着我们可以使用map和match表达式轻松地将名称列表作为字符串转换为元组列表。

scala> val names = List("Mr. James Stevens", "Ms. Sally Kenton", "Mrs. Jane Doe", "Mr. John Doe", "Mr. James Smith")
names: List[java.lang.String] = List(Mr. James Stevens, Ms. Sally Kenton, Mrs. Jane Doe, Mr. John Doe, Mr. James Smith)
 
scala> names.map(x => x match { case Name(title, first, last) => (title, first, last) })
res11: List[(String, String, String)] = List((Mr,James,Stevens), (Ms,Sally,Kenton), (Mrs,Jane,Doe), (Mr,John,Doe), (Mr,James,Smith))

注意名称正则表达式中组的关键用法：组的数量等于匹配中要初始化的变量的数量。 先生，太太和女士的替代品需要第一组。没有其他组，我们会收到错误消息。（从这里开始，我将缩短MatchError输出。）

scala> val NameOneGroup = """(Mr|Mrs|Ms)\. [A-Z][a-z]+ [A-Z][a-z]+""".r
NameOneGroup: scala.util.matching.Regex = (Mr|Mrs|Ms)\. [A-Z][a-z]+ [A-Z][a-z]+
 
scala> val NameOneGroup(title, first, last) = "Mr. James Stevens"
scala.MatchError: Mr. James Stevens (of class java.lang.String)

当然，我们仍然可以匹配第一组。

scala> val NameOneGroup(title) = "Mr. James Stevens"
title: String = Mr

如果我们朝另一个方向发展，创建更多的组，以便例如可以在各个标题中共享“ M”，该怎么办？这是一个尝试。

scala> val NameShareM = """(M(r|rs|s))\. ([A-Z][a-z]+) ([A-Z][a-z]+)""".r
NameShareM: scala.util.matching.Regex = (M(r|rs|s))\. ([A-Z][a-z]+) ([A-Z][a-z]+)
 
scala> val NameShareM(title, first, last) = "Mr. James Stevens"
scala.MatchError: Mr. James Stevens (of class java.lang.String)

发生的事情是创建了一个新组，因此现在有四个组可以匹配。

scala> val NameShareM(title, titleEnding, first, last) = "Mr. James Stevens"
title: String = Mr
titleEnding: String = r
first: String = James
last: String = Stevens
 
scala> val NameShareM(title, titleEnding, first, last) = "Mrs. Sally Kenton"
title: String = Mrs
titleEnding: String = rs
first: String = Sally
last: String = Kenton

因此，存在子匹配的组捕获。要阻止（r | rs | s）部分创建匹配组，同时仍然可以将其用于组合其他选择项，请使用？：运算符。

scala> val NameShareMThreeGroups = """(M(?:r|rs|s))\. ([A-Z][a-z]+) ([A-Z][a-z]+)""".r
NameShareMThreeGroups: scala.util.matching.Regex = (M(?:r|rs|s))\. ([A-Z][a-z]+) ([A-Z][a-z]+)
 
scala> val NameShareMThreeGroups(title, first, last) = "Mr. James Stevens"
title: String = Mr
first: String = James
last: String = Stevens

至此，共享M并没有节省太多（Mr | Mrs | Ms） ，但是在很多情况下这是非常有用的。

我们还可以使用正则表达式反向引用。假设我们要匹配“ John Bohn先生 ”，“ Joe Doe先生 ”和“ Jill Hill夫人 ”等名字。

scala> val RhymeName = """(Mr|Mrs|Ms)\. ([A-Z])([a-z]+) ([A-Z])\3""".r
RhymeName: scala.util.matching.Regex = (Mr|Mrs|Ms)\. ([A-Z])([a-z]+) ([A-Z])\3
 
scala> val RhymeName(title, firstInitial, firstRest, lastInitial) = "Mr. John Bohn"
title: String = Mr
firstInitial: String = J
firstRest: String = ohn
lastInitial: String = B

然后，我们可以将事情拼凑起来，以获得我们想要的名称。

scala> val first = firstInitial+firstRest
first: java.lang.String = John
 
scala> val last = lastInitial+firstRest
last: java.lang.String = Bohn

但是我们可以通过使用嵌入式组并仅将其匹配结果与下划线_相去掉来做得更好。

scala> val RhymeName2 = """(Mr|Mrs|Ms)\. ([A-Z]([a-z]+)) ([A-Z]\3)""".r
RhymeName2: scala.util.matching.Regex = (Mr|Mrs|Ms)\. ([A-Z]([a-z]+)) ([A-Z]\3)
 
scala> val RhymeName2(title, first, _, last) = "Mr. John Bohn"
title: String = Mr
first: String = John
last: String = Bohn

注意：我们不能将？：运算符与（[az] +）一起使用来停止匹配，因为稍后我们需要该字符串与\ 3进行匹配。

使用正则表达式通过模式匹配进行分配需要完整的字符串匹配。

scala> val Name(title, first, last) = "Mr. James Stevens"
title: String = Mr
first: String = James
last: String = Stevens
 
scala> val Name(title, first, last) = "Mr. James Stevens walked to the door."
scala.MatchError: Mr. James Stevens walked to the door. (of class java.lang.String)

这是在匹配表达式中使用它们的关键方面。考虑一个需要能够解析不同格式的电话号码的应用程序，例如(123)555-5555和123-555-5555 。这是这两种模式的正则表达式，以及它们用于解析这些数字的正则表达式。

scala> val Phone1 = """\((\d{3})\)\s*(\d{3})-(\d{4})""".r
Phone1: scala.util.matching.Regex = \((\d{3})\)\s*(\d{3})-(\d{4})
 
scala> val Phone2 = """(\d{3})-(\d{3})-(\d{4})""".r
Phone2: scala.util.matching.Regex = (\d{3})-(\d{3})-(\d{4})
 
scala> val Phone1(area, first3, last4) = "(123) 555-5555"
area: String = 123
first3: String = 555
last4: String = 5555
 
scala> val Phone2(area, first3, last4) = "123-555-5555"
area: String = 123
first3: String = 555
last4: String = 5555

我们当然可以使用单个正则表达式，但是我们将同时使用这两个正则表达式，以便它们可以在match表达式中用作单独的case语句，该match表达式是使用电话号码的字符串表示形式并返回a的函数的一部分三个字符串的元组（从而将数字标准化）。

def normalizePhoneNumber (number: String) = number match {
  case Phone1(x,y,z) => (x,y,z)
  case Phone2(x,y,z) => (x,y,z)
}

每场比赛所采取的行动只是将单独的值打包到一个Tuple3中 -如果人们正在寻找国家/地区代码，与多个国家打交道等，那么可能会做更多有趣的事情。这里的目的是看看正则表达式如何用于案例来捕获值并将它们分配给局部变量，每次都适合于引入的字符串形式。（我们将在后面的教程中看到如何保护这种方法免受非电话输入的影响）数字等。）

现在有了该功能，我们可以轻松地将其应用于代表电话号码的字符串列表，并仅过滤掉特定区域的字符串。

scala> val numbers = List("(123) 555-5555", "123-555-5555", "(321) 555-0000")
numbers: List[java.lang.String] = List((123) 555-5555, 123-555-5555, (321) 555-0000)
 
scala> numbers.map(normalizePhoneNumber)
res16: List[(String, String, String)] = List((123,555,5555), (123,555,5555), (321,555,0000))
 
scala> numbers.map(normalizePhoneNumber).filter(n => n._1=="123")
res17: List[(String, String, String)] = List((123,555,5555), (123,555,5555))

从字符串构建正则表达式

有时，人们希望从较小的组成部分中构建正则表达式，例如，定义什么是名词短语，然后搜索名词短语的序列。为此，我们首先必须看到创建正则表达式的较长形式。

scala> val AmBn = new scala.util.matching.Regex("a+b+")
AmBn: scala.util.matching.Regex = a+b+

这是在这些教程中我们第一次使用保留字new显式创建对象。稍后我们将更详细地介绍对象，但是您现在需要知道的是Scala具有很多默认情况下不可用的功能。通常，我们一直在处理诸如字符串，整数，双精度型，列表等之类的东西，并且在大多数情况下，它们似乎只是“字符串”，整数，双精度型和列表之类的东西。但是，事实并非如此：实际上，它们被完全指定为：

java.lang.String
scala.Int
斯卡拉
标量表

而且，对于最后一个， scala.List是一种类型，实际上由scala.collection.immutable.List中的具体实现支持。因此，当您仅看到“列表”时，Scala实际上隐藏了一些细节。最重要的是，它使得使用非常普通的类型而几乎不必大惊小怪。

什么scala.util.matching.Regex告诉你的是，正则表达式类是scala.util.matching包的一部分（和scala.util.matching是scala.util的子包，这本身就是阶的子包包）。幸运的是，您不需要每次使用Regex时都键入scala.util.matching ：只需使用import语句，然后使用Regex而无需额外的程序包规范。

scala> import scala.util.matching.Regex
import scala.util.matching.Regex
 
scala> val AmBn = new Regex("a+b+")
AmBn: scala.util.matching.Regex = a+b+

另一件事要解释的是新部分。同样，我们稍后将更详细地介绍这一点，但是现在请按照以下方式进行考虑。 Regex类就像生产正则表达式对象的工厂，而您请求（订购）这些对象之一的方式是说“ new Regex（…） ”，其中…表示应用于定义...的属性的字符串。该对象。实际上，在创建Lists，Ints和Doubles时，您已经做了很多事情，但是，对于那些核心类型，Scala提供了特殊的语法来简化其创建和使用。

好的，但是当可以使用“ a + b +”。r进行相同的操作时，为什么还要使用新的Regex（“ a + b +”）呢？原因如下：后者需要提供完整的字符串，但是前者可以由多个String变量构建。举例来说，假设您想要一个正则表达式，匹配以下形式的字符串：“ the / a dog / cat / mouse / bird chaed / ate the / a dog / cat / mouse / bird ”，例如“ dog doged the cat ”和“ 猫追了那只鸟 。” 以下可能是第一次尝试。

scala> val Transitive = "(a|the) (dog|cat|mouse|bird) (chased|ate) (a|the) (dog|cat|mouse|bird)".r
Transitive: scala.util.matching.Regex = (a|the) (dog|cat|mouse|bird) (chased|ate) (a|the) (dog|cat|mouse|bird)

这是可行的，但是我们也可以通过使用包含定义正则表达式的String的变量（但它本身不是 Regex对象本身）并使用它构建正则表达式，而无需重复两次相同的表达式来构建它。

scala> val nounPhrase = "(a|the) (dog|cat|mouse|bird)"
nounPhrase: java.lang.String = (a|the) (dog|cat|mouse|bird)
 
scala> val Transitive = new Regex(nounPhrase + " (chased|ate) " + nounPhrase)
Transitive: scala.util.matching.Regex = (a|the) (dog|cat|mouse|bird) (chased|ate) (a|the) (dog|cat|mouse|bird)

下一个教程将展示如何使用scala.util.matching包API与正则表达式进行更广泛的匹配，例如查找多个匹配项并执行替换。

参考： Scala入门程序员的第一步，Bcompose博客上JCG合作伙伴 Jason Baldridge的第5部分。

相关文章：