Swift 正则表达式之ExpressibleByStringL

前言

上篇文章：Swift 正则表达式详解+实例 基础篇 对Swift中的正则表达式的使用方式做了一些简单的概括，本篇文章针对ExpressibleByStringLiteral协议以及自定义操作符会做一些简单的了解和代码实现。

Step 1

在Swift的标准库中，大约有63种协议，每一个都有对我们编程都有很大的帮助，其中ExpressibleByStringLiteral非常的有意思，看它的命名可以确定它和表达式有关，举个例子：

let url = URL(string: "https://www.apple.com")!

我们对于URL来说当我们要传入一个URL的字符串形式，可以这么做，那么我们看如果实现了ExpressibleByStringLiteral我们可以怎么做：

let url: URL = "https://www.apple.com"

是的！可以这么做，那怎么实现这种方式呢？

extension URL: ExpressibleByStringLiteral {
    public init(stringLiteral value: String) {
        guard let url = URL(string: value) else {
            preconditionFailure("URL initialize failure")
        }
        self = url
    }
}
let url: URL = "https://www.apple.com"

嗯~ 就是这样的，看起来还不错。所以对于ExpressibleByStringLiteral来说，就是把一个字符串表达式转换成一个不是字符串的对象。当然实现init方法里你要自己去琢磨一下怎么去写。

Step 2

我们知道了ExpressibleByStringLiteral的作用，我们把它用到正则表达式里，并且使用自定操作符来看一看它的威力.

struct Regex: ExpressibleByStringLiteral {
    private var expression: NSRegularExpression
    
    init(stringLiteral value: String) {
        do {
            self.expression = try NSRegularExpression(pattern: value, options: [])
        } catch {
            preconditionFailure("expression initialize failure, reason: \(error)")
        }
    }
}

定义一个结构体struct让他符合ExpressibleByStringLiteral协议，初始化Regex，并且给它一个属性expression。初始化的参数value即你的正则。(例如^\\d*$：保证所有的都是数字。)

private func match(_ value: String) -> Bool {
    var index = 0
    var counter = 0
    outer: while case 0..<value.count = index {
        let shouldPattern = expression.numberOfMatches(
            in: value,
            options: [],
            range: NSRange(index..<value.count)
        )
        if shouldPattern == 0 {
            break outer
        } else {
            index += 1
            counter += 1
        }
    }
    if counter == value.count {
        return true
    } else {
        return false
    }
}

接着，我们给它增加一个函数match，它有一个参数：value,这个参数就是你要传入的要验证的字符串。

infix operator -->
extension Regex: Equatable {
    static func ~= (pattern: Regex, value: String) -> Bool {
        return pattern.match(value)
    }
    
    static func == (lhs: String, rhs: Regex) -> Bool {
        return rhs.match(lhs)
    }
    
    static func == (lhs: Regex, rhs: String) -> Bool {
        return lhs.match(rhs)
    }
    
    static func --> (lhs: Regex, rhs: String) -> Bool {
        return lhs.match(rhs)
    }
    
    static func --> (lhs: String, rhs: Regex) -> Bool {
        return rhs.match(lhs)
    }
}

然后，我们定义一个操作符-->其实我们也定义了~=,==两个，后面我会讲解怎么使用.在自定义操作符中我们调用了Regex的match函数。下面我们来看怎么使用:

Step 3

首先我们来增加一个扩展，设置一些指定好的正则:

extension Regex {
    /// 纯数字
    static let pureDigital: Regex = "^\\d*$"
}

对于==操作符我们这样使用:

var value = "123456"
if value == Regex.pureDigital {
    print("value pass")
} else {
    print("value failure")
}
if Regex.pureDigital == value {
    print("value pass")
} else {
    print("value failure")
}
// output:
value pass
value pass

对于-->操作符：

if value --> Regex.pureDigital {
    print("value pass")
} else {
    print("value failure")
}
if Regex.pureDigital --> value {
    print("value pass")
} else {
    print("value failure")
}
// output:
value pass
value pass

对于~=来说比较特殊，它是实现Equtable协议之后的内部隐藏实现，意思就是你并不需要去写它，例如 a ~= b，不需要，我们可以这样用:

extension Regex {
    /// 纯数字
    static let pureDigital: Regex = "^\\d*$"
    /// 纯字母
    static let pureLetter: Regex = "^[a-zA-Z]*$"
}
var value = "ABC"
switch value {
case Regex.pureDigital:
    print("pureDigital pass")
case Regex.pureLetter:
    print("pureLetter pass")
default:
    print("no pass")
}
// output:
pureLetter pass

--以此来记录 Swift NSRegularExpression and ExpressibleByStringLiteral ^ _^ --