模式

模式是用来匹配的规则 如case 捕捉错误的catch if/guard/while/for 语句的条件等

模式类型

1.通配符模式 
2.标识符模式
3.值绑定模式
4.元祖模式
5.枚举case模式 
6.可选模式
7.类型转换模式
8.表达式模式

通配符模式

_ 匹配任何值

_? 匹配非nil值

enum Life {
    case human(name: String, age: Int?)
    case animal(nam: String, age: Int?)
}

func  check(_ life: Life){
    switch life {
    case .human(let name, _):
        print(name)
    case .animal(let name, _?):
        print(name)
    default:
        print("other")
    }
}

标识符模式

给对应的常量 变量名赋值

值绑定模式

E1DD75A3-566D-47D2-A9DC-22EFCC938DB7.png

元组模式

let point = [(0,0),(1,0)]
for (x, _) in point {
    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")
}

枚举case模式

if case 等价于只有一个case的switch语句
case 匹配的意思

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

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

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

可选模式

可选类型是枚举 只有2个case some none

let age: Int? = 42
if case .some(let x) = age {
    print(x)
}
if case let x? = age {
    print(x)
}

类型转换模式

let num: Any = 6
switch num {
case is Int:
    print("Int")
case let n as Int:
   print("Int")
default:
    break
}

is Int 判断是否为Int类型 as是强转 但是 只是影响的n的类型 num的类型是不会改变的

表达式模式

表达式模式用在case中

通过重载运算符 自定义表达式模式的匹配规则 也就是~=

自定义表达式模式

struct Student {
    
    var score = 0, name = ""
    //pattern case后面的内容
    //value   switch后面的内容
    static func ~= (pattern: Int, value: Student) -> Bool {
         return value.score >= pattern
    }
    static func ~= (pattern: Range<Int>, value: Student) -> Bool {
        return pattern.contains(value.score)
    }
    static func ~= (pattern: ClosedRange<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 ...bbnnhnnn79:  print("[60,79]")
case 0:  print(">= 0")
default:  break
}

var info = (Student(score: 70, name: "Jack"), "及格")
switch info {
case let (60, text):
    print(text)
default:
    break
}

及格

3C7DF87B-7EB2-4547-ACD3-0658969E590A.png

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 = 8
switch age {
case isEven:
    print("偶数")
case isOdd:
    print("急数")
default:
    break
}

偶数

prefix operator >=

extension Int {

    static func ~= (pattern: (Int) -> Bool, value: Int) -> Bool {
        return pattern(value)
    }
    //>= 系统定义的时候是中缀运算符 要把他强制定义为前缀运算符 需要prefix operator >= 这样定义
    //但是 如此设置 有可能会对其他地方产生影响
    prefix static func >= (value: Int) -> (Int) -> Bool {
        
        return { $0 >= 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}
}

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


var age = 9
switch age {
case ~>=0,~<=10:
    print("1")
case ~>10,~<20:
    print("2")
default:
    break
}

where

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