这个正则表达式可以进一步优化吗？

Question

我编写了这个正则表达式来解析 srt 文件中的条目。

(?s)^\d++\s{1,2}(.{12}) --> (.{12})\s{1,2}(.+)\r?$

我不知道这是否重要，但这是使用 Scala 编程语言完成的（Java 引擎，但是是文字字符串，因此我不必加倍反斜杠）。

之所以使用s{1,2}，是因为有些文件只有换行符\n，而其他文件则有换行符和回车符\n\r 第一个(?s)启用DOTALL模式，这样第三个捕获组也可以匹配换行符。

我的程序基本上打破了使用\n\r?\n 作为分隔符的 srt 文件，并使用 Scala 良好的模式匹配功能来读取每个条目以进行进一步处理：

val EntryRegex = """(?s)^\d++\s{1,2}(.{12}) --> (.{12})\s{1,2}(.+)\r?$""".r

def apply(string: String): Entry = string match {
  case EntryRegex(start, end, text) => Entry(0, timeFormat.parse(start),
    timeFormat.parse(end), text);
}

示例条目：

一行：

1073
01:46:43,024 --> 01:46:45,015
I am your father.

两行：

160
00:20:16,400 --> 00:20:19,312
<i>Help me, Obi-Wan Kenobi.
You're my only hope.</i>

问题是，分析器告诉我，这种解析方法是迄今为止我的应用程序中最耗时的操作（它会进行密集的时间数学运算，甚至可以比读取和解析文件快几倍）条目）。

那么任何正则表达式向导都可以帮助我优化它吗？或者也许我应该牺牲正则表达式/模式匹配的简洁性并尝试一种老式的java.util.Scanner 方法？

干杯，

Answer 1

(?s)^\d++\s{1,2}(.{12}) --> (.{12})\s{1,2}(.+)\r?$

在 Java 中，$ 表示输入的结束或紧接在输入结束之前的换行符的开始。 \z 表示输入的明确结束，所以如果这也是 Scala 中的语义，那么 \r?$ 是多余的，$ 也可以。如果你真的只想要最后一个 CR 而不是 CRLF，那么\r?\z 可能会更好。

(?s) 也应该使(.+)\r? 变得多余，因为+ 是贪婪的，. 应该始终扩展以包含\r。如果您不希望 \r 包含在第三个捕获组中，则使匹配变得惰性：(.+?) 而不是 (.+)。

也许

(?s)^\d++\s\s?(.{12}) --> (.{12})\s\s?(.+?)\r?\z

将在 JVM &| 中运行的正则表达式的其他高性能替代方案CLR 包括JavaCC 和ANTLR。有关仅 Scala 的解决方案，请参阅http://jim-mcbeath.blogspot.com/2008/09/scala-parser-combinators.html

Answer 2

我并不乐观，但这里有两件事可以尝试：

1. 您可以将(?s) 移动到您需要它之前。

2. 删除 \r?$ 并为文本 .+ 使用贪婪的 .++

   ^\d++\s{1,2}(.{12}) --> (.{12})\s{1,2}(?s)(.++)$

要真正获得良好的性能，我会重构代码和正则表达式以使用findAllIn。当前代码正在为文件中的每个 Entry 执行正则表达式。我想单一的findAllIn 正则表达式会表现得更好......但也许不会......

Answer 3

看看这个：

(?m)^\d++\r?+\n(.{12}) --> (.{12})\r?+\n(.++(?>\r?+\n.++)*+)$

这个正则表达式匹配一个完整的 .srt 文件条目就地。您不必先在换行符处拆分内容；这是对资源的巨大浪费。

正则表达式利用了这样一个事实，即只有一个行分隔符（\n 或\r\n）分隔条目中的行（多个行分隔符用于将条目彼此分隔）。使用 \r?+\n 而不是 \s{1,2} 意味着当您只想匹配一个时，永远不会意外匹配两个行分隔符 (\n\n)。

这样，您也不必在(?s) 模式下依赖.。 @Jacob 对此是正确的：它并没有真正帮助你，它正在扼杀你的表现。但是(?m) 模式对正确性和性能很有帮助。

你提到了java.util.Scanner；这个正则表达式可以很好地与findWithinHorizon(0) 一起使用。但是，如果 Scala 不提供一种很好的惯用方式来使用它，我会感到惊讶。

Answer 4

我不会使用java.util.Scanner 甚至字符串。只要您可以假设文件的 UTF-8 编码（或缺少 unicode），您所做的一切都将在字节流上完美运行。您应该能够将速度至少提高 5 倍。

---

编辑：这只是对字节和索引的大量低级摆弄。这是基于我之前做过的事情的一些东西，这似乎快了 2 到 5 倍，具体取决于文件大小、缓存等。我没有在这里进行日期解析，只是返回字符串，我假设文件足够小以适合单个内存块（即

import java.io._
abstract class Entry {
  def isDefined: Boolean
  def date1: String
  def date2: String
  def text: String
}
case class ValidEntry(date1: String, date2: String, text: String) extends Entry {
  def isDefined = true
}
object NoEntry extends Entry {
  def isDefined = false
  def date1 = ""
  def date2 = ""
  def text = ""
}

final class Seeker(f: File) {
  private val buffer = {
    val buf = new Array[Byte](f.length.toInt)
    val fis = new FileInputStream(f)
    fis.read(buf)
    fis.close()
    buf
  }
  private var i = 0
  private var d1,d2 = 0
  private var txt,n = 0
  def isDig(b: Byte) = ('0':Byte) <= b && ('9':Byte) >= b
  def nextNL() {
    while (i < buffer.length && buffer(i) != '\n') i += 1
    i += 1
    if (i < buffer.length && buffer(i) == '\r') i += 1
  }
  def digits() = {
    val zero = i
    while (i < buffer.length && isDig(buffer(i))) i += 1
    if (i==zero || i >= buffer.length || buffer(i) != '\n') {
      nextNL()
      false
    }
    else {
      nextNL()
      true
    }
  }
  def dates(): Boolean = {
    if (i+30 >= buffer.length) {
      i = buffer.length
      false
    }
    else {
      d1 = i
      while (i < d1+12 && buffer(i) != '\n') i += 1
      if (i < d1+12 || buffer(i)!=' ' || buffer(i+1)!='-' || buffer(i+2)!='-' || buffer(i+3)!='>' || buffer(i+4)!=' ') {
        nextNL()
        false
      }
      else {
        i += 5
        d2 = i
        while (i < d2+12 && buffer(i) != '\n') i += 1
        if (i < d2+12 || buffer(i) != '\n') {
          nextNL()
          false
        }
        else {
          nextNL()
          true
        }
      }
    }
  }
  def gatherText() {
    txt = i
    while (i < buffer.length && buffer(i) != '\n') {
      i += 1
      nextNL()
    }
    n = i-txt
    nextNL()
  }
  def getNext: Entry = {
    while (i < buffer.length) {
      if (digits()) {
        if (dates()) {
          gatherText()
          return ValidEntry(new String(buffer,d1,12), new String(buffer,d2,12), new String(buffer,txt,n))
        }
      }
    }
    return NoEntry
  }
}

既然您看到了，您不高兴正则表达式解决方案的编码速度如此之快吗？