我正在尝试创建一个方便的类来快速构建复杂的正则表达式。这部分按预期工作:

/**
A RegexAtom contains a regular expression pattern, or fragment of a pattern. Capture groups can be named with the groupNames array.
RegexAtom does no syntax checking on the pattern. Typical usage is to define several fragments of a regex pattern, and then combine
them using finalPattern = foo + bar + soom
*/
public class RegexAtom{
    var regex: String = ""
    var groupNames: [String] = []
    public init(regex: String, groupNames:[String]){
        self.regex = regex
        self.groupNames = groupNames
    }
    public init(regex: String){
        self.regex = regex
        self.groupNames = []
    }

}
func +(left: RegexAtom, right: RegexAtom) -> RegexAtom{
    var foo = RegexAtom(regex: left.regex,groupNames: left.groupNames)
    foo.regex += right.regex
    foo.groupNames.extend(right.groupNames)
    return foo
}

我可以使用 + 添加复杂的 RegexAtoms，它符合要求并且运行得很好。

问题来自于希望能够更紧凑地处理文字字符串，就像在 PyParsing 中所做的那样(我想念 PyParsing :( )

这个函数的工作原理:

func +(left:RegexAtom, right: String)->RegexAtom{
var foo = RegexAtom(regex: left.regex,groupNames: left.groupNames)
foo.regex.extend(right)
return foo

但是如果我尝试像这样构建一个复杂的正则表达式

let WS: RegexAtom = RegexAtom(regex:"\\s*")
let tableHeader1 = RegexAtom(regex: "Date") + WS + "Flight" + WS + "Depart" + WS + "Arrive" + WS + "Eq" + WS + "Blk" + WS + "Grnd" + WS + "Blk" + WS + "Duty" + WS + "Cred"

编译错误:

“表达式太复杂，无法在合理的时间内解决。考虑将表达式分解为不同的子表达式。”

但这工作正常:

let tableHeader1 = RegexAtom(regex: "Date") + WS + "Flight"

较长的表达式对我来说并不算长，但我在 Xcode 或 swift 方面的经验很少。

有什么建议吗？

最佳答案

这里有一些因素结合在一起导致了您的问题。

首先，最好避免这种事情:

func +(left: RegexAtom, right: String) -> RegexAtom { ... }

有两个原因。这种静默类型强制在 Swift 中有点不受欢迎。例如，没有标准库运算符允许您将整数与 float 相加。人们倾向于假设 + 是可交换的(即 a + b == b + a)，因此您需要定义一个版本，其中左边是字符串，右边是正则表达式。

第二个问题是 "thing" 不是 String。它是一个字符串文字，可以创建任何实现 StringLiteralConvertible 的类型。默认类型是 String，但也可以是 Character 或 StaticString 或任何其他自定义类型。

Swift 的类型推断引擎非常灵活——它会努力为您放入表达式中的所有类型找到可能的匹配项。然后，如果有多个匹配项，它会尝试根据一系列优先规则选择最佳匹配项。但在大表达式中，可能性太多了，调查所有这些都是组合的噩梦，所以它就放弃了。

想想你的简单例子。 Swift 选择的解释是这样的:

let tableHeader1 = (RegexAtom(regex: "Date") + WS) + ("Flight" as String)

这是因为 + 是左关联的，字符串文字默认为 String。但它还必须考虑其他一些替代方案:

// this will have been considered and rejected, because there's no operator
// that adds characters to regexes
let tableHeader1 = (RegexAtom(regex: "Date") + WS) + ("Flight" as Character)

// this will compile, but the other version is preferred because + is left-
// associative.  But if the first version resulted in an expression that
// didn't compile (say a regex plus a regex equals an integer), it would
// fall back to this possibility
let tableHeader1 = RegexAtom(regex: "Date") + (WS + ("Flight" as String))

现在，想象一下您超长的加号表达式所暗示的可能性的组合爆炸。

作为替代方案，您可以考虑放弃 +(RegexAtom,String) 运算符，而是让 RegexAtom 符合 StringLiteralConvertible:

extension RegexAtom: StringLiteralConvertible {
    public init(stringLiteral: String) {
        self.init(regex: stringLiteral)
    }
    public init(extendedGraphemeClusterLiteral: String) {
        self.init(regex: extendedGraphemeClusterLiteral)
    }
    public init(unicodeScalarLiteral: String) {
        self.init(regex: unicodeScalarLiteral)
    }
}

如果您这样做，看起来您的复杂表达式可以编译 OK。

关于regex - Swift 覆盖 + 多种类型和长表达式，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29306221/