iOS-Swift-字面量、模式匹配

一. 字面量（Literal）

下面代码中的10、false、"Jack"都是字面量

var age = 10
var isRed = false
var name = "Jack"

Swift源码规定，常见字面量的默认类型：

public typealias IntegerLiteralType = Int
public typealias FloatLiteralType = Double
public typealias BooleanLiteralType = Bool
public typealias StringLiteralType = String

可以通过typealias修改字面量的默认类型

typealias FloatLiteralType = Float
typealias IntegerLiteralType = UInt8
var age = 10 // UInt8
var height = 1.68 // Float

Swift自带的绝大部分类型，都支持直接通过字面量进行初始化，如下：

Bool、Int、Float、Double、String、Array、Dictionary、Set、Optional等

1. 字面量协议

Swift自带类型之所以能够通过字面量初始化，是因为它们遵守了对应的协议

• Bool : ExpressibleByBooleanLiteral
• Int : ExpressibleByIntegerLiteral
• Float、Double : ExpressibleByIntegerLiteral、ExpressibleByFloatLiteral
• Dictionary : ExpressibleByDictionaryLiteral
• String : ExpressibleByStringLiteral
• Array、Set : ExpressibleByArrayLiteral
• Optional : ExpressibleByNilLiteral

var b: Bool = false // ExpressibleByBooleanLiteral
var i: Int = 10 // ExpressibleByIntegerLiteral
var f0: Float = 10 // ExpressibleByIntegerLiteral
var f1: Float = 10.0 // ExpressibleByFloatLiteral
var d0: Double = 10 // ExpressibleByIntegerLiteral
var d1: Double = 10.0 // ExpressibleByFloatLiteral
var s: String = "jack" // ExpressibleByStringLiteral
var arr: Array = [1, 2, 3] // ExpressibleByArrayLiteral
var set: Set = [1, 2, 3] // ExpressibleByArrayLiteral
var dict: Dictionary = ["jack" : 60] // ExpressibleByDictionaryLiteral
var o: Optional<Int> = nil // ExpressibleByNilLiteral

2. 字面量协议的应用

让Int类型遵守ExpressibleByBooleanLiteral协议，这样就能通过Bool字面量来初始化Int类型数据

//有点类似于C++中的转换构造函数
extension Int : ExpressibleByBooleanLiteral {
    public init(booleanLiteral value: Bool) {
        self = value ? 1 : 0
    }
}
var num: Int = true //通过Bool字面量来初始化Int类型数据
print(num) // 1

使用Int、Double、String类型字面量来初始化Student对象

class Student : ExpressibleByIntegerLiteral, ExpressibleByFloatLiteral, ExpressibleByStringLiteral, CustomStringConvertible {
    var name: String = ""
    var score: Double = 0
    required init(floatLiteral value: Double) { self.score = value }
    required init(integerLiteral value: Int) { self.score = Double(value) }
    required init(stringLiteral value: String) { self.name = value } //使用一般String
    required init(unicodeScalarLiteral value: String) { self.name = value } //unicode表情
    required init(extendedGraphemeClusterLiteral value: String) { self.name = value } //特殊字符
    var description: String { "name=\(name),score=\(score)" }
}
var stu: Student = 90
print(stu) // name=,score=90.0
stu = 98.5
print(stu) // name=,score=98.5
stu = "Jack"
print(stu) // name=Jack,score=0.0

使⽤数组、字典字⾯量初始化Point

struct Point {
    var x = 0.0, y = 0.0
}
extension Point : ExpressibleByArrayLiteral, ExpressibleByDictionaryLiteral { 
    init(arrayLiteral elements: Double...) { //使用数组初始化
    guard elements.count > 0 else { return }
    self.x = elements[0]
    guard elements.count > 1 else { return }
    self.y = elements[1]
}
    init(dictionaryLiteral elements: (String, Double)...) { //使用字典初始化
        for (k, v) in elements {
            if k == "x" { self.x = v }
            else if k == "y" { self.y = v }
        }
    }
}
var p: Point = [10.5, 20.5]
print(p) // Point(x: 10.5, y: 20.5)
p = ["x" : 11, "y" : 22]
print(p) // Point(x: 11.0, y: 22.0)

二. 模式匹配

什么是模式(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）

1. 通配符模式（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(.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

2. 标识符模式（Identifier Pattern）

给对应的变量、常量名赋值

var age = 10 
let name = "jack"

3. 值绑定模式（Value-Binding Pattern）

let point = (3, 2)
switch point {
case let (x, y):
    print("The point is at (\(x), \(y)).")
}

4. 元组模式（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) {
    //要求，第一个非空值，第二个任何值，第三个是可以转成String的值，第三个不符合，所以匹配失败，打印default
    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)
}

5. 枚举Case模式（Enumeration Case Pattern）

if case语句等价于只有1个case的switch语句

原来的写法：

let age = 2
if age >= 0 && age <= 9 {
    print("[0, 9]")
}

switch：

switch age {
    case 0...9:
        print("[0, 9]")
    default:
        break
}

枚举Case模式：

if case 0...9 = age {
    print("[0, 9]")
}

guard case：

guard case 0...9 = age else { return }
print("[0, 9]")

for case：

let ages: [Int?] = [2, 3, nil, 5]
for case nil in ages { //匹配nil值
    print("有nil值")
    break
} //有nil值
 
let points = [(1, 0), (2, 1), (3, 0)]
for case let (x, 0) in points {
    print(x)
} //1 3

6. 可选模式（Optional Pattern）

let age: Int? = 42
if case .some(let x) = age { print(x) } //age非空就打印
if case let x? = age { print(x) } //age非空就打印，和上面效果一样，更简洁

let ages: [Int?] = [nil, 2, 3, nil, 5]
for case let age? in ages { //age?是匹配非空值
    print(age)
} //2 3 5

//下面这种先取出来再通过可选绑定来判断是否有值，是我们最常用的方式
//跟上面的for case效果是一样的，上面更简洁
let ages: [Int?] = [nil, 2, 3, nil, 5]
for item in ages {
    if let age = item {
        print(age)
    }
} //2 3 5

func check(_ num: Int?) {
    switch num {
        case 2?: print("2") //非空并且里面包装的是2
        case 4?: print("4") //非空并且里面包装的是4
        case 6?: print("6") //非空并且里面包装的是6
        case _?: print("other") //非空
        case _: print("nil")  //任意值
    }
}
check(4) // 4
check(8) // other
check(nil) // nil

7. 类型转换模式（Type-Casting Pattern）

let num: Any = 6
switch num {
case is Int: //判断num是否是Int类型
    //上面仅仅是判断num是否是Int类型，编译器并没有进行强转，编译器依然认为num是Any类型
    print("is Int", num) 
case let n as Int: //判断能不能将num强转成Int，如果可以就强转，然后赋值给n，最后n是Int类型，num还是Any类型
    print("as Int",n) 
default:
    break
}

//type(of: self)可以获取当前方法调用者是谁
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 {
    case let dog as Dog: //传进来是Animal类型，强转成Dog，下⾯两个⽅法就可以调
        dog.eat()
        dog.run()
    case is Cat:
        //传进来是Animal类型，没强转成Cat，编译器认为还是Animal，只能调eat，最终实际调⽤的还是Cat的eat⽅法
        animal.eat() //如果真想调⽤jump只能强转：(animal as? Cat)?.jump()
        default: break
    }
}
// Dog eat
// Dog run
check(Dog())
// Cat eat
check(Cat())

8. 表达式模式（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.

复杂的case匹配⾥⾯其实调⽤了~=运算符来匹配，我们可以重载~=运算符来重新定制匹配规则，如下：

1. 自定义表达式模式的匹配规则：

可以通过重载~=运算符，自定义表达式模式的匹配规则，这也是函数式编程的思想的体现

示例1：⾃定义Student和Int的匹配规则

pattern：case后面的内容
value：switch后面的内容

struct Student { var score = 0, name = ""
    //⾃定义Student和Int的匹配规则
    static func ~= (pattern: Int, value: Student) -> Bool { value.score >= pattern }
    //⾃定义Student和闭区间的匹配规则
    static func ~= (pattern: ClosedRange<Int>, value: Student) -> Bool { pattern.contains(value.score) }
    //⾃定义Student和开区间的匹配规则
    static func ~= (pattern: Range<Int>, value: Student) -> Bool { 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语句等价于只有1个case的switch语句，所以也可以这么写：

if case 60 = stu { //将student对象和60匹配
    print(">= 60")
} // >= 60

把Student对象放到元祖里面，这时候就是把Student和60匹配，如果匹配成功就将及格和text绑定，如下：

var info = (Student(score: 70, name: "Jack"), "及格")
switch info {
case let (60, text): print(text) //如果匹配成功就将及格和text绑定
default: break
} // 及格

示例2：⾃定义String和函数(带参数)的匹配规则

extension String {
    static func ~= (pattern: (String) -> Bool, value: String) -> Bool {
        pattern(value) //调用一下这个函数，将value传进去
    }
}

//接收一个String返回一个函数
func hasPrefix(_ prefix: String) -> ((String) -> Bool) { { $0.hasPrefix(prefix) } }
func hasSuffix(_ suffix: String) -> ((String) -> Bool) { { $0.hasSuffix(suffix) } }

var str = "jack"
switch str {
case hasPrefix("j"), hasSuffix("k"): //两个条件只需要满足一个
    print("以j开头或者以k结尾")
default: break
} //以j开头或者以k结尾

所以重写~=把str和函数进⾏匹配，这样只是学习怎么⾃定义表达式模式，其实使⽤系统的那两个函数更简单。

上面的hasPrefix、hasSuffix⽅法是传⼊⼀个prefix，return⼀个函数，只不过上面是简写的，完整写法如下：

func hasPrefix(_ prefix: String) -> ((String) -> Bool) {
    return {
    (str:String) -> Bool in
    str.hasPrefix(prefix)
    }
}

func hasSuffix(_ suffix: String) -> ((String) -> Bool) {
    return {
    (str:String) -> Bool in
    str.hasSuffix(suffix)
    }
}

示例3：⾃定义Int和函数的匹配规则

func isEven(_ i: Int) -> Bool { i % 2 == 0 }
func isOdd(_ i: Int) -> Bool { i % 2 != 0 }

extension Int {
    static func ~= (pattern: (Int) -> Bool, value: Int) -> Bool {
        pattern(value)
    }
}

var age = 9
switch age {
case isEven:
    print("偶数")
case isOdd:
    print("奇数")
default:
    print("其他")
}

示例4：⾃定义Int和⾃定义运算符的匹配规则

这个例⼦和示例3本质是⼀样的，因为运算符的本质也是函数

prefix operator ~>
prefix operator ~>=
prefix operator ~<
prefix operator ~<=

extension Int {
    static func ~= (pattern: (Int) -> Bool, value: Int) -> Bool {
        return
        pattern(value) //调用一下这个函数，将value传进去
    }
    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 = 15
switch age {
case ~<=0:
    print("1")
case ~>10:
    print("2")
default: break
} // 2

补充：where

可以使用where为模式匹配增加匹配条件

在case后面：

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
}

在for循环后面：

var ages = [10, 20, 44, 23, 55]
for age in ages where age > 30 {
    print(age)
} // 44 55

在关联类型后面：

protocol Stackable { associatedtype Element }
protocol Container {
    associatedtype Stack : Stackable where Stack.Element : Equatable
}

在函数返回值后面给泛型做一些约束：

func equal<S1: Stackable, S2: Stackable>(_ s1: S1, _ s2: S2) -> Bool
    where S1.Element == S2.Element, S1.Element : Hashable {
    return false
}

带条件的协议的扩展：

extension Container where Self.Stack.Element : Hashable { }