模式匹配

通配符模式

通配符就是 _ 可以匹配任何值,_?匹配非nil

enum Life {
    case human(name:String,age:Int?)
    case animal(name:String,age:Int?)
}
let l1 = Life.human(name: "人", age: 10)
let l2 = Life.human(name: "人1", age: nil)
let l3 = Life.animal(name: "猫", age: 3)
let l4 = Life.animal(name: "狗", age: nil)
func check(_ life:Life)
{
    switch life {
    case .human(let name,_):
        print(name)
    case .animal(let name,_?):
        print(name)
    default:
        print("不知道是什么品种")
    }
}
check(l1)  //人
check(l2)  //人1
check(l3)  //猫
check(l4)  //不知道是什么品种

上面代码可以看到age传nil,则switch也匹配不到狗的信息,原因就是_?只能匹配非空

标识符模式

var name = "yokan"
var age = 10

右边是字面量,左边是标识符

值绑定模式

不多说了,上面的case就是值绑定模式,只是用了通用匹配符而已

元祖模式

let points = [(1,2),(2,3),(0,4)]
for (x,_) in points
{
    print(x)    //1
                //2
                //0
}

没啥好说的,返回值也可以这样

枚举Case模式

let num = 2
func test() {
    if case 0...9 = num
    {
        print("num在0-9之间")
    }
    
    guard case 3...9 = num else
    {
        print("num不在3-9之间")
        return
    }
}

test()

等价于0<=num<=9,同时if-case等价于switch-case

switch num
{
    case 0...9 :
        print("num在0-9之间")
    default :
        print("the other")
}

case模式还有for - case  

for case nil in [1,2,4,nil]{ print("有nil"); break}

for case let x in [1,2,4,nil]{ print(x) }

总结一句话case模式默认前面有个switch,是个浓缩版的switch

可选模式

let num:Int? = 4
let num1:Int? = nil
func test(_ x:Int?)
{
    if case let x? = x
    {
        print(x)
    }
}
test(num)    //4
test(num1)  //什么都不会输出,因为不符合

类型转换模式

let num:Any = 10
switch num {
    case is Int:
        print(num)
    default:
        print("nop")
}

判断是否Int

let num:Any = 10
switch num {
    case let x as Int:
        print(x)
    default:
        print("nop")
}

是否能转换

表达式模式

struct Stu
{
    var name:String
    var score:Int
    static func ~= (pattern:Int,stu:Stu) -> Bool
    {
        return stu.score == pattern
    }
    static func ~= (pattern:Range<Int>,stu:Stu) ->Bool
    {
        pattern.contains(stu.score)
    }
    static func ~= (pattern:ClosedRange<Int>,stu:Stu) ->Bool
    {
        pattern.contains(stu.score)
    }
}
var stu1 = Stu(name: "yokan", score: 50)
switch stu1
{
case 100:
    print("great")
case 90..<100:
    print("S")
case 80..<90:
    print("A")
case 60...79:
    print("B")
case 0..<60:
    print("不及格")
default:
    print("找不到")
}

其中pattern:Int 对应普通数字.  pattern:Range<Int>对应 ..<非闭区间  pattern:ClosedRange<Int>对应闭区间,说白了,就是把case里面的内容转交给了Struct处理,前者是case后面的值,后者是switch后面的值,这个属于自定义的表达式模式

where

where的作用就是给模式匹配再加条件

enum Stu {
    case nameScore(String,Int)
}

let stu = Stu.nameScore("yokan", 10)
switch stu
{
    case let .nameScore(name, score) where score > 10:
        print(name)
    default:
        print("找不到")
}

就像这样,加一个where在原有的匹配上再加个条件