Swift-进阶 08：枚举enum

print(Week.MON.rawValue)
let w = Week.MON.rawValue

print(Week.init(rawValue: "MON"))

print(Week.init(rawValue: "MON"))
print(Week.init(rawValue: "Hello"))
<!--打印结果-->
Optional(_6_EnumTest.Week.MON)
nil

- `struct_extract` 表示`取出当前的Int值`，Int类型在系统中也是结构体
- `cond_br` 表示比较的表达式，即分支条件跳转
    - 如果匹配成功，则构建一个`.some的Optional`返回
    - 如果匹配不成功，则继续匹配，知道最后还是没有匹配上，则构建一个`.none的Optional`返回

@_semantics("findStringSwitchCase")
public // COMPILER_INTRINSIC
// 接收一个数组 + 需要匹配的string
func _findStringSwitchCase( 
  cases: [StaticString],
  string: String) -> Int {
// 遍历之前创建的字符串数组，如果匹配则返回对应的index
  for (idx, s) in cases.enumerated() {
    if String(_builtinStringLiteral: s.utf8Start._rawValue,
              utf8CodeUnitCount: s._utf8CodeUnitCount,
              isASCII: s.isASCII._value) == string {
      return idx
    }
  }
  // 如果不匹配，则返回-1
  return -1
}

//注：当使用了关联值后，就没有RawValue了，主要是因为case可以用一组值来表示，而rawValue是单个的值
enum Shape{
    //case枚举值后括号内的就是关联值，例如 radius
    case circle(radius: Double)
    case rectangle(width: Int, height: Int)
}

enum Shape{
    //case枚举值后括号内的就是关联值，例如 radius
    case circle(Double)
    case rectangle(Int, Int)
}

<!--创建-->
var circle = Shape.circle(radius: 10.0)
<!--重新分配-->
circle = Shape.rectangle(width: 10, height: 10)

enum Week: String{
    case MON
    case TUE
    case WED
    case THU
    case FRI
    case SAT
    case SUN
}
var current: Week?
switch current {
    case .MON:print(Week.MON.rawValue)
    case .TUE:print(Week.MON.rawValue)
    case .WED:print(Week.MON.rawValue)
    default:print("unknow day")
}
<!--打印结果-->
unknow day

enum Shape{
    case circle(radius: Double)
    case rectangle(width: Int, height: Int)
}
let shape = Shape.circle(radius: 10.0)
switch shape{
    //相当于将10.0赋值给了声明的radius常量
    case let .circle(radius):
        print("circle radius: \(radius)")
    case let .rectangle(width, height):
        print("rectangle width: \(width) height: \(height)")
}
<!--打印结果-->
circle radius: 10.0

enum Shape{
    case circle(radius: Double)
    case rectangle(width: Int, height: Int)
}
let shape = Shape.circle(radius: 10)
switch shape{
    //做了Value-Binding，相当于将10.0赋值给了声明的radius常量
    case .circle(let radius):
        print("circle radius: \(radius)")
    case .rectangle(let width, var height):
        height += 1
        print("rectangle width: \(width) height: \(height)")
}
<!--打印结果-->
circle radius: 10.0

enum Shape{
    case circle(radius: Double)
    case rectangle(width: Int, height: Int)
}
let circle = Shape.circle(radius: 10)
<!--匹配单个case-->
if case let Shape.circle(radius) = circle {
    print("circle radius: \(radius)")
}

enum Shape{
    case circle(radius: Double)
    case rectangle(width: Double, height: Double)
    case square(width: Double, height: Double)
}
let shape = Shape.circle(radius: 10)
switch shape{
case let .circle(x), let .square(20, x):
    print(x)
default:
    break
}

enum Shape{
    case circle(radius: Double)
    case rectangle(width: Double, height: Double)
    case square(width: Double, height: Double)
}
let shape = Shape.rectangle(width: 10, height:20)
switch shape{
case let .rectangle(_, x), let .square(_, x):
    print("x = \(x)")
default:
    break
}
<!--另一种方式-->
enum Shape{
    case circle(radius: Double)
    case rectangle(width: Double, height: Double)
    case square(width: Double, height: Double)
}
let shape = Shape.rectangle(width: 10, height:20)
switch shape{
case let .rectangle(x, _), let .square(_, x):
    print("x = \(x)")
default:
    break
}

enum CombineDirect{
    //枚举中嵌套的枚举
    enum BaseDirect{
        case up
        case down
        case left
        case right
    }
    //通过内部枚举组合的枚举值
    case leftUp(baseDIrect1: BaseDirect, baseDirect2: BaseDirect)
    case leftDown(baseDIrect1: BaseDirect, baseDirect2: BaseDirect)
    case rightUp(baseDIrect1: BaseDirect, baseDirect2: BaseDirect)
    case rightDown(baseDIrect1: BaseDirect, baseDirect2: BaseDirect)
}
//使用
let leftUp = CombineDirect.leftUp(baseDIrect1: CombineDirect.BaseDirect.left, baseDirect2: CombineDirect.BaseDirect.up)

//结构体嵌套枚举
struct Skill {
    enum KeyType{
        case up
        case down
        case left
        case right
    }
    let key: KeyType
    func launchSkill(){
        switch key {
        case .left, .right:
            print("left, right")
        case .up, .down:
            print("up, down")
        }
    }
}

enum Shape{
    case circle(radius: Double)
    case rectangle(width: Double, height: Double)
    //编译器报错：Enums must not contain stored properties 不能包含存储属性，因为enum本身是值类型
//    var radius: Double
    //计算属性 - 本质是方法（get、set方法）
    var with: Double{
        get{
            return 10.0
        }
    }
    //类型属性 - 是一个全局变量
    static let height = 20.0
}

enum Week: Int{
    case MON, TUE, WED, THU, FRI, SAT, SUN
    mutating func nextDay(){
        if self == .SUN{
            self = Week(rawValue: 0)!
        }else{
            self = Week(rawValue: self.rawValue+1)!
        }
    }
}
<!--使用-->
var w = Week.MON
w.nextDay()
print(w)

//用枚举表示链表结构
enum List<T>{
    case end
    //表示case使是引用来存储
    indirect case node(T, next: List<T>)
}
<!--也可以将indirect放在enum前-->
//表示整个enum是用引用来存储
indirect enum List<T>{
    case end
    case node(T, next: List<T>)
}

You indicate that an enumeration case is recursive by writing indi rect before it, which tells the compiler to insert the necessary l ayer of indirection.

enum List<T>{
    case end
    indirect case node(T, next: List<T>)
}
print(MemoryLayout<List<Int>>.size)
print(MemoryLayout<List<Int>>.stride)
<!--打印结果-->
8 //size大小是8
8 //stride大小是8

enum List<T>{
    case end
    indirect case node(T, next: List<T>)
}
var node = List<Int>.node(10, next: List<Int>.end)
print(MemoryLayout.size(ofValue: node))
print(MemoryLayout.stride(ofValue: node))

<!--swift中定义-->
@objc enum Week: Int{
    case MON, TUE, WED, THU, FRI, SAT, SUN
}
<!--OC使用-->
- (void)test{
    Week mon = WeekMON;
}

<!--OC定义-->
//会自动转换成swift的enum
NS_ENUM(NSInteger, OCENUM){
    Value1,
    Value2
};
<!--swift使用-->
//1、将OC头文件导入桥接文件
#import "CJLTest.h"
//2、使用
let ocEnum = OCENUM.Value1

typedef enum {
    Num1,
    Num2
}OCNum;
<!--swift中使用-->
let ocEnum = OCNum.init(0)
print(ocEnum)
//*******打印结果*******
OCNum(rawValue: 0)

typedef NS_ENUM(NSInteger, CENUM){
    CEnumInvalid = 0,
    CEnumA = 1,
    CEnumB,
    CEnumC
};

@objc enum Week: Int{
    case MON, TUE, WED
    var val: String?{
        switch self {
        case .MON:
            return "MON"
        case .TUE:
            return "TUE"
        case .WED:
            return "WED"
        default:
            return nil
        }
    }
}
<!--OC中使用-->
Week mon = WeekMON;
<!--swift中使用-->
let Week = Week.MON.val

enum NoMean{
    case a
}
print(MemoryLayout<NoMean>.size)
print(MemoryLayout<NoMean>.stride)
<!--打印结果-->
0 //size大小是0
1 //表示访问下一个NoMean的case时，需要跨越1字节的步长

enum NoMean{
    case a
    case b
}
print(MemoryLayout<NoMean>.size)
print(MemoryLayout<NoMean>.stride)
<!--打印结果-->
1 //size大小是1
1 //步长是1

enum NoMean{
    case a
    case b
    case c
    case d
}
print(MemoryLayout<NoMean>.size)
print(MemoryLayout<NoMean>.stride)
<!--打印结果-->
1
1

enum NoMean{
    case a
    case b
    case c
    case d
}
var tmp = NoMean.a
var tmp1 = NoMean.b
var tmp2 = NoMean.c
var tmp3 = NoMean.d

enum Shape{
    case circle(radius: Double)
    case rectangle(width: Double, height: Double)
}
print(MemoryLayout<Shape>.size)
print(MemoryLayout<Shape>.stride)
<!--打印结果-->
17 //size的大小是17
24 //stride的步长是24

var combine = CombineDirect.leftDown(baseDirect1: .left, baseDirect2: .down)

struct Skill {
    enum KeyType{
        case up
        case down
        case left
        case right
    }
}
print(MemoryLayout<Skill>.size)
print(MemoryLayout<Skill>.stride)
<!--打印结果-->
0 //size的大小取决于成员变量，但是struct中目前没有属性
1

struct Skill {
    enum KeyType{
        case up
        case down
        case left
        case right
    }
    let key: KeyType //1字节
    var height: UInt8 //1字节
    func launchSkill(){
        switch key {
        case .left, .right:
            print("left, right")
        case .up, .down:
            print("up, down")
        }
    }
}
print(MemoryLayout<Skill>.size)
print(MemoryLayout<Skill>.stride)
<!--打印结果-->
2
2

struct Skill {
    enum KeyType{
        case up
        case down
        case left
        case right
    }
    var width: Int //8字节
    let key: KeyType //1字节
    var height: UInt8 //1字节
    func launchSkill(){
        switch key {
        case .left, .right:
            print("left, right")
        case .up, .down:
            print("up, down")
        }
    }
}
print(MemoryLayout<Skill>.size)
print(MemoryLayout<Skill>.stride)
<!--打印结果-->
10 //size大小（与OC中的结构体大小计算是一致的，min(m,n),其中m表示存储的位置，n表示属性的大小，要求是：m必须整除n）
16 //stride大小

struct Skill {
    var age: Int //8字节
    var height: UInt8 //1字节
    var width: UInt16 //2字节
}
print(MemoryLayout<Skill>.size)
print(MemoryLayout<Skill>.stride)
<!--打印结果-->
12
16