Swift 특이점①, 열거형(Enum)

enum Weekday {
    case monday
    case tuesday
    case wednesday
    case thursday
    case friday
    case saturday
    case sunday
}


enum CompassPoint {
    case north, south, east, west
}

var today: Weekday = Weekday.monday

today = .tuesday




// 일요일인 경우만 특정한 처리를 하고 싶을때

if today == .sunday {
   
}


// 모든 각각의 경우를 처리하고 싶을때

if today == .monday {
   print("오늘은 월요일입니다.")
} else if today == .tuesday {
   print("오늘은 화요일입니다.")
} else if today == .wednesday{
   print("오늘은 수요일입니다.")
} else if today == .thursday{
   print("오늘은 목요일입니다.")
} else if today == .friday{
   print("오늘은 금요일입니다.")
} else if today == .saturday{
   print("오늘은 토요일입니다.")
} else {
   print("오늘은 일요일입니다.")
}

/**=====================================**/

//항상 switch문과 연결해서 사용됨

switch today {
case .monday:
   print("오늘은 월요일입니다.")
case .tuesday:
   print("오늘은 화요일입니다.")
case .wednesday:
   print("오늘은 수요일입니다.")
case .thursday:
   print("오늘은 목요일입니다.")
case .friday:
   print("오늘은 금요일입니다.")
case .saturday:
   print("오늘은 토요일입니다.")
case .sunday:
   print("오늘은 일요일입니다.")
}

enum Alignment1: String {
    case left = "L"
    case center = "C"
    case right = "R"
}


let align = Alignment(rawValue: 0)   // 인스턴스 생성시 - 옵셔널타입으로 리턴 (실패가능)
let leftValue = Alignment.center.rawValue    // 접근연산자를 통해 원시값 자체에도 접근가능



Alignment1(rawValue: "C")     // (가능하지만) 문자열 방식으로는 잘 사용하지는 않음
let centerValue = Alignment1.center.rawValue

enum RpsGame: Int {
    case rock
    case paper
    case scissors
}

RpsGame(rawValue: 0)!
RpsGame(rawValue: 1)
RpsGame(rawValue: 2)


let number = Int.random(in: 0...100) % 3 
print(RpsGame(rawValue: number)!)      // 출력은 하지만 문자열은 아님에 주의




// 옵셔널값을 벗겨서 사용
if let r = RpsGame(rawValue: 0) {
    print(r)       // 출력은 하지만 문자열은 아님에 주의
}

enum Computer {
    case cpu(core: Int, ghz: Double)
    case ram(Int, String)
    case hardDisk(gb: Int)
}

let myChip1 = Computer.cpu(core: 8, ghz: 3.5)
let myChip2 = Computer.cpu(core: 4, ghz: 2.0)

let myChip3 = Computer.ram(16, "DRAM")
let myChip4 = Computer.ram(4, "SRAM")
let myChip5 = Computer.ram(32, "DRAM")

let myChip6 = Computer.hardDisk(gb: 128)
let myChip7 = Computer.hardDisk(gb: 512)

switch chip {
case .cpu(core: 8, ghz: 3.1):
    print("CPU 8코어 3.1GHz입니다.")
case .cpu(core: 8, ghz: 2.6):
    print("CPU 8코어 2.6GHz입니다.")
case .ram(32, _):
    print("32기가램 입니다.")
default:
    print("그 이외의 칩에는 관심이 없습니다.")
}
// 연관값을 가진 케이스를 패턴 매칭시키기


switch chip {
case let .cpu(a, b):    // let a = 연관값, let b = 연관값
    print("CPU \(a)코어 \(b)GHz입니다.")
case let .ram(a, _):
    print("램 \(a)기가램 입니다.")
case let .hardDisk(a) :
    print("하드디스크 \(a)기가 용량입니다.")
}

// 로그인 타입을 정의

enum LoginProvider: String {      // 3가지로 정의
    case email
    case facebook
    case google
}

let userLogin = LoginProvider.facebook


// 열거형은 한정된 사례로 만든 타입이고,
// 스위치문은 표현식에 대한 분기처리에 최적화

switch userLogin {                   // 3가지로 분기처리
case .email:
    print("이메일 로그인")
case .facebook:
    print("페이스북 로그인")
case .google:
    print("구글 로그인")
}


// 물론 특정한 경우도 처리 가능
if LoginProvider.email == userLogin {
    print("이메일 로그인")
}

enum Optional<Wrapped> {     // 제네릭 문법
    case some(Wrapped)
    case none
}

var num: Int? = 7  // 열거형(한정된 사례)
//Optional.some(7)
//Optional.none

switch num {
case .some(let a):  // let a = 7 
    print(a)
case .none:
    print("nil")
}

switch num {
case Optional.some(let a):
    print(a)
case Optional.none:
    print("nil")
}

enum SomeEnum {
    case left
    case right
}

// 타입을 다시 옵셔널 열거형으로 선언한다며?
let x: SomeEnum? = .left

// 원칙 ===> 이거 말고
switch x {
case .some(let value):      // Optional.some(let value) = Optional.some(SomeEnum.left)  ⭐️
    switch value {
    case .left:
        print("왼쪽으로 돌기")
    case .right:
        print("오른쪽으로 돌기")
    }
case .none:
    print("계속 전진")
}

// 편의적 기능 제공 ===> 이렇게 처리됨!!
switch x {
case .some(.left):
    print("왼쪽으로 돌기")
case .some(.right):
    print("오른쪽으로 돌기")
case .none:
    print("계속 전진")
}

switch x {     // 예전에는 x! 라고 써줘야 했음 (스위치문에서 옵셔널 타입도 ok)
case .left:
    print("왼쪽으로 돌기")
case .right:
    print("오른쪽으로 돌기")
case nil:
    print("계속 전진")
}

chip = Computer.hardDisk(gb: 128)    // 256

// if문에서도 스위치문에서 사용하는 case문과 같이 사용 가능
if case Computer.hardDisk(gb: let gB) = chip {
    print("\(gB)기가 바이트 하드디스크임")
}

if case Computer.hardDisk(gb: let gB) = chip, gB == 256 {    // 처리를 다양하게 활용 가능
    print("256기가 바이트 하드디스크임")
}


//for문
let chiplists: [Computer] = [
    .cpu(core: 4, ghz: 3.0),
    .cpu(core: 8, ghz: 3.5),
    .ram(16, "SRAM"),
    .ram(32, "DRAM"),
    .cpu(core: 8, ghz: 3.5),
    .hardDisk(gb: 500),
    .hardDisk(gb: 256)
]

for case let .cpu(core: c, ghz: h) in chiplists {    // 배열중에서 특정 케이스만 뽑아서 활용 가능 ⭐️
    print("CPU칩: \(c)코어, \(h)헤르츠")
}

// 일반 for문과 비교 =====> 모든 경우
for chip in chiplists {
    print("\(chip)")
}

// 옵셔널 타입을 포함하는 배열에서 반복문을 사용하는 경우
let arrays: [Int?] = [nil, 2, 3, nil, 5]

for case .some(let number) in arrays {
    print("Found a \(number)")
}

// 1) 열거형 케이스 패턴 (앞에서 배운)

switch a {
case .some(let z):
    print(z)
case .none:  // nil이라고 써도됨
    print("nil")
}


// 2) 옵셔널 패턴

switch a {
case let z?:      // .some을 조금 더 간소화하는 문법
    print(z)
case nil:         // .none 이라고 써도됨
    print("nil")
}

if case .some(let x) = num {
    print(x)
}


//옵셔널 패턴 (.some을 ? 물음표로 대체 가능한 패턴)
if case let x? = num {        // "옵셔널(?) 물음표를 띄어내고, x 상수로 보자"의 의미라고 생각하면 됨
    print(x)
}

// 옵셔널 타입을 포함하는 배열에서 반복문을 사용하는 경우, 옵셔널 패턴을 사용하면 편리함
let arrays: [Int?] = [nil, 2, 3, nil, 5]


// 1) 열거형 케이스 패턴
for case .some(let number) in arrays {
    print("Found a \(number)")
}


// 2) 옵셔널 패턴
for case let number? in arrays {
    print("Found a \(number)")
}

switch userLogin {
case .email:
    print("이메일 로그인")
case .facebook:
    print("페이스북 로그인")
case .google:
    print("구글 로그인")
@unknown default:
    print("그 외의 모든 경우")
}