Swift_枚举

//初始类型
enum test {
    case fef
    case sdf
}


//关联值
enum test2 {
    case a(Int,Float,Bool,Int)
    case b(String)
}


//原始值
enum test31:Character {
    case a = "r"
    case b = "\n"
    case c = "s"
}

//原始值隐式赋值
enum test32:Int{
    case a = 1,b,c,d

}

enum test33:String {
    case a = "fsdf"
}



//递归枚举
indirect enum ArithmeticExpression {
    case number(Int)
    case addition(ArithmeticExpression, ArithmeticExpression)
    case multiplication(ArithmeticExpression, ArithmeticExpression)
}

import UIKit

class ViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()

        //递归枚举
        let five = ArithmeticExpression.number(5)
        let four = ArithmeticExpression.number(4)
        let sum = ArithmeticExpression.addition(five, four)
        let product = ArithmeticExpression.multiplication(sum, ArithmeticExpression.number(2))
        
        mapFunc()
    }
    
    func evaluate(_ expression: ArithmeticExpression) -> Int {
        switch expression {
        case let .number(value):
            return value
        case let .addition(left, right):
            return evaluate(left) + evaluate(right)
        case let .multiplication(left, right):
            return evaluate(left) * evaluate(right)
        }
    }
    
    func mapFunc() {
        
        //普通枚举
        var enum_a = test.fef
        enum_a = test.fef
        
        
        switch enum_a {
            
        case .fef:
            break;
            
        case .sdf:
            break;
            
        default:
            break;
        }
        
        
        //关联值枚举
        var enum_b = test2.a(10, 234.2, true, 0)
        
        switch enum_b {
            //常量每一个值
        case .a(let one, let two, let three, let four):
            print("\(one)\n\(two)\n\(three)\n\(four)\n")
            
        case .a(101, 234.2, true, 0):
            print("1")
            break
            
        case .a(10, 234.2, true, 0):
            print("2")
            break
            
        case .b("te"):
            print("3")

            break
            
        default:
            print("dfsd")
            
        }
        

        
        //原始值、原始值隐式赋值
        var value_num = test32.c.rawValue  //value_num = 3
        
        let value_num2 = test31.a.rawValue //value_num2 = "r"
        
        
        
        //使用原始值初始化枚举实例
        let f = 3
        if let s = test32(rawValue:f) {
            
            switch s {
            case .a:
                break
                
            case .b:
                break
                
            case .c:
                break
                
            case .d:
                break
                
            default:
                print("no value for f")
            }
        }
        
    }
    
    
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }
    
    
}