[Swift] Swift의 데이터타입 총 정리

Swift로 알고리즘 문제를 조금씩 풀어볼 예정인데 그 전에 데이터 타입에 대한 내용을 한번 읽어보앗습니당 ! 그중에서 몰랐던 내용이나 기억하면 좋을 것 같은 내용들을 정리 ~ !

Int 와 UInt : 양수만 사용한다고 해서 UInt 를 고집할 필요는 없다. 스위프트는 데이터타입에 엄격하기 때문에 같은 정수라 하더라도 전혀 다른 타입으로 인식하여 변수끼리 값을 교환할 때 많은 자원을 소모할 수 있다.
각 진수에 따라 정수를 표현하는 방법
- 10진수 : 평소에 쓰던 숫자와 동일하게
- 2진수 : 접두어 0b
- 8진수 : 접두어 0o
- 16진수 : 접두어 0x
toggle() : true, false 반전
64비트 Double 15자리, 32비트 Float 6자리 : 무엇을 사용해야할지 잘 모르는 상황이라면 Double을 사용하기를 권장
임의의 수 만들기 random(in: ) ex) Int.random(in: -100...100)
Character 값에 유니코드 문자를 사용할 수 있다. 한글변수이름도 사용가능
상수로 선언된 문자열은 변경 불가, 이니셜라이저를 사용하여 빈 문자열 생성 가능 String()
append() 메서드를 사용하여 문자열을 이어붙일 수 있음. + 연산자도 가능
count 문자의 수 세기, isEmpty 비어있는 지 확인
문자열 비교 == : true, false 값 반환
메서드를 통한 접두어, 접미어 확인 .hasPrefix("문자열") , hasSuffix("문자열")-> true, false
메서드를 통한 대소문자 변환 : uppercased(), lowercased()
코드상에서 여러줄의 문자열을 직접 쓰고 싶다면 큰따옴표 3개 사용
문자열 내 특수 문자
- \n : 줄바꿈
- \ : 문자열 내 백슬래시
- \" : 문자열 내 큰 따옴표
- \t : 탭문자
- \0 : 문자열이 끝났음을 알리는 null 문자
Any는 스위프트의 모든 데이터 타입을 사용할 수 있다는 뜻
AnyObject는 조금 한정된 의미로 클래스의 인스턴스만 할당할 수 있다
변수 또는 상수에 값이 없는 경우, 즉 nil 일 경우 ? 해당 변수 또는 상수에 접근했을 때 잘못된 메모리 접근으로 런타임 오류 발생. - Null Point Exception
특정함수의 반환 타입으로 사용될 수 있는 Never라는 타입 존재

스위프트는 타입에 민감하고 엄격 : 서로 다른 타입끼리의 데이터 교환은 꼭 타입캐스팅을 거쳐야 함

스위프트에서 값 타입의 데이터 교환은 엄밀히 말하면 타입캐스팅이 아닌 새로운 인스턴스를 생성하여 할당하는 것

Type-safe 언어

타입확인 : 컴파일 오류로 알려주기 때문에 서로 다른 타입의 값을 할당한느 실수를 줄일 수 있다.
타입추론 : 특정 타입을 명시하지 않아도 컴파일러가 할당된 값을 기준으로 변수나 상수의 타입을 결정

타입별칭

이미 존재하는 데이터 타입에 임의로 다른 이름을 부여할 수 있다.
그런 다음 기본 타입 이름과 이후에 추가한 별칭을 모두 사용할 수 있다.

튜플

타입의 이름이 따로 지정되어 있지 않은, 프로그래머 마음대로 만드는 타입
지정된 데이터의 묶음
인덱스를 통해서 값을 빼오고, 할당할수 있다.

var person: (String, Int, Double) = ("name", 100 , 182.5)

person.1 = 99
person.2 = 150

print(" \(person.0)")

이름없이 인덱스만으로 표현했을때는 가독성이 떨어짐 , 어떤 의미인지 유추하기 어려움.

튜플의 요소마다 이름을 붙여줄수 있따.


var person: (name: String, age: Int, height: Double) = ("name", 100 , 182.5)

person.age = 99 person.height = 150

print(" (person.name)")


- 튜플에는 타입이름에 해당하는 키워드가 따로 없어서 사용하기 불편
- 매번 같은 모양의 튜플을 사용하고 싶다면 타입 별칭을 사용해보자 

```swift 
typealias PersonTuple = (name: String, age: Int, height: Double)
let suyeon: PersonTuple =  ("name", 100 , 182.5)

print(" \(suyeon.name)")

컬렉션 형 - 배열, 딕셔너리, 세트

배열

같은 타입의 데이터를 일렬로 나열한 후 순서대로 저장하는 형태의 컬렉션 타입
isEmpty, count 사용가능

let emptyArray: [Int] = []

// 정식 문법 사용
let emptyArray2 = Array<Int>()

// 단축 문법 사용
let emptyArray3 = [Int]()

// 정식 문법
let strArray1: Array<String> = ["정식", "문법"]

// 단축 문법
let strArray2: [String] = ["단축", "문법"]

// 형식 추론
let strArray3 = ["형식", "추론"]

// 시퀀스
let nums = Array(1...3) // [1, 2, 3]

// 여러 자료형(타입)
let anyArr: [Any] = [1, 2, "three", "four"] // [1, 2, "three", "four"]

배열은 각 요소에 인덱스를 통해 접근할 수 있습니다.
인덱스는 0부터
Exception Error 잘못 접근
first 와 last 프로퍼티를 통해 맨처음, 마지막 요소 가져올 수 있다.
firstIndex(of:) 메서드로 해당 요소의 인덱스를 알아낼수도 있다.
중복된다면 맨 처음껄 반환
맨뒤에 요소를 추가하고 싶다면 append(_:) 메서드 사용
중간에 요소를 삽입하고 싶다면 insert(_:at:) 메서드 사용
요소를 삭제하고 싶다면 remove(_:) 메서드 사용 -> 삭제된 후 반환
removeFirst(), removeLast()
names[1 ... 3] : 슬라이싱 - 읽기 가능 , 값 대입하면 바꾸기도 가능
스위프트의 컬렉션 타입을 활용할 때 서브스크립트 기능 많이 사용함. 나중에

딕셔너리

키와 값의 쌍으로 구성됨, 순서 없
타입 별칭으로 단순하게 표현 가능

// typealias 사용
typealias StringIntDictionary = [String: Int]

var numberForName: [String: Int] = [String: Int]()
var numberForName: StringIntDictionary = StringIntDictionary()
var numberForName:  [String: Int] = [:]

딕셔너리 내부에서 키는 유일
값을 유일하지 않음
없는 키로 접근해도 오류가 발생하지는 않지만, nil을 반환
특정 키에 해당하는 값을 제거하려면 removeValue(forKey: ) 제거후 반환
numberForName["yagom", default: 0] : 키에 해당하는 값이 없으면 0을 출력

세트

같은 타입의 데이터를 순서없이 하나의 묶음으로 저장하는 형태
모두 유일한 값, 중복 없음
보통 순서가 중요하지 않거나 각 요소가 유일한 값이어야하는 경우에 사용
세트의 요소로는 해시가능한 값이 들어와야함 Hashable 채택
Array와 마찬가지로 대괄호 사용, 타입 추론을 사용하게 되면 컴파일러는 Set이 아닌 Array로 타입을 지정.
names: Set = []
세트에 요소를 추가하고 싶다면 insert, 제거하고 싶다면 remove 메서드 . 삭제 후 반환
세트 안의 값들이 모두 유일함을 보장하므로, 집합관계를 표현하고자 할떄 유용
두 세트의 교집합, 합집합을 연산하기에 매우 용이
sorted() 메서드를 통해서 정렬된 배열 반호나 가능
교집합 : set1.intersection(set2)
여집합 : set1.symmetricDifference(set2) -> 겹치는거 뺀 나머지
합집합 : set1.union(set2)
차집합 : set1.subtracting(set2)
.sorted() 메서드로 정렬 후 반환
포함관계 연산도 다양하다
isDisJoint(with:) : 서로 배타적인지 true
set1.isSubset(of: set2) : set1이 set2의 부분집합인가요 t/f
set1.isSuperset(of: set2) : set1이 set2의 전체집합인가요 ? t/f

컬렉션에서 임의의 요소 추출과 뒤섞기 .

임의의 요소 추출 : randomElement()
뒤섞기 : shuffle()
자신의 요소는 그대로 둔 채 새로운 컬렉션에 임의의 순서로 섞어서 반환 shuffled()

세트를 뒤섞으면 배열로 반환
세트는 순서가 없기 때문에 스스로 뒤섞을 수 없다. shuffle()은 안됨
딕셔너리를 뒤섞으며ㅕㄴ 키 값이 쌍을 이룬 튜플의 배열로 반환
String도 컬렉션입니다 !

열거형

연관된 항목들을 묶어서 표현할 수 있는 타입
제한된 선택지를 주고 싶을떄, 정해진 값 이외에는 입력받고 싶지 않을 때, 예상된 입력값이 한정되어 있을 때
스위프트의 열거형은 각 항목이 그 자체로 고유의 값이 될 수 있다.
열거형 각 항목이 원시값이라는 형태로 실제 값을 가질 수도 있다.
또는 연관값을 사용하여 다른 언어에서 공용체라고 불리는 값의 묶음도 구현할수 있다.
옵셔널은 열거형으로 구현되어있다

enum School {
    case primary
    case elementary
    case middle
    case high
    case collage
    case university
}

var highestEducationLevel: School = .university

// 같은 타입으로만 값을 변경할수 있다.
highestEducationLevel = .high

// 항목의 raw value : 특정 타입으로 지정된 값을 가질수 있다. 

enum School: String {
    case primary = "유치원"
    case elementary = "초등학교"
    case university = "대학교"
}

let highestEducationLevel: School = .university
print(highestEducationLevel.rawValue)

// 일부 항목만 원시값을 주는것도 가능하다. 
// 나머지는 알아서 처리 : 문자열이라면 각 항목이름 그대로, 정수 타입이면 첫 항목을 기주능로 0부터 1씩 늘어남

// 열거형이 원시값을 갖는 열거형일 때 , 원시값 정보를 안다면 원시값을 통해 열겨형 벼눗 또는 상수 생성가능

let primary = School(rawValue: "유치원")
let graduate = School(rawValue: "석박사") // nil

열거형 - 연관값

열거형 각 항목이 연관값을 가지게 되면, 기존 프로그래밍 언어의 공용체 형태를 띔
각 항목 옆에 소괄호로 묶어 표현

enum MainDish {
    case pasta(taste: String)
    case pizza(dough: String, topping: String)
    case chicken(withSauce: Bool)
    case rice
}

var dinner: MainDish = .pasta(taste: "크림")
dinner = .pizza(dough: "치즈크러스트", topping: "불고기")
dinner = .chicken(withSauce: true)
dinner = .rice

// 여러 열거형의 응용

enum PastaTaste {
    case cream, tomato
}

enum PizzaDough {
    case cheeseCrust, thin, original
}

enum PizzaTopping {
    case pepperoni, cheese, bacon
}

enum MainDish {
    case pasta(taste: PastaTaste)
    case pizza(dough: PizzaDough, topping: PizzaTopping)
    case chicken(withSauce: Bool)
    case rice
}

var dinner: MainDish = .pasta(taste: .cream)
dinner = .pizza(dough: .cheeseCrust, topping: .bacon)

항목순회

열거형에 포함된 모든 케이스를 알아야할때 사용
CaseIterable 프로토콜 채택
열거형에 allCases라는 이름의 타입프로퍼티를 통해 모든 케이스의 컬렉션을 생성

// 플랫폼 별로 사용 조건을 추가하는 경우 ?

enum School: CaseIterable {
    case primary
    case elementary
    case middle
    case high
    case collage
    case university

    @available(iOS, obsoleted: 12.0)
    case graduate

    static var allCases: [School] {
        let all: [School] = [.primary,
                            .elementary,
                            .middle,
                            .high,
                            .collage,
                            .collage,
                            .university]
        #if os(iOS)
        return all
        #else 
        return all + [.graduate]
        #endif
    }
}

let allCases: [School] = .allCases
print(allCases)

available 속성을 통해 특정 케이스를 플랫폼에 따라 사용할 수 있거나 없는 경우가 생기면
CaseIterable 프로토콜을 채택하는 것만으로 allCases 프로퍼티 사용 불가
직접 구현해줘야함.
연관값을 갖는 경우에도 마찬가지로 직접 구현

enum PastaTaste: CaseIterable {
    case cream, tomato
}

enum PizzaDough: CaseIterable {
    case cheeseCrust, thin, original
}

enum PizzaTopping: CaseIterable {
    case pepperoni, cheese, bacon
}

enum MainDish: CaseIterable {
    case pasta(taste: PastaTaste)
    case pizza(dough: PizzaDough, topping: PizzaTopping)
    case chicken(withSauce: Bool)
    case rice

    static var allCases: [MainDish] {
        return PastaTaste.allCases.map(MainDish.pasta) + PizzaDough.allCases.reduce([]) {
            (result, dough) -> [MainDish] in result + PizzaTopping.allCases.map {
                (topping) -> MainDish in MainDish.pizza(dough: dough, topping: topping)
            }
        }
        + [true, false].map(.chicken)
        + [.rice]
    }
}

print(MainDish.allCases.count)

순환열거형

열거형 항목의 연관값이 열거형 자신의 값이고자 할 때
indirect 키워드 사용

특정 항목, 열거형 전체


enum ArithmeticExpression {
case number(Int)
indirect case addition(ArithmeticExpression, ArithmeticExpression)
indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
}

// 열거형 전체 indirect enum ArithmeticExpression { case number(Int) case addition(ArithmeticExpression, ArithmeticExpression) case multiplication(ArithmeticExpression, ArithmeticExpression) }

// evaluate는 열거형의 계산을 도와주는 순환함수

let five = ArithmeticExpression.number(5) let four = ArithmeticExpression.number(4) let sum = ArithmeticExpression.addition(five, four) let final = ArithmeticExpression.multiplication(sum, ArithmeticExpression.number(2))

func evaluate(_ expression: ArithmeticExpression) -> Int { switch expression { case .number(let value): return value case .addition(let left, let right): return evaluate(left) + evaluate(right) case .multiplication(let left, let right): return evaluate(left) * evaluate(right) } }

let result: Int = evaluate(final) // indirect 키워드는 이진탐색트리등의 순환알고리즘을 구현할때 유용하게 사용가능


### 비교 가능한 열거형 
- Comparable 프로토콜을 채택하면 각 케이스 비교 가능. 
- 앞에 위치한 case가 더 작은 값이 된다.

```swift
enum Condition: Comparable {
    case terrible
    case bad
    case good
    case great
}

let myCondition: Condition = .great
let yourCondition: Condition = .bad

if myCondition >= yourCondition {
    print("제 상태가 더 좋군요")
} else {
    print("당신의 상태가 더 좋군요")
}

enum Device: Comparable {
    case iPhone(version: String)
    case iPad(version: String)
    case macBook
    case iMac
}

var devices: [Device] = []
devices.append(Device.iMac)
devices.append(.iPhone(version: "14.3"))
devices.append(.iPhone(version: "6.1"))
devices.append(.iPad(version: "10.3"))
devices.append(.macBook)

let sortedDevices: [Device] = devices.sorted()
print(sortedDevices)

Suyeon9911 / TIL