#1. 데이터 타입

** 스위프트 프로그래밍 - 야곰 책을 위주로 공부했습니다. **

 

 

[변수 선언 방법]

- 변수

   var 변수명: 타입 = 값

 

- 상수

   let 상수명: 타입 = 값

 

변수 선언 시 타입을 명시해주지 않으면 타입을 추론해서 적용해주지만, 타입 추론은 잘 사용하지 않는 것이 좋습니다.

 

[기본 데이터 타입]

1. 정수 타입 - Int / UInt

var a: Int // +, -
var b: UInt // only +

음수를 사용하지 않는 일반적인 경우에는 Int를 권장합니다.

 

2. 부울 타입

var a: Bool // true, false

 

3. 부동소수점(실수) 타입 - Double / Float

var a: Double // 64비트
var b: Float  // 32비트

일반적인 경우에는 Double을 권장합니다.

 

4. 문자와 문자열 - Character / String

var a: Character = "a" // 유니코드 한 글자
var b: String = "apple" // 문자의 나열

var c: String = String() // 이니셜라이저를 통한 빈 문자열 생성

c.append("My name is ") // append 문자열 이어붙이기
c = c + "Yookie" // + 연산자 문자열 이어붙이기

print(c.count) // 문자열 길이 17

var d: String = String()
print(d.isEmpty) // 빈 문자열 확인, count가 0일 때 true

d = """
My name is
Yookie!
Nice to meet you
"""
dump(d) // - "My name is\nYookie!\nNice to meet you"

문자열(String)은 문자(Character)의 나열입니다.

 

5. Any 타입

var a: Any // 모든 데이터 타입 사용 가능, 사용권장 안함
a = 10 // Int
a = "apple" // String

AnyObject는 Any보다는 조금 한정된 의미로 "클래스의 인스턴스"만 할당할 수 있습니다.

Any와 AnyObject는 될 수 있으면 사용하지 않는 편이 좋습니다. (데이터 타입은 명확히 정의해주는게 좋습니다.)

 

 

[고급 데이터 타입]

1. 타입 별칭 - typealias

typealias MyInt = Int // 타입 별칭 - 임의의 다른 이름을 부여
var a: MyInt = 10

typealias YourInt = Int
var b: YourInt = 20

a = b // 타입이 동일해서 가능

 

 

2. 튜플

typealias MyTuple = (String, Int) // 튜플 - 지정된 데이터의 묶음
var a: MyTuple = ("my", 10)
print(a.0) // my

typealias YourTuple = (String, Int, Int)
var b: YourTuple = ("you", 10, 20)
print(b.2) // 20

typealias DefinedTuple = (name: String, age: Int) // 튜플 요소 이름 지정
var c: DefinedTuple = ("Yookie", 26)
print("index: \(c.0), name: \(c.age)") // index: Yookie, name: 26

튜플 + 타입별칭(typealias) 조합 = 깔끔합니다.

 

3. 배열 - Array

var a: Array<Int> = [10, 20, 30]
var b: [String] = ["one", "two", "three"]

// 비어있는 배열 생성
var emptyarrA: Array<Int> = Array<Int>()
var emptyarrB: [String] = [String]()
var emptyarrC: [String] = []

Array<타입>과 [타입]은 같은 표현입니다.

 

4. 딕셔너리 - Dictionary

var a: Dictionary<String, Int> = ["one": 10, "two": 20, "three": 30]
var b: [String: Int] = ["one": 10, "two": 20, "three": 30]

// 비어있는 딕셔너리 생성
var emptydicA: Dictionary<String, Int> = Dictionary<String, Int>()
var emptydicB: [String: Int] = [String: Int]()
var emptydicC: [String: Int] = [:]

배열과 달리 인덱스가 없고 순서가 없습니다.

 

5. 집합 - Set

// 배열과 유사하지만 축약형 사용이 불가하며 중복된 값 불가
var a: Set<String> = ["abc", "def", "abc"]
print(a) // ["def", "abc"]

// 비어있는 Set 생성
var emptysetA: Set<String> = Set<String>()
var emptysetB: Set<String> = []

Array<Int> -> [Int] 이런 축약형 표현이 불가합니다.

 

6. 열거형 - enum ★

- 연관된 항목들을 묶어서 제한된 선택지를 주고 싶을 때 유용합니다.

- switch 구문과 함께 사용하면 활용도가 높습니다.

- 옵셔널(Optional)은 열거형(enum)으로 구현되어 있습니다.

// 기본
enum PlayType {
    case live
    case aod
    case podcast
    case vod
    case clip
}

// 원시값1
enum PlayType: String {
    case live = "라이브"
    case aod = "다시듣기"
    case podcast = "팟캐스트"
    case vod = "다시보기"
    case clip = "클립"
}

// 원시값2
enum PlayType: String {
    case live = "라이브", aod = "다시듣기", podcast = "팟캐스트", vod = "다시보기", clip = "클립"
}

열거형 선언 3가지 방법 (기본 1가지, 원시값 2가지)

enum PlayType: String {
    case live = "라이브", aod = "다시듣기", podcast = "팟캐스트", vod = "다시보기", clip = "클립"
}

var a = PlayType.live // 타입 추론 방식
var b: PlayType = .aod // 타입 명시 방식

print(a.rawValue, b.rawValue) // rawValue 원시 값 라이브 팟캐스트

var c = PlayType(rawValue: "팟캐스트") // 해당 원시 값이 없을 경우 nil 반환
if let value = c {
    print(value)
} else {
    print("nil")
} // podcast

기본적인 열거형 사용법

enum Number: Int {
    case zero
    case one
    case two
    case three
    case ten = 10
}
print(Number.two.rawValue) // 2
print(Number.ten.rawValue) // 10

원시값의 디폴트 (ex. 정수(Int): 0부터 순서대로 / 문자열(String): case명)

enum Menu {
    case pasta(taste: String)
    case pizza(dough: String, topping: String)
    case chicken(withSauce: Bool)
    case rice
}
var a: Menu = .pasta(taste: "tomato") // 연관값 그냥 이대로 사용
print(a) // pasta(taste: "tomato")

연관값을 가져 열거형의 범위를 넓힐 수 있습니다. (ex. tomato taste의 pasta, cream taste의 pasta 등)

// 순환 열거형으로 (5+4)*2 계산
enum ArithmeticExpression {
    case number(Int)
    indirect case addition(ArithmeticExpression, ArithmeticExpression) // 순환열거형(indirect)
    indirect case multiplication(ArithmeticExpression, ArithmeticExpression) // 순환열거형(indirect)
}

let num1 = ArithmeticExpression.number(5)
let num2 = ArithmeticExpression.number(4)
let num3 = ArithmeticExpression.number(2)
let sum = ArithmeticExpression.addition(num1, num2)
let final = ArithmeticExpression.multiplication(sum, num3)

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)
print(result) // 7

순환열거형 = 열거형(enum)을 활용한 순환함수