Enumeration

• 열거형(enum)의 기본형은 아래와 같다.

enum TypeName {
	case caseName
    case caseName, caseName
}

여기서 조심해야될 점은 case도 하나의 값이다!("left"/ 1 과 같이 정수 값이나 string 값과 같이 그냥 값이다!)

예)

enum Alignment {
    case left
    case right
    case center
}

Alignment.center
Alignment.left
Alignment.right

• case를 새로운 변수에 저장할 수 있다.

var textAlignment = Alignment.center

• 열거형 이름은 생략하고 case이름만 작성해도 된다!

// 열거형 이름은 생략하고 case이름만 작성해도 된다!
textAlignment = .left

• switch문으로 표현을 하면 더욱 더 쉽다.

switch textAlignment {
case .left:
    print("left")
case .right:
    print("right")
case .center:
    print("center")
}

Raw Values

열거형의 case 는 모두 독립적인 값이지만 내부에 또 다른 값을 저장할 수 있습니다. 이것을 원시값(raw value)이라고 합니다.

-> 원시값을 만약 가지고 싶다면, enum 선언 시 이름 옆에 Type을 꼭 써줘야된다.

• Raw Values 기본 형

enum Name: RawValueType {
    case caseName = value
}

예)

enum Alignment: Int {
    case left
    case right
    case center
}

Alignment.left.rawValue //0
Alignment.right.rawValue //1
Alignment.center.rawValue //2

• 아래와 같이 rawValue를 직접 지정해 줄 수도 있다.

enum Alignment: Int {
    case left
    case right = 10
    case center
}

Alignment.left.rawValue //0
Alignment.right.rawValue //10
Alignment.center.rawValue //11

Alignment(rawValue: 0) //left
Alignment(rawValue: 10) //right

• 만약 rawvalue Type만 지정해두었다면 rawValue는 caseName을 따라간다.

enum WeekDay: String {
    case sunday
    case monday
    case tuesday
    case wednesday
    case thursday
    case friday
    case saturday
}

WeekDay.sunday.rawValue //sunday

• 아래와 같이 rawValue값을 지정할 수 있다.

enum WeekDay: String {
    case sunday
    case monday = "MON"
    case tuesday
    case wednesday
    case thursday
    case friday
    case saturday
}

WeekDay.monday.rawValue // "MON"

• Character가 rawValueType일 경우 무조건적으로 rawValue를 할당해주어야됩니다.

enum ControlChar: Character {
    case tab = "\t"
    case newLine = "\n"
}

Associated Values(연관값)

• 원시값 대신 연관된 값을 저장할 수 있다.

단, 모든 케이스가 동일한 형식을 가져야된다.

기본 꼴

enum Name {
	case caseName(Type)
    case caseName(Type, Type, ...)
}

또한, 연관값의 경우에는 선언 시점이 아닌 새로운 열거형을 생성할 때 값을 저장한다.

예를 들어서 아래와 같이 연관값을 설정할 수 있다.

enum AppleDevice {
    case iPhone(model: String, storage: Int) // named tuple
    case iMac(size: Int, model: String, price: Int)
    case macBook(String, Int, Int) // unnamed tuple
}

그리고 아래는 연관값을 확인한 후에 코드를 실행할 때 switch문을 사용한 케이스다.

var gift = AppleDevice.iPhone(model: "X", storage: 256)

switch gift {
case .iPhone(model: "X", storage: 256):
    print("iPhone X and 256GB")
case .iPhone(model: "X", _)
    // 와일드카드 패턴 사용 가능
    print("iPhone X")
case .iPhone:
    // 연관값 생략 가능
    print("iPhone")
case .iPhone(let model, let storage):
    // 블록 내부에서 연관값을 사용할 땐 상수로 바인딩
    // 값을 변경할 때는 var 로 변경가능
    print("iPhone \(model) and \(storage)GB")
case let .iMac(size, model, price):
    // 모든 연관값을 동일한 형태로 바인딩한다면
    // let 키워드를 열거형 케이스 앞에 표기하는 것도 가능
    print("iMac \(size), \(model), \(price)")
}

allCases의 사용

• CaseIterable을 사용하면 enum을 배열처럼 사용할 수 있다.

사용 예)

enum Animal: CaseIterable {
    case rabbit
    case dog
    case cat
}

print(Animal.allCases) // enum case들을 배열 안에 넣어서 return한다.
Animal.allCases.forEach({ Animal in
    print("\(Animal)")
}) // rabbit dog cat

enum 타입의 연산 property(+switch문)

프로젝트를 하다가 유용하게 사용한 enum문법이다. enum 안에 연산 property를 사용한 경우이다.

enum FruitJuice: Int, CaseIterable {
    case strawberryBanana = 1
    case strawberry = 2
    case banana = 3
    case pineapple = 4
    case mangoKiwi = 5
    case kiwi = 6
    case mango = 7
    
    var recipe: [Fruit: Int] {
        switch self {
        case .strawberryBanana:
            return [Fruit.strawberry: 10, Fruit.banana: 1]
        case .strawberry:
            return [Fruit.strawberry: 16]
        case .banana:
            return [Fruit.banana: 2]
        case .pineapple:
            return [Fruit.pineapple: 2]
        case .mangoKiwi:
            return [Fruit.mango: 2, Fruit.kiwi: 1]
        case .kiwi:
            return [Fruit.kiwi: 3]
        case .mango:
            return [Fruit.mango: 3]
        }
    }
}

FruitJuice.mango.recipe // [mango: 3]

enum 타입의 연산 method(+switch문)

• 위의 연산 property와 비슷하게 사용할 수 있는 연산 method이다.

enum FruitJuice: Int, CaseIterable {
    case strawberryBanana = 1
    case strawberry = 2
    case banana = 3
    case pineapple = 4
    case mangoKiwi = 5
    case kiwi = 6
    case mango = 7
    
    func juiceType() -> String {
        switch self {
        case .strawberryBanana:
            return "strawberryBanana"
        case .strawberry:
            return "strawberry"
        ...
        }
}

FruitJuice.mango.juiceType() // "mango"

enum 타입의 타입 메소드

• 아래의 예처럼 함수들을 enum 타입으로 모아두어 타입 메소드 형태로 끌어쓸 수 있다.

enum ExpressionParser {
    
    static func parse(from input: String) -> Formula {
        ...
        return Formula(operandsList: operandsList, operatorsList: operatorsList)
    }
    
    private static func componentsByOperators(from input: String) -> [String] {
        return input.split(with: ",")
    }
}

// 사용부 
let sut = ExpressionParser.parse(from: inputString)