模式(Pattern)
- 什么是模式?
- 模式是用于匹配的规则,比如switch的case、捕捉错误的catch、if\guard\while\for语句的条件等
- Swift中的模式有
- 通配符模式(Wildcard Pattern)
- 标识符模式(Identifier Pattern)
- 值绑定模式(Value-Binding Pattern)
- 元组模式(Tuple Pattern)
- 枚举Case模式(Enumeration Case Pattern)
- 可选模式(Optional Pattern)
- 类型转换模式(Type-Casting Pattern)
- 表达式模式(Expression Pattern)
通配符模式(Wildcard Pattern)
- _ 匹配任何值
- _? 匹配非nil值
enum Life {
case human(name: String, age: Int?)
case animal(name: String, age: Int?)
}
func check(_ life: Life) {
switch life {
case .human(let name, _):
print("human", name)
case .animal(let name, _?):
print("animal", name)
default:
print("other")
}
}
check(Life.human(name: "Rose", age: 20)) //human Rose
check(Life.human(name: "Jack", age: nil)) //human Jack
check(Life.animal(name: "Dog", age: 5)) //animal Dog
check(Life.animal(name: "Cat", age: nil)) //other
check(.human(name: "Rose", age: 20)) //human Rose
check(.human(name: "Jack", age: nil)) //human Jack
check(.animal(name: "Dog", age: 5)) //animal Dog
check(.animal(name: "Cat", age: nil)) //other
标识符模式(Identifier Pattern)
- 给对应的变量、常量名赋值
var age = 10
let name = "jack"
值绑定模式(Value-Binding Pattern)
把元祖中3和2的值分别绑定给x和y:
元组模式(Tuple Pattern)
let points = [(0, 0), (1, 0), (2, 0)]
for (x, _) in points {
print(x)
}
let name: String? = "Jack"
let age = 18
let info: Any = [1,2]
switch (name, age, info) {
case (_?, _, _ as String):
print("case")
default:
print("default")
} //输出default
var scores = ["jack": 98, "Rose": 100, "Kate": 86]
for (name, score) in scores {
print((name, score))
}
//输出:
//("jack", 98)
//("Rose", 100)
//("Kate", 86)
枚举Case模式(Enumeration Case Pattern)
- if case语句等价于只有一个case的switch语句
let age = 2
//原来的写法
if age >= 0 && age <= 9 {
print("[0, 9]") //[0, 9]
}
//枚举case模式:看age里是否有0到9的数字,如果匹配,进入{ }
if case 0...9 = age {
print("[0, 9]") //[0, 9]
}
guard case 0...9 = age else { return }
print("[0, 9]")
switch age {
case 0...9: print("[0, 9]")
default: break
}//[0, 9]
let ages: [Int?] = [2, 3, nil, 5]
for case nil in ages {
print("有nil值")
break
} //有nil值
let points = [(1, 0), (2, 1), (3, 0)]
for case let (x, 0) in points {
print(x)
} // 1 3
可选模式(Optional Pattern)
//.some(let x)等同于 let x?
let age: Int? = 42
if case .some(let x) = age {print(x)}
if case let x? = age { print(x)} //age为非空则匹配成功,并且解包给x
let ages: [Int?] = [nil, 2, 3, nil, 5]
//age为不为nil的可选型,符合则自动解包
for case let age? in ages {
print(age)
}
//下面的代码与上面的代码实现效果一致
for item in ages {
//item如果为非空可选,则自动解包赋值给age
if let age = item {
print(age)
}
}
func check(_ num: Int?) {
switch num {
case 2?: print("2") //如果num为非nil的可选型2,输出2
case 4?: print("4")
case 6?: print("6")
case _?: print("other")
case _: print("nil")
}
}
check(4) //4
check(8) //other
check(nil) //nil
类型转换模式(Type- Casting Pattern)
let num = 6
switch num {
case is Int:
//num是Int类型
print("is Int", num)
default:
break
} //输出 is Int 6
let num1: Any = 6
switch num1 {
case is Int:
//num依然是Any类型,但是Any是任意类型,可以认为是Int,所以会进入这个case
print("is Int", num)
default:
break
} //输出 is Int 6
let num: Any = 6
switch num {
//num如果可以转换为Int类型,就把转换后的值给n
case let n as Int:
//num依然是Any类型,只是它转换后的n是Int类型
print("as Int", n + 1)
default:
break
} // 输出 as Int 7
实际用例:
class Animal {
func eat() {print(type(of: self), "eat")}
}
class Dog: Animal {
func run() {
print(type(of: self), "run")
}
}
class Cat: Animal {
func jump() {
print(type(of: self), "jump")
}
}
func check(_ animal: Animal) {
switch animal {
//看能否吧animal转换为Dog类型,如果可以,则把转换后的值给dog变量
case let dog as Dog:
dog.eat()
dog.run()
case is Cat:
//编译器认为现在的animal是Animal类型,只能调用animal的eat()方法,不能调用Cat的jump方法
animal.eat()
//这里的animal不能直接调用Cat的jump()方法,除非强制转换成Cat类型
// (animal as? Cat)?.jump()
default:
break
}
}
check(Dog())
//Dog eat
//Dog run
check(Cat())
//typeof最终看调用的实际对象类型,所以是Cat类型
//Cat eat
表达式模式(Expression Pattern)
- 表达模式用在case中
let point = (1, 2)
switch point {
case (0, 0):
print("(0, 0) is at the origin.")
case(-2...2, -2...2):
print("(\(point.0),\(point.1)) is near the origin.")
default:
print("The point is at (\(point.0),\(point.1)).")
} //输出:(1,2) is near the origin.
通果反汇编运算,我们可以看到这实际上是通过~=这个符号实现的表达式匹配,所以想要自定义表达式模式匹配,需要重载~=这个运算符
自定义表达式模式
- 可以通过重载运算符,自定义表达式模式的匹配规则
struct Student {
var score = 0, name = ""
//pattern是case后的值
//value是switch后的值
static func ~= (pattern: Int, value: Student) -> Bool {
return value.score >= pattern
}
static func ~= (pattern: ClosedRange<Int>, value: Student) -> Bool {
return pattern.contains(value.score)
}
static func ~= (pattern: Range<Int>, value: Student) -> Bool {
return pattern.contains(value.score)
}
}
var stu = Student(score: 75, name: "Jack")
switch stu {
case 100: print(">= 100")
case 90: print(">= 90")
case 80..<90: print("[80, 90]")
case 60...79: print("[60, 79]")
case 0: print(">= 0")
default: break
} //输出:[60, 79]
一般情况下,写如下代码会报错,但是当重载了表达式模式匹配,就不会报错:
if case 60 = stu {
print(">= 60")
} //>= 60
var info = (Student(score: 70, name: "Jack"), "及格")
switch info {
//如下代码表示Student(score: 70, name: "Jack")和60进行匹配,"及格"和text进行匹配,当score大于60则为true,走print(text)代码
case let (60, text): print(text)
default: break
} //输出: 及格
先列举一个String判断开头结尾是什么的复杂结构的常规代码:
//prefix == "21"
//str == "123456"
func hasPerfix(_ prefix: String) -> ((String) -> Bool) {
return {
(str: String) -> Bool in
str.hasPrefix(prefix)
}
}
//suffix == "456"
//str == "123456"
func hasSuffix(_ suffix: String) -> ((String) -> Bool) {
return {
(str: String) -> Bool in
str.hasSuffix(suffix)
}
}
var fn = hasPerfix("12")
print(fn("123456")) //true
var fn1 = hasSuffix("456")
print(fn1("123456")) //true
接下来用重载运算符的方式,自定义表达式模式的匹配规则:
extension String {
static func ~= (pattern: (String) -> Bool, value: String) -> Bool {
return pattern(value)
}
}
func hasPerfix(_ prefix: String) -> ((String) -> Bool) {
//$0表示第一个参数
return { $0.hasPrefix(prefix) }
}
func hasSuffix(_ suffix: String) -> ((String) -> Bool) {
return { $0.hasSuffix(suffix) }
}
var str = "123456"
switch str {
case hasPerfix("12"), hasSuffix("456"):
print("以12开头或者以456结尾")
default:
break
} // 输出:以12开头或者以456结尾
//var str = "123456"
//switch str {
//case hasPerfix("12"):
// print("以12开头")
//case hasSuffix("456"):
// print("以456结尾")
//default:
// break
//} //输出:以12开头
类似上面的例子:
扫描二维码关注公众号,回复:
14574790 查看本文章

- 接下来列举一个重载运算符实现新的运算符功能的例子:
1. 原始写法:
func greaterThan(_ num: Int) -> (Int) -> Bool {
return {
(i: Int) -> Bool in
return i > num
}
}
var fn = greaterThan(5)
print(fn(10)) //true
2. 自定义表达模式的匹配原则:
extension Int {
static func ~= (pattern: (Int) -> Bool, value: Int) -> Bool {
return pattern(value)
}
}
func greaterThan1(_ num: Int) -> (Int) -> Bool {
return { $0 > num }
}
var age = 10
switch age {
case greaterThan(5):
print(age, "大于5")
default: break
} // 输出:10 大于5
3. 重写比较运算符
extension Int {
static func ~= (pattern: (Int) -> Bool, value: Int) -> Bool {
return pattern(value)
}
}
prefix operator ~>
prefix operator ~>=
prefix operator ~<
prefix operator ~<=
prefix func ~> (_ i: Int) -> ((Int) -> Bool) { return { $0 > i} }
prefix func ~>= (_ i: Int) -> ((Int) -> Bool) { return { $0 >= i} }
prefix func ~< (_ i: Int) -> ((Int) -> Bool) { return { $0 < i} }
prefix func ~<= (_ i: Int) -> ((Int) -> Bool) { return { $0 <= i} }
var age = 9
switch age {
case ~>=0:
print("1")
case ~>10:
print("2")
default:
break
} //输出:1
- 在列举一个简单奇偶数判定的例子
func isEven(_ i: Int) -> Bool { return i % 2 == 0}
func isOdd(_ i: Int) -> Bool { return i % 2 != 0}
extension Int {
static func ~= (pattern: (Int) -> Bool, value: Int) -> Bool {
return pattern(value)
}
}
var age = 11
switch age {
case isEven:
print("偶数")
case isOdd:
print("奇数")
default:
print("其他")
} // 输出: 奇数
Where
- 可以使用where为模式匹配增加条件
switch case中的where用例:
var data = (10, "jack")
switch data {
case let (age, _) where age > 10:
print(data.1, "age>10")
case let (age, _) where age > 0:
print(data.1, "age>0")
default:
break
} //jack age>0
for循环中的where用例:
var ages = [10, 20 , 44, 23, 55]
for age in ages where age > 30 {
print(age)
} //44 55
协议中关联类型的where用例:
protocol Stackable { associatedtype Element}
protocol Container {
associatedtype Stack : Stackable where Stack.Element : Equatable
}
泛型中的where用例:
func equal<S1: Stackable, S2:Stackable>(_ s1:S1, _s2:S2) -> Bool where S1.Element == S2.Element, S1.Element : Hashable{
return false
}
扩展中的where用例:
extension Container where Self.Stack.Element : Hashable { }