딕셔너리 & 열거형 (Enumeration)

[Roy-wonji]

Dictionary(딕셔너리 )란 ?

• 데이터와 키와 값으로 하나의 쌍으로 만들어서 관리하는 컬렉션
• 대괄호 묶음 각 요소(element)는 키(key) 와 값(value)의 쌍을 클론으로 처리 해야 합니다

딕셔너리의 문법 약속

• 대괄호로 묶는다. (쌍을 콜론으로 처리)
• 키값은 유일해야함 / 중복 불가능(구분하는 요소이기 때문에) 밸류값은 중복 가능
• 1개의 딕셔너리에는 동일한 자료형 쌍의 데이터만 담을 수 있음
• 키값은 Hashble 해야함

var dic = ["A": "Apple", "B": "Banana", "C": "City"]   // 딕셔너리 리터럴로 생성해서 저장
let dic1 = [1: "Apple", 2: "Banana", 3: "City"]

// 단축문법
var words: [String: String] = [:]

// 정식문법
let words1: Dictionary<Int, String>

업데이트 (update) - 삽입하기 / 교체하기 / 추가하기

dic = ["A": "Apple", "B": "Banana", "C": "City"]
words["A"] = "Apple"   // 애플로 다시 바꾸기
words["B"] = "Banana"  // 동일한 키가 없으면 ===> 추가하기
words["B"] = "Blue"    // 동일한 키가 있으면 ===> 기존 밸류 덮어쓰기
words.updateValue("City", forKey: "C")
// (정식 기능) 함수 문법 (update + insert = upsert)
words.updateValue("City", forKey: "C")   // 새로운 요소가 추가되면 ==> 리턴 nil
words = ["A": "A"]   // 전체 교체하기(바꾸기)

삭제(제거)하기 (remove)

dic = ["A": "Apple", "B": "Banana", "C": "City"]
dic["B"] = nil    // 해당요소 삭제

dic["E"] = nil   // 존재하지 않는 키/값을 삭제 ======> 아무일이 일어나지 않음(에러아님)
dic.removeValue(forKey: "A")   // 삭제후, 삭제된 값 리턴

dic.removeValue(forKey: "A")   // 다시 삭제해보기 ===> nil리턴
dic.removeAll()

dic.removeAll(keepingCapacity: true)

딕셔너리의 비교

• 딕셔너리는 원래 순서가 없기 때문에, 순서는 상관없
• (순서 상관없이 무조건 true나옴 - Hashable하기 때문에, 순서 상관없이 비교가능)

a == b   // true
a != b   // false

Set

수학에서의 집합과 비슷한 연산을 제공하는, 순서가 없는 컬렉션

Set 문법 약속

• 생김새는 배열과 같음(따라서, 생성시 타입을 선언 해야함)
• 수학에서의 집합과 동일하기 때문에 요소는 유일해야함(순서가 존재하지 않음)

선언

var integerSet: Set<int> = Set<int>()

삽입

integerSet.insert(1)

integerSet.insert(100)

integerSet.insert(99)

integerSet.insert(99)

포함되어있는가

integerSet.contains(100)

삭제

integerSet.remove(100) - optional

integerSet.removeFirst()

업데이트

set.update(with: 1) - 1 이라는 요소를 추가한다.

set.update(with: 7) - 새로운 요소가 추가되면 nil 리턴

집합

let setA: Set<Int> = [1, 2, 3, 4, 5]

let setB: Set<Int> = [3, 4, 5, 6, 7]

let union: Set<Int> = setA.union(setB) 합집합

let sortedSet = union.sorted() 정렬된 배열

let intersection: Set<Int> = setA.intersection(setB) 교집합

let substracting: Set<Int> = setA.subtracting(setB) 차집합

열거형(Enumeration)

• 타입 자체를 한정된 사례 (case ) 안에서 정의 할수 있는 타입
• 열거형을 사용하면 코드의 가독성과 안정성이 높아짐 ===> 명확한 분기 처리 가능

enum Weekday  {
    case monday, tuesday
    case wednesday
    case thursday
    case friday
    case saturday
    case sunday
}
var today: Weekday = Weekday.monday

today = .tuesday

열거형의 원시값과 연관값

• 열거형의 원시값(Raw Values)

여러가지 형태로 원시값을 정의 가능 (Hashable한 - Int / String / Character / Double 등 가능)

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

case left = "L"

case center = "C"

case right = "R"

}

열거형의 연관값(Associated Values)

• 각 케이스별로 상이한 특징이 있고, 그것을 저장 / 활용할 필요가 있을 때
• 개별케이스마다 저장할 형식을 따로 정의(자료형에 제한이 없음 / 튜플의 형태)
• 하나의 케이스에 서로다른 연관값을 저장할 수 있음 ===> 선언시점이 아니라, 새로운 열거형 값을 생성할때 저장

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)

원시값(Raw Values)과 연관값(Associated Values)의 차이

구분	원시 값	연관값
사용목적	열거형 타입의 각 케이스에 정수또는 문자열을 매칭 시켜 타입을 생성 하거나 다룰떄 조금더 편하게 사용	열거형 타입의 각케이스의 카테고리에는 해당 하지만 , 보다 구체적인 정보를 저장해서 사용하려고 할떄
선언 방법	선언 타입이 제한 - int , string을 주로 사용 (원칙적으로 hashable 프로토콜을 준수하는 타입 모두 가능)	선언 타입에 제한 없이 자유롭게 정의 가능 (연관된 정보를 추가적 저장 개념이기 떄문에 )
값의 저장	열거형의 선언 시점 (선언시에 case 마다 값이 매칭)	인스턴스 생성시
값의 변경 (case)	선언시에 정의개념이기에 당연히 불가능	하나의 케이스에 서로 다른 값들을 저장가능
주의점	하나의 열거형에서 원시값과 연관값을 함께 사용하는 것은 불가능 함	하나의 열거형에서 원시값과 연관값을 함께 사용하는 것은 불가능 함

옵셔널(Optional) + 열거형

옵셔널의 구현은 제네릭 열거형으로 선언하고, some 의 케이스에 연관값을 저장한 것이다.

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

case .some(let a):  // let a = 7     // 열거형 case 패턴을 활용해서, 내부 연관값을 꺼냄

print(a)

case .none:

errors.errorNum

}

.none은 명시적인 열거형으로 표현한 것이고, 일반적으로는 값이 없다는 의미의 nil키워드를 사용할뿐

옵셔널 타입 + switch / 조건문 / 반복문

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

enum LoginProvider: String {
case email
    case facebook
    case google
}
switch userLogin {                   // 3가지로 분기처리

case .email:

print("이메일 로그인")

case .facebook:

print("페이스북 로그인")

case .google:

print("구글 로그인")

}
enum LoginProvider: String , CustomStringConvertible  {

case email , facebook , google    // 3가지로 정의

var description: String {

switch self {

case .email:

return "이메일 로그인"

case .facebook:

return "페이스북 로그인"

case .google:

return "구글 로그인"

}

}

}
if case Computer.hardDisk(gb: let gB) = chip {

print("\(gB)기가 바이트 하드디스크임")

}
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 .cpu(core: 4, ghz: let ghz):       // let ghz = 연관값  (cpu가 4코어인 경우, ghz에 저장된 연관값을 꺼내서 바인딩)

print("CPU 4코어 \(ghz)HGz입니다.")

case .cpu(core: _, ghz: _):

print("CPU 칩 입니다.")

case .ram(32, ):

print("32기가램 입니다.")

case .ram(, _):

print("램 입니다.")

case let .hardDisk(gb: gB):            // let gB = 연관값

print("\(gB)기가 바이트 하드디스크 입니다.")

default:                               // 대부분 default문이 필요하기도 함

print("그 외에 나머지는 관심이 없습니다. 그렇지만 칩이긴 합니다.")

}
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)헤르츠")

}

열거형과 Switch 문의 default 선언

@unknown (Swift 5.0 ~)

switch문에서 열거형의 모든 케이스를 다루지 않는 경우, 스위치문에서 모든 열거형의 케이스를 다루지 않았다고 경고를 통해 알려줌 ===> 개발자의 실수 가능성을 컴파일 시점에 알려줌