望其项背 iOS - swift: 枚举(枚举基础,省略枚举类型的枚举值,指定原始类型的枚举值,遍历枚举值,枚举值是一个关联值,通过 switch 判断枚举值,通过 if 判断枚举值,枚举递归,枚举中的方法,枚举中的下标)

项目地址 https://github.com/webabcd/IosDemo
作者 webabcd

望其项背 iOS - swift: 枚举(枚举基础,省略枚举类型的枚举值,指定原始类型的枚举值,遍历枚举值,枚举值是一个关联值,通过 switch 判断枚举值,通过 if 判断枚举值,枚举递归,枚举中的方法,枚举中的下标)

示例如下:

SwiftView07.swift

/*
 * 本例用于演示枚举(枚举基础,省略枚举类型的枚举值,指定原始类型的枚举值,遍历枚举值,枚举值是一个关联值,通过 switch 判断枚举值,通过 if 判断枚举值,枚举递归,枚举中的方法,枚举中的下标)
 */

import SwiftUI

struct SwiftView07: View {
    
    var result: String = "";
    
    init() {
        result = sample1() // 枚举基础,省略枚举类型的枚举值,指定原始类型的枚举值
        result += "\n";
        result += sample2() // 遍历枚举值
        result += "\n";
        result += sample3() // 枚举值是一个关联值,通过 switch 判断枚举值,通过 if 判断枚举值
        result += "\n";
        result += sample4() // 枚举递归
        result += "\n";
        result += sample5() // 枚举中的方法,枚举中的下标
    }

    var body: some View {
        VStack {
            HStack {
                Text(result)
                Spacer()
            }
            Spacer()
        }
    }
    
    func sample1() -> String {
        // 指定一个枚举值
        var a = Enum1.e1 // 枚举值是 Enum1.e1
        // 修改枚举值(如果枚举类型确定了,则可以省略枚举类型)
        a = .e2 // 枚举值是 Enum1.e2
        
        // 如果枚举类型确定了,则可以省略枚举类型
        let b: Enum1 = .e3  // 枚举值是 Enum1.e3
        
        // 原始类型为 Int 的枚举
        let c = Enum2.e2  // 枚举值是 Enum2.e2
        let d = c.rawValue // 枚举值 Enum2.e2 的原始值是 101
        
        // 通过指定枚举的原始值来初始化枚举
        let e = Enum2(rawValue: 101) // 这是一个可空类型,e! 是 Enum2.e2
        let f = Enum2(rawValue: 0) // 这是一个可空类型,f 是 nil
        
        return "\(a), \(b), \(c), \(d), \(e!), \(f)"
    }
    // 定义一个枚举
    // 注意:枚举值并不是整型,Enum1.e1 的枚举值就是 Enum1.e1,并不是 0 之类的
    enum Enum1 {
        case e1
        case e2
        case e3, e4, e5
    }
    // 定义一个指定了原始类型的枚举
    // 下面这个枚举的原始类型是 Int 类型,可以通过类似 Enum2.e1.rawValue 获取枚举值的原始值
    enum Enum2: Int {
        case e1 = 100 // 指定此枚举值的原始值为 100
        case e2       // 此枚举值的原始值为 101
        case e3       // 此枚举值的原始值为 102
    }

    
    
    func sample2() -> String {
        // 支持 CaseIterable 协议的枚举可以通过 allCases 遍历枚举值
        for item in Enum3.allCases {
            print(item)
        }
        
        return ""
    }
    // 将枚举标记为支持 CaseIterable 协议(这样就可以通过 allCases 遍历枚举值了)
    enum Enum3: CaseIterable {
        case e1
        case e2
        case e3
    }
    
    
    
    func sample3() -> String {
        let a: Enum4 = .e1
        let b: Enum4 = .e2(1, 2) // 初始化一个枚举值(此枚举值是一个关联值)
        
        // 通过 switch 判断枚举值
        switch a {
        case .e1:
            print("a is .e1")
        default :
            print("impossible")
        }
        
        // 通过 switch 判断枚举值(此枚举值是一个关联值)
        switch b {
        case .e2(_, _): // 类似的 case .e2(1, _):, case .e2(_, 2):, case .e2(1, 2): 之类的就不详细说了
            print("a is .point")
        default :
            print("impossible")
        }
        
        // 通过 switch 判断枚举值(此枚举值是一个关联值)
        switch b {
        case let .e2(x, y): // 将枚举值的关联值赋值给 x 和 y,类似的还有 let .e2(_, y):, let .e2(x, _):, let .e2(1, y):, let .e2(x, 2): 之类的就不详细说了
            print("\(x), \(y)")
        default :
            print("impossible")
        }
        
        // 通过 if 判断枚举值
        if case .e2(_, 2) = b {
            print("case .e2(_, 2) = b")
        }
        
        // 通过 if 判断枚举值
        if case .e1 = a {
            print("case .e1 = a")
        }
        
        return "\(a), \(b)"
    }
    enum Enum4 {
        case e1
        // 枚举值是一个关联值
        // 下面这个枚举值是由 2 个 Int 类型的数据决定的
        case e2(Int, Int)
    }
    
    
    
    func sample4() -> String {
        let a = Enum5.e1
        let b = Enum5.e2(a)
        
        return "\(a), \(b)"
    }
    // 通过 indirect 修饰的枚举可以支持枚举递归
    indirect enum Enum5 {
        case e1
        case e2(Enum5) // 枚举递归
    }
    
    
    
    func sample5() -> String {
        var a: Enum6 = .e1
        print(a) // e1
        a.next() // 调用枚举中的方法(这个是实例方法)
        print(a) // e2
        a.next()
        print(a) // e3
        a.next()
        print(a) // e1
        
        let b = Enum6[0] // 调用枚举中的下标(这个是类下标)
        print(b) // e1
        
        return ""
    }
    enum Enum6: Int {
        case e1 = 0, e2, e3
        
        // 枚举中的方法(关于方法的更多说明请参见 SwiftView09.swift)
        // 这个是实例方法
        mutating func next() {
            switch self {
            case .e1:
                self = .e2
            case .e2:
                self = .e3
            case .e3:
                self = .e1
            }
        }
        
        // 枚举中的下标(关于下标的更多说明请参见 SwiftView09.swift)
        // 这个是类下标
        static subscript(rawValue: Int) -> Enum6 {
            return Enum6(rawValue: rawValue)!
        }
    }
}

项目地址 https://github.com/webabcd/IosDemo
作者 webabcd

posted @ 2021-06-29 09:09  webabcd  阅读(9)  评论(0编辑  收藏  举报