用途

主に値をグループ化するのに使用します。

enum Size {
    case S, M, L
}

// または
enum Size {
    case S
    case M
    case L
}

var size = Size.S

if (size == Size.S) {
    print("Sサイズ")
}

// 型推論で.Sだけでもいけます
if (size == .S) {
    print("Sサイズ")
}

Raw Valueを参照するには、rawValue を使用します。

var size = Size.S
if (size.rawValue == 1) {
  print("Sサイズ")
}

関数を定義する

enum Size {
    case S, M, L
    
    func sizeToString() {
        switch self {
        case .S:
            print("Sサイズ")
        case .M:
            print("Mサイズ")
        case .L:
            print("Lサイズ")
        default:
            break
        }
    }
}

var size = Size.S
size.sizeToString() // => "Sサイズ"

rawValue から case を求める

enum Size: Int {
    case S = 0, M, L

    func sizeToString() {
        switch self {
        case .S:
            print("Sサイズ")
        case .M:
            print("Mサイズ")
        case .L:
            print("Lサイズ")
        default:
            break
        }
    }
}

let section = Size(rawValue: 0)!
print(section) // S

コンストラクタを定義する

init メソッド（nilになる場合は init? メソッド）によってコンストラクタを定義することができます。

enum Size: CaseIterable {
    case S
    case M
    case L
    
    init?(price: Int) {
        if price == 100 {
            self = .S
        } else if price == 200 {
            self = .M
        } else if price == 300 {
            self = .L
        } else {
            return nil
        }
    }
}
print(Size(price: 100)) => Optional(Size.S)

caseに引数を定義する

case をさらに細かい粒度に分けたい場合などは便利です。

enum Size {
    case S(price: Int)
    case M(price: Int)
    case L(price: Int)

    func string() -> String {
        switch self {
        case .S(let price): return "Sサイズ: \(price)円"
        case .M(let price): return "Mサイズ: \(price)円"
        case .L(let price): return "Lサイズ: \(price)円"
        }
    }
}

let a = Size.S(price: 100)

print(a.string()) => Sサイズ: 100円

CaseIterable

enum のすべての case を allCases メソッドにより配列で取得することができます。

enum Size: CaseIterable {
    case S
    case M
    case L
}

print(Size.allCases) => [Size.S, Size.M, Size.L]