Swift

Computer Science of Swift

💛 Swift

Swift 함수 형태 및 관련 용어

👉 func 함수명(전달인자 레이블 매개변수 레이블: 매개변수 타입)
　　👋 func hello(to num: Int) { ~ }
　　👋 func hello(_ str: String) -> String { ~ }
👉 전달인자 레이블 : 함수 외부에서 매개변수의 역할을 좀 더 명확히 하는 역할, 다르게 레이블을 써줌으로써 오버로딩 가능
👉 매개변수 : 함수를 정의할 때 외부로부터 전달된 값의 이름, 함수 내부에서 전달된 값을 다루기 위한 역할
👉 _ : 와일드 카드 패턴, 변수를 사용할 필요가 없을 때 사용, 공란 대신 입력st
👉 가변 매개변수 : 매개변수로 몇 개의 값이 들어올지 모를 때 사용할 수 있으며, 함수마다 가변 매개변수는 하나만 가질 수 있음
　　👉 타입 뒤에 …으로 나타냄
　　👋 func hello(_ num: Int, _ result: Int…) { ~ }

rawValue(원시값)

👉 열거형의 각 케이스가 기본적으로 갖고 있는 값
👉 각 케이스는 원시값을 가지고 있지 않을 수 있음 // 열거형의 이름만 있고 타입은 없이 선언되어 있는 경우
👉 정수형의 첫번째 케이스 기본적으로 0, 한 케이스의 원시값은 이전 케이스의 원시값 + 1
👉 실수형의 첫번째 케이스 기본적으로 0, 한 케이스의 원시값은 이전 케이스가 정수값일 경우 + 1, 이전 케이스가 실수형일 경우 에러
👉 String형의 원시값은 기본적으로 자신의 case 이름의 값 혹은 직접 지정한 값
👉 Character의 원자값은 모두 직접 선언해야 함

associated Value(연관값)

👉 열거형에서 각 케이스들은 각자 단 하나의 원시값만 가질 수 있음
👉 이러한 단점을 보완하기 위해 각 케이스가 상황에 따라 다른 값을 가지게 하기 위해서 사용하는 개념
👉 케이스에 튜플 형태로 타입을 명시하여 사용
　　👋 case caseName(model: String)
　　👋 case caseName(model: String, size: Int)
　　👋 let a: ENUM~ = ENUM~.caseName(model: “hello”, size: 10) // 직접 값을 지정하여 사용
👋 Link

연관값을 가지는 열거형 매칭 🔥

👉 ex1) enum switch

let commute = Transportation.subway(line: 2, express: false)

switch commute { // 여기서 Transportation 타입 추론
    case .subway(2): ~ // 따라서, 생략 가능
	case .car: ~
	case .bus(1): ~
	case .bus(2, "seoul", _): ~
	case .bus(3, let src, let dest): ~
    // 모든 변수의 바인딩 방식이 동일하다면 let이나 var을 맨 앞에 쓸 수 있음
    case let .plain(line, station):
        print("line: \(line), station: \(station)")
    default:
        break // 각 case엔 break가 생략되어 있으며, 공란은 허용하지 않기에 do nothing 기능을 위해서는 break를 명시적으로 작성해야 함
}

👉 ex2) enum if

let commute = Transportation.subway(line: 2, express: false)
if case let .subway(2, express) = commute { ~ }
// #1 let을 case뒤에 작성함으로써 인자에 let을 적지 않아도 됨 // if case .subway(2, let express) = commute
// #2 commute가 왼쪽과 매칭되냐의 의미
// #3 .subway로 작성이 가능한 이유는 오른쪽으로부터 타입을 참고하였기 때문
// #4 if case let ; switch문과 같이 모든 케이스를 작성하는 것이 아닌 원하는 단 하나의 경우만 체크할 수 있도록 하여 편하게 사용하도록 하는 swift 문법
// ; The Swift If-Case-Let syntax is a convenient shortcut to avoid a full switch statement when you only want to match a single case.

열거형 특징

👉 enum은 연산 프로퍼티나 메소드를 포함할 수 있으며, 확장이 가능하고, 프로토콜을 따르도록 정의할 수 있음
　　👋 ex)

enum HTTPCode: Int {
    case OK = 200
    case NOT_MODIFY = 304
    case SERVER_ERROR = 500

    var value: String { // 연산 프로퍼티 (읽기 전용, get 생략)
        return "HTTP number is \(self.rawValue)"
    }

    var code: Int {
        switch self { // 여기서 self는 자신의 케이스를 의미
        case .OK: return 2022
        case .NOT_MODIFY: return 2023
        //...
        }
    }

    func getDescription () -> String { // 메소드 포함 가능 (인스턴스 메소드)
        switch self { // 여기서 self는 자신의 케이스를 의미
        case .OK:
            return "HTTP 코드는 \(self.rawValue) 입니다"
        //...
        }
    }
        
    static func getName() -> String { // 타입 메소드
        return "이건 HTTPCode야~~"
    }
}

Self 🆚 self

👉 Self : 타입 프로퍼티와 타입 메소드를 가리킬 때 사용
👉 self : 인스턴스 프로퍼티와 인스턴스 메소드를 가리킬 때 사용

프로퍼티 종류 3가지

👉 저장 프로퍼티 : 클래스/구조체 에서 사용
　　👉 클래스/구조체의 인스턴스의 일부가 되는 상수(let) 및 변수(var)
　　👉 let으로 선언된 저장 프로퍼티는 수정 불가능
　　👉 var로 선언된 저장 프로퍼티는 수정 가능
　　👉 선언 시 초기값을 지정할 수 있으며, 수정 또한 가능
　　👉 lazy 저장 프로퍼티
　　　　👉 해당 저장 프로퍼티는 사용되기 전까지 생성되지 않음
　　　　　　👉 따라서, 잘 활용할 경우 성능 향상, 공간낭비를 줄일 수 있다는 장점이 있음
　　　　👉 반드시 var로 선언되어야 함
　　　　　　👉 let으로 선언된 프로퍼티는 초기화를 함과 동시에 값을 필요로 하기 때문에, 값이 필요할 때에 초기화를 하는 lazy와는 거리가 있음
👋 Link

👉 연산 프로퍼티 : 클래스/구조체/열거형 에서 사용
　　👉 반드시 var로 선언해야 함
　　　　👉 연산 프로퍼티니까 값이 변경되어야 함
　　　　👉 연산된 값을 저장할 공간, 즉, 다른 변수(저장 프로퍼티)를 반드시 필요로 함
　　👉 연산 프로퍼티는 get, set 메서드 가지고 있음
　　　　👉 get만 선언 O (읽기 전용)
　　　　　　👉 get만 있는 읽기 전용 연산 프로퍼티는 get 생략 가능
　　　　　　👉 즉, 단순히 { return } 으로 작성 가능
　　　　👉 get/set 선언 O (읽기/쓰기)
　　　　👉 set만 선언 X
　　👉 get의 return 타입은 연산 프로퍼티의 타입과 반드시 같아야 함
　　👉 set은 작성 방식, 두 가지
　　　　👉 set { x(저장 프로퍼티) = newValue + 1 }
　　　　👉 set(tempX) { x(저장 프로퍼티) = tempX + 1 }
　　👉 ex)

struct Info {
    var num = 3 // 저장 프로퍼티

    var cal: Int { // 연산 프로퍼티
        get {
            let tempX = num + 3

            return tempX // return 타입 유의
        }
        set(value) {
            num = value - 3
        }
    }
}

👋 Link

👉 타입 프로퍼티 : 클래스/구조체/열거형 에서 사용
　　👉 static 키워드를 붙임으로써 타입 프로퍼티를 정의할 수 있음
　　👉 타입 프로퍼티에는 저장 타입 프로퍼티, 연산 타입 프로퍼티가 있음
　　👉 저장 타입 프로퍼티
　　　　👉 let / var로 선언 가능
　　　　👉 무조건 기본값을 설정해야 함
　　　　👉 처음 액세스 할 때는 lazy와 같이 자동으로 지연 초기화
　　　　　　👉 즉, lazy 키워드는 필요 X
　　👉 연산 타입 프로퍼티
　　　　👉 반드시 var로 선언해야 함(연산 인스턴스 프로퍼티처럼)
　　　　👉 클래스 타입에 대한 연산 타입 프로퍼티의 경우 static 대신 class 키워드를 붙임으로써 서브 클래스가 슈퍼 클래스의 구현을 오버라이드 할 수 있음
　　　　👉 서브 클래스에서 static 키워드 앞에 override 키워드를 붙여야 함
　　　　　　👉 override static var ~
　　　　👉 타입 프로퍼티는 타입 자체에 .연산자를 통해 프로퍼티에 접근
　　　　　　👉 반면에, 인스턴스 프로퍼티는 인스턴스에 .연산자를 통해 프로퍼티에 접근
👋 Link

Property Observer

👉 프로퍼티 옵저버는 lazy 키워드가 없는 저장 프로퍼티에 추가할 수 있음
　　👉 부모 클래스의 연산 프로퍼티를 오버라이딩 할 경우 또한 프로퍼티 옵저버를 추가하는 것이 가능
👉 willSet
　　👉 값이 설정되기 직전에 호출되는 메소드, 새롭게 설정될 값이 newValue
　　👉 willSet 작성 방식, 두 가지
　　　　👉 willSet { newValue }
　　　　👉 willSet(A) { A }
👉 didSet
　　👉 새로운 값이 설정된 직후에 호출되는 메소드, 새로 설정되기 이전의 값이 oldValue
　　👉 didSet 작성 방식, 두 가지
　　　　👉 didSet { oldValue }
　　　　👉 oldSet(B) { B }
👉 ex)

class StepCounter {
    var totalSteps: Int = 0 {
        willSet(newTotalSteps) {
            print("totalSteps을 \(newTotalSteps)로 설정하려고 합니다.")
        }
        
        didSet(oldTotalSteps) {
            if totalSteps > oldTotalSteps  {
                print("\(totalSteps - oldTotalSteps)걸음이 추가되었습니다.")
            }
        }
    }
}

let stepCounter = StepCounter()
stepCounter.totalSteps = 200
// totalSteps을 200로 설정하려고 합니다. (willSet)
// 200(200 - 0)걸음이 추가되었습니다. (didSet)

Struct 🆚 Class 🆚 Enum

👉 struct와 enum의 인스턴스는 값 타입이지만, class의 인스턴스는 참조 타입
👉 struct와 enum은 상속이 불가능하지만, class는 상속이 가능
👉 struct와 class는 생성자가 있지만, enum에는 생성자가 없음
⭐️ 클래스와 구조체의 공통점, 차이점
　　👉 구조체 : 값 타입
　　　　👉 var 선언 시 var 저장 프로퍼티 값 변경 가능
　　　　👉 let 선언 시 모든 저장 프로퍼티 상수화 되어 값 변경 불가능
　　　　👉 생성자가 없어도 됨
　　　　　　👉 기본적으로 저장 프로퍼티들을 파라미터로 가지는 이니셜라이져가 있으며 초기값을 준다면 후에 값을 설정해주지 않아도 됨
　　👉 클래스 : 참조 타입
　　　　👉 let/var 선언 관계 없이 var 저장 프로퍼티 값 변경 가능
　　　　👉 let 저장 프로퍼티는 변경 불가능
　　　　👉 저장 프로퍼티에 초기값이 없으면 생성자(init) 반드시 필요
　　　　　　👉 단, 저장 프로퍼티에 초기값이 지정되어 있다면 생성자가 없어도 됨

class 성능 향상 방법 🔥

👉 상속이 없는 클래스는 final로 선언하기
　　👉 class 성능 향상은 Dispatch 과정 관련
　　👉 Dispatch? 어떠한 메소드를 실행하여 처리할 지 결정하는 과정 (바인딩 in C++)
　　👉 Dispatch 종류?
　　　　👉 Static Dispatch : 컴파일 시점에 어떤 메소드가 사용될 지 결정
　　　　👉 Dynamic Dispatch : 런타임 시점에서 어떤 메소드가 사용될 지 결정
　　　　　　👉 Dynamic Dispatch는 참조에 따라 함수를 호출하기 때문에 overhead가 발생
　　　　　　👉 이러한 overhead는 상속이 가능한 class의 override 될 수 있는 메소드에서 발생
　　　　　　👉 따라서, override가 확실히 되지 않음을 컴파일러에게 알려주면 overhead가 발생하지 않아 성능이 향상
👉 외부 접근이 없는 경우 private 키워드 사용하기
👉 변경이 없는 변수는 let 키워드를 사용하기
👉 변수 선언 시 타입을 지정하기

Optional

👉 nil의 허용 여부를 나타내는 것
👉 옵셔널 종류 2가지
　　👉 ? : 옵셔널
　　　　👋 ex)

var optionalValue: Int? = 100  

optionalValue = optionalValue + 1 // 기존 변수처럼 사용 불가
optionalValue = nil // nil 할당 가능

　　👉 ! : 묵시적 추출 옵셔널
　　　　👉 Non-Optional Type으로 처리되어야 할 때 값을 자동으로 추출해주는 장점이 있음
　　　　👉 잘못 사용 시, 런타임 에러가 발생할 수 있음

var optionalValue: Int! = 100

optionalValue = optionalValue + 1 // 기존 변수처럼 사용 가능
optionalValue = nil // nil 할당 가능
optionalValue = optionalValue + 1 // 옵셔널에 nil이 할당되어 있을 때 접근 시도 -> 런타임 오류

Optional 해제

👉 명시적 해제
　　👉 강제 언래핑 : ! 키워드 사용

var number: Int? = 3

print(number) // Optional(3)
print(number!) // 3

　　👉 비강제 언래핑 : 옵셔널 바인딩

if let result = number { // 옵셔널 바인딩
    print(result)
} else {
    print("nil")
}

👉 묵시적 해제
　　👉 컴파일러에 의한 자동 해제

let value: Int? = 6

if value == 6 { // 비교 연산자를 이용하여 다른 값과 비교 할 경우, 컴파일러가 자동적으로 옵셔널 값을 해제
    print("value가 6입니다.")
} else {
    print("value가 6이 아닙니다.")
}

　　👉 옵셔널의 묵시적 해제

let str = "12"
var strToInt: Int? = Int(str)
// Int() 함수는 매개변수에 정수로 변환될 수 없는 값이 오면
// nil을 반환하기 때문에 옵셔널 타입으로 선언해야 한다.

print(strToInt) // Optional(12)

var strToInt2: Int! = Int(str)
// 선언 시에 ! 키워드를 사용하면 묵시적으로 옵셔널 해제를 해준다.
// 강제 언래핑 때 사용하는 ! 와는 의미가 다름

print(strToInt2 + 1) // 13

Optional Binding

👉 미리 nil 체크를 함과 동시에 Optional 포장지를 벗겨 값을 안전하게 꺼내오는 방식
👉 값이 있을 때만 값이 바인딩 됨
👉 주로 if let, if var, guard 와 함께 사용
　　👉 guard : 한 줄짜리 간편한 if 구문, 구문 뒤에 항상 else를 달아줘야 함
👉 쉼표를 사용해 여러 옵셔널 변수들을 한꺼번에 바인딩할 수 있음
　　👋 ex)

if let name = myName, let friend = yourName {
    print("실행 : \(name) and \(friend)")
} else { // 바인딩 실패 시 (하나라도 nil이 존재하는 경우)
    print("Binding Error")
}

Optional Chaining

👉 하위 프로퍼티에 옵셔널 값이 있는지 연속적으로 확인하면서 중간에 하나라도 nil이 발견된다면 nil을 반환하는 것
👋 let count: Int? = A.num?.count

typealias

👉 기존에 선언되어 있는 유형에 새로운 유형의 별칭을 사용함으로써 코드의 의미와 가독성을 높이는 개념
👋 ex)

typealias Hi = (Int, Int, Int)
typealias Hello = (title: Int, content: Int, writer: Int)

var hi: Hi = (3, 3, 3)
var hi2 = Hi(4, 4, 4)

var hello: Hello = (title: 1, content: 2, writer: 3)
var hello2 = Hello(title: 4, content: 5, writer: 6)

print(hi.0) // 3
print(hi2.0) // 4

print(hello.title) // 1
print(hello2.writer) // 6

타입 캐스팅

👉 is : 타입 확인 및 서브클래스 확인
👉 as : 타입 변환
　　👉 업캐스팅 : 서브클래스를 슈퍼클래스로 만드는 것, 항상 성공
　　👉 다운캐스팅 : 슈퍼클래스를 서브클래스로 만드는 것, 실패할 수 있기에 as? 혹은 as! 사용

Swift Method

👉 Instance Method
　　👉 인스턴스화하여 생성된 인스턴스를 통해 호출할 수 있는 메소드
👉 Type Method
　　👉 인스턴스의 생성 없이 타입 자체에서 바로 호출할 수 있는 메소드
　　👉 Static Method
　　　　👉 subclass에서 오버라이딩이 불가능한 메소드
　　👉 Class Method
　　　　👉 subclass에서 오버라이딩이 가능한 메소드

Swift init

👉 Designated init
　　👉 Swift의 초기화 이니셜라이져로, 클래스의 모든 프로퍼티를 초기화시키는 역할
　　👉 init 이라고도 불림
　　　　👉 모든 프로퍼티들은 init 함수가 끝나기 전(초기화 종료 전)에 모두 초기값을 가지고 있어야 함
　　　　　　👉 만약 초기값이 없는 프로퍼티가 있을 경우, 초기화에 실패하여 인스턴스가 생성되지 않음
　　　　　　👉 프로퍼티 타입을 옵셔널 타입으로 설정하는 것 또한 초기화를 진행한 것임 (nil로 자동 초기화)
　　　　　　　　👉 let으로 선언된 프로퍼티 타입을 옵셔널 타입으로 지정할 경우 반드시 초기값을 지정해야 함, 그렇지 않으면 에러
　　　　👉 상속 받은 서브 클래스에서 D.I.를 작성할 경우, 반드시 super 클래스의 Initializers를 호출해주어야 함
　　　　👉 ex)

class Human {
    let name: String
    var age: Int? // OK
    let num: Int? // Error!
    
    init(name: String) {
        self.name = name
    }
}
 
class Sodeul: Human {
    let alias: String
    
    init(alias: String) { 
        super.init(name: alias) // 없으면 에러 발생
        self.alias = alias
    }
}

👉 Convinience init
　　👉 보조 이니셜라이져로, 일부 프로퍼티를 원하는 값으로 저장하는 역할을 하기에 C.i. 내부에서 반드시 D.i.를 호출해야 함
　　　　👉 모든 프로퍼티를 초기화해주는 D.i.를 도와주는 역할
　　　　👉 ex)

class Human {
    var name: String
    var nickName: String
    
    init(name: String, nickName: String) {
        self.name = name
        self.nickName = nickName
    }
    
    convenience init(name: String) {
        self.init(name: name, nickName: "unknown")
    }
}

👋 Link

Swift 초기화 심화 개념 🔥

👉 Initializer Delegation
　　👉 생성자에서 또 다른 생성자를 호출하여 초기화 코드의 중복을 최대한 제거하고, 모든 프로퍼티를 효율적으로 초기화 하기위해 사용하는 것
　　👉 Wrong ex)

struct Position { // Initializer Delegation 준수 X
    var x: Int
    var y: Int
    
    // 만약, Initializer에서 y를 무조건 0으로 초기화 하고 싶다면

    init(xPos: Int, yPos: Int) {
        x = xPos
        y = yPos // 이 곳을 y = 0으로 수정해야하고
    }

    init(pos: Int) {
        x = pos
        y = pos // 이 곳 또한, y = 0으로 수정해야 함 -> 코드 중복
    }
}

　　👉 Correct ex)

struct Position { // Initializer Delegation 준수 O
    var x: Int
    var y: Int

    // 만약, Initializer에서 y를 무조건 0으로 초기화 하고 싶다면
    
    init(xPos: Int, yPos: Int) {
        x = xPos
        y = yPos // 이 곳만 y = 0으로 수정하면 끝 :)
    }

    init(pos: Int) {
        self.init(xPos: pos, yPos: pos)
    }
}

👋 Link

👉 deinit
　　👉 소멸자로, 클래스 인스턴스가 메모리에서 해제되기 직전에 호출됨
👉 required init?
　　👉 code ex)

class SampleView: UIView {
    override init(frame: CGRect) {
        //code
    }

    required init?(coder: NSCoder) {
        //code
    }
}

　　👉 쉽게 말해, UIView/UIViewController를 상속받는 클래스에서 프로퍼티를 선언하고 init() 메소드를 작성할 것인데, 슈퍼클래스가 NSCoding 프로토콜을 준수하기에, required init?(coder: NSCoder) 메소드를 작성해야 함
　　　　👉 NSCoding 프로토콜은 이를 구현하는 클래스로부터 실패 가능한 이니셜라이저를 작성하도록 함
　　　　　　👉 클래스가 encoding 과 decoding 되는 것을 가능하게 해주는 프로토콜
　　　　　　👉 다시 말하면, NSCoding을 채택한 클래스는 encoding 및 decoding 가능
　　　　👉 프로토콜에 적혀있는 이니셜라이저를 구현하면 required 키워드가 붙으며, required 키워드가 붙은 이니셜라이저를 상속받는 자식 클래스에서도 이를 구현해줘야 할 수도 있음
　　　　👉 UIView/UIViewController는 NSCoding 프로토콜을 구현하고 있기 때문에, 이를 상속받은 클래스에서는 required init?(coder: )를 구현해줘야 할 수도 있음
　　　　　　👉 즉, 아예 작성을 안하거나, init을 작성한다면 반드시 같이 작성해야 함
　　　　　　　　👉 swift에서는 자식 클래스에서 지정 이니셜라이저를 따로 작성하지 않은 경우, 부모의 이니셜라이져들을 자동으로 상속
　　　　　　　　👉 따라서, 새로운 D.i.를 자식 클래스에서 작성하지 않았을 경우에 에러가 발생하지 않았음
　　　　　　　　👉 하지만, 자식클래스에서 새로운 D.i.를 작성하게 된다면, 부모 클래스의 이니셜라이저들이 자동 상속하지 않기 때문에, required init?(coder: )를 구현하라는 에러가 발생
　　👉 code로 custom한 UIView/UIViewController 등 무언가를 만들 때에 init을 반드시 해야 하는 이유?
　　　　👉 인터페이스 빌더에서는 자동으로 초기화를 해주지만, 코드에서는 인터페이스 빌더를 사용하는 게 아니기 때문에 초기화를 하지 않는다면 아무것도 뜨지 않기 때문
　　　　　　👉 인터페이스 빌더의 대표적인 예시 : Storyboard, Xib
　　　　👉 다양한 사용 예시
　　　　　　👋 override init(frame: CGRect) // UIView
　　　　　　👋 override init(nibName nibNameOrNil: String?, bundle nibBundleOrNil: Bundle?) // UIViewController
　　　　　　👋 override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) // UITableViewCell
　　　　　　👋 override init(reuseIdentifier: String?) // UITableViewHeaderFooterView
👋 Link
👋 Link

👉 init? 🆚 init!
　　👉 init? : 초기화에 성공하면 초기화된 인스턴스가 “Optional Type”으로 리턴, 초기화에 실패하면 “nil”을 리턴
　　👉 init! : 초기화에 성공하면 초기화된 인스턴스가 “Non Optional Type”으로 리턴, 초기화에 실패하면 크래시가 발생

Protocol

👉 반드시 가져야 할 프로퍼티나 메소드를 정의만 하는 청사진 역할
👉 프로토콜을 적용할 객체는, 프로토콜에서 정의했던 프로퍼티와 메소드를 반드시 구현해야 함

Protocol Property

👉 프로토콜은 프로퍼티가 저장 프로퍼티인지, 연산 프로퍼티인지 명시하지 않음
👉 대신 읽기만 가능한지, 읽기/쓰기 모두가 가능한지 명시해야 함
👉 또한, 프로토콜의 프로퍼티는 반드시 var로 선언되야 함
👉 ex)
👉 프로토콜의 프로퍼티가 get만 필요로 하는 경우, 모든 종류의 프로퍼티에서 요구사항을 충족시킬 수 있음
　　👉 상수 저장 프로퍼티

protocol FullyNamed {
    var fullName: String { get }
}
struct Person: FullyNamed {
    let fullName: String
}
var john = Person(fullName: "John Appleseed")
john.fullName = "Zedd" // error! 'fullName' is a 'let' constant

　　👉 변수 저장 프로퍼티

protocol FullyNamed {
    var fullName: String { get }
}
struct Person: FullyNamed {
    var fullName: String
}
var john = Person(fullName: "John Appleseed")
john.fullName = "Zedd" // ok

　　👉 연산 프로퍼티 get

protocol FullyNamed {
    var fullName: String { get }
}
struct Person: FullyNamed {
    var name: String // 실제 값 저장될 저장 프로퍼티
    var fullName: String {
        return name
    }
}
var john = Person(name: "John Appleseed")
john.fullName = "Zedd" // error! 'fullName' is a get-only property
print(john.fullName) // ok

　　👉 연산 프로퍼티 get/set

protocol FullyNamed {
    var fullName: String { get }
}
struct Person: FullyNamed {
    var name: String // 실제 값 저장될 저장 프로퍼티
    var fullName: String {
        get {
            return name
        }

        set {
            name = newValue
        }
    }
}
var john = Person(name: "John Appleseed")
john.fullName = "Zedd" // ok
print(john.fullName) // ok

👉 프로토콜의 프로퍼티가 get과 set 모두 필요로 하는 경우, 상수 저장 프로퍼티와 읽기 전용 연산 프로퍼티가 될 수 없음
　　👉 상수 저장 프로퍼티

protocol FullyNamed {
    var fullName: String { get set }
}
struct Person: FullyNamed {
    let fullName: String // error! error: type 'Person' does not conform to protocol 'FullyNamed'
}
var john = Person(fullName: "John Appleseed")

　　👉 변수 저장 프로퍼티

protocol FullyNamed {
    var fullName: String { get set }
}
struct Person: FullyNamed {
    var fullName: String
}
var john = Person(fullName: "John Appleseed")
john.fullName = "Zedd" // ok

　　👉 연산 프로퍼티 get

protocol FullyNamed {
    var fullName: String { get set }
}
struct Person: FullyNamed {
    var name: String // 실제 값 저장될 저장 프로퍼티
    var fullName: String {
        return name // error! error: type 'Person' does not conform to protocol 'FullyNamed'
    }
}
var john = Person(name: "John Appleseed")

　　👉 연산 프로퍼티 get/set

protocol FullyNamed {
    var fullName: String { get set }
}
struct Person: FullyNamed {
    var name: String // 실제 값 저장될 저장 프로퍼티
    var fullName: String {
        get {
            return name
        }

        set {
            name = newValue
        }
    }
}
var john = Person(name: "John Appleseed")
john.fullName = "Zedd" // ok
print(john.fullName) // ok

Any 🆚 AnyObject

👉 Any는 함수 타입을 포함한 모든 타입의 인스턴스를 나타낼 수 있는 프로토콜
👉 반면, AnyObject는 클래스 타입의 인스턴스만을 나타낼 수 있는 프로토콜

객체 지향 프로그래밍 🆚 프로토콜 지향 프로그래밍

👉 객체 지향 프로그래밍
　　👉 상속을 통해 수직적으로 타입을 확장하는 구조
　　👉 하나의 서브클래스는 하나의 슈퍼클래스만 가질 수 있다는 제한이 있음
　　👉 슈퍼클래스를 그대로 상속 받기에 불필요한 변수와 메소드를 모두 물려 받아야 하는 단점
👉 프로토콜 지향 프로그래밍
　　👉 프로토콜 확장을 통해 수평적으로 타입을 확장하는 구조
　　👉 상속과는 다르게 다수의 프로토콜을 가지는 것이 가능
　　👉 부모 프로토콜과 자식 프로토콜 사이가 서로 독립적이기에 불필요한 프로퍼티나 메소드를 갖지 않게 할 수 있음

map

👉 컬렉션이 보유한 각 값들을 매개변수로 전달받은 함수에서 로직을 처리한 후 새로운 컬렉션으로 반환하는 함수

filter

👉 컬렉션이 보유한 값들 중 매개변수로 전달받은 함수의 결과가 True인 값만 새로운 컬렉션에 넣어 반환하는 함수

reduce

👉 초기값에 컬렉션이 보유한 각 값들을 매개변수로 전달받은 함수에서 모두 계산하여 연산 결과로 반환하는 함수

flatMap 🆚 compactMap

👉 Swift 4.1부터 flatMap은 2차원 배열을 1차원 배열로 만드는 역할
　　👉 기존의 flatMap은 배열을 flatten하게 만들어 주고, nil을 제거하며, 옵셔널 바인딩을 하는 역할
👉 Swift 4.1부터 1차원 배열에서 nil을 제거하고 옵셔널 바인딩을 하고 싶을 때 compactMap을 사용
　　👉 compactMap은 2차원 배열을 1차원 배열로 만들지 않음
👉 nil이 포함된 2차원 배열에서 flatmap과 compactmap을 순서대로 체이닝 연결하면 1차원 배열로 nil을 제거하고 옵셔널 바인딩을 해줄 수 있음
👉 1차원 배열에서는 동일한 결과

Swift의 sort() 구현 방식?

👉 Insertion Sort와 Merge Sort가 합쳐진 형태인 Tim Sort로 구현되어 있음
👉 시간 복잡도 : 최선의 경우 O(n), 최악의 경우 O(nlogn)

Result

👉 성공과 실패에 대한 결과 값을 반환하고 싶을 때 사용하는 타입
👉 Result 타입은 enum이며, 두 개의 제네릭한 결과를 리턴
　　👉 Failure 타입은 Error를 상속받은 타입이어야 함
　　👉 Success 타입은 void, string, int 등 값 타입을 사용해도 됨

Subscripts

👉 컬렉션, 리스트, 시퀀스 등 집합의 특정 요소에 쉽게 접근할 수 있는 문법
👉 배열에서는 인덱스를 통해, 딕셔너리에서는 키 값을 통해 접근
👉 ex)

var dict = ["Kim": 1, "Lee": 2]
dict["Park"] = 3 // Subscript 문법

var arr = [3, 2, 4, 8]
arr[0] = 1 // Subscript 문법
print(arr[0]) // Subscript 문법

Collection 🆚 Sequence

👉 Collection
　　👉 Collection 프로토콜은 Sequence 프로토콜을 준수하고 있음
　　👉 대표적으로, Array, Set, Dictionary가 Collection 프로토콜을 준수하고 있음
👉 Sequence
　　👉 각 요소에 순차적이고 반복적인 접근이 가능한 타입

Copy On Write

👉 데이터 복사 시 실제로 값을 복사하지 않고 단순히 값을 참조만 하다가 데이터 변경이 발생될 시 값을 복사해 변경하는 기법
👉 Collection Type을 복사해서 사용할 때 일어남
　　👉 Swift에서는 기본적으로 Collection 타입에 COW가 구현되어 있기 때문
👉 단순히 값을 참조만 하다가 데이터 변경이 발생될 시 값을 복사하여 불필요한 복사를 줄이는 매커니즘
👉 기존의 오버헤드를 줄일 수 있음
👉 생성되는 사본 수를 확인하기 위해 Reference Count를 계산해야 한다는 단점이 존재

String of Swift

👉 swift에서 string은 값 타입으로 분류되며, character의 collection
👉 character는 각각 다른 크기의 메모리를 차지할 수 있는 유니코드를 준수하기 때문에 Subscript로 접근 X
👉 또한, character 타입은 힙 영역에 간접적으로 저장되기에, 따라서, String은 값 타입이지만 힙 할당이 발생

String 🆚 NSString

👉 String
　　👉 구조체, 값 타입
👉 NSString
　　👉 클래스, 참조 타입

NSAttributedString 🆚 NSMutableAttributedString

👉 NSAttributedString
　　👉 텍스트 자체에 스타일을 설정할 수 있는 텍스트 타입
👉 NSMutableAttributedString
　　👉 NSAttributedString의 특정 범위에 다양한 스타일(색상, 자간 등)을 설정할 수 있는 텍스트 타입

KVC 🔥

👉 Key-Value Coding
👉 객체의 값을 직접 가져오지 않고, Key 또는 KeyPath를 이용해서 간접적으로 데이터를 가져오거나 수정하는 방법
👉 ex)

struct Address {
    var town: String
}

struct Person {
    var address: Address
}
let address = Address(town: "Lalala")
var kid = Person(address: address)

kid[keyPath: \.address.town] // Lalala

kid[keyPath: \.address.town] = "Hello"
kid[keyPath: \.address.town] // Hello
kid.address.town // Hello

👋 Link

KVO 🔥

👉 Key-Value Observing
👉 객체의 프로퍼티의 변경사항을 다른 객체에 알리기 위해 사용하는 코코아 프로그래밍 패턴
👉 Model과 View와 같이 논리적으로 분리된 파트간의 변경사항을 전달하는데 유용
👉 NSObject를 상속한 클래스에서만 KVO를 사용할 수 있음
👋 Link

Codable

👉 자신을 외부 표현으로 인코딩할 수 있는 유형인 Encodable과 외부 표현으로부터 자신을 디코딩할 수 있는 유형인 Decodable로 구성된 프로토콜
👉 주로, API에서 JSON Data를 다룰 때 사용
　　👉 JSON Data 중 필요한 데이터를 모델로 정리한 Struct, Class 혹은 Enum을 통해 사용

CodingKey

👉 주로 Codable 프로토콜에서 JSON Key를 사용자가 정의한 프로퍼티에 매핑하기 위해 사용하는 프로토콜
👉 ex)

struct Coffee: Codable {
    var name: String

    enum CodingKeys: String, CodingKey {
        case name = "order_Drink_Name"
    }
}

Identifiable

👉 Hashable 프로토콜을 준수하며, id 프로퍼티 하나만 가지는 아주 단순한 프로토콜
👉 채택한 타입의 id를 통하여 고유 개체를 비교 및 구분하게 되는 방식
👉 UUID : 범용 고유 식별자로, 고유하게 식별하기 위해 만들어진 개념
　　👉 총 36개 문자(32개 문자와 4개의 하이픈)으로 구성되어 있음

Hashable & Equatable

👉 Hashable
　　👉 채택한 타입이 유일한 값으로 구분됨을 보장해주는 프로토콜
　　👉 내부의 hash function을 통해 해시 값을 결정
　　👉 Hashable은 Equatable 프로토콜을 상속하고 있음
　　　　👉 H가 E를 상속해야 하는 이유
　　　　　　👉 객체의 동일 여부는 명확한 판단 기준을 필요로 함
　　　　　　👉 Equatable : 값의 비교가 가능함을 보장해주는 프로토콜
　　　　　　👉 ==, != 연산자를 정의하여 객체의 동일 여부의 기준을 결정함
　　　　　　　　👉 즉, Equatable 프로토콜을 상속 받아 Hashable 타입이 객체의 동일 여부를 판단할 수 있도록 함

CaseIterable

👉 enum 열거형의 값들을 배열 컬렉션과 같이 순회할 수 있도록 해주는 프로토콜
👉 주로 allCases 타입 프로퍼티와 함께 많이 쓰임

Mutating

👉 값 타입의 프로퍼티는 기본적으로 메소드 내부에서 수정할 수 없음
👉 수정이 필요한 경우 메소드 앞에 mutating 키워드를 사용하여 수정이 가능해 짐
　　👉 메소드 내에서 값 타입의 프로퍼티를 수정하면, 해당 인스턴스의 복사본이 생성되어 변경되는 것
　　👉 즉, 복사본이 변경이 변경되었을 뿐 원래의 인스턴스와 무관함
　　👉 mutating은 이 복사본을 원래의 인스턴스로 리턴하는 역할로 이해하면 됨

Extension

👉 이미 존재하는 클래스, 구조체, 프로토콜 등의 타입에 새로운 기능을 추가하여 확장하는 개념
👉 연산 프로퍼티, 메소드, 프로토콜 등을 추가할 수 있음
👉 원본 소스 코드에 접근할 수 없는 유형을 확장하는 기능도 포함되어 있음
👉 extension 내부에서 함수 오버라이딩 가능한지?
　　👉 해당하는 메소드가 Objective-C와 호환되는 경우 오버라이딩이 가능은 하지만, 일반적으로 권장되는 방법은 아님
　　👉 그 이유는, extension은 추가적인 기능의 확장을 사용하는 개념이기 때문

Defer

👉 함수 안에서 작성되는 클로저
👉 작성된 위치와 상관없이 함수 종료 직전에 실행됨
👉 호출되는 순서
　　👉 하나의 스코프에서 여러 defer를 사용할 경우 스택처럼 쌓임
　　👉 가장 먼저 넣은 defer 코드가 가장 마지막에 호출됨
　　👉 가장 마지막에 넣은 defer 코드가 가장 먼저 호출됨
👉 defer가 호출되기 전에 해당 스코프가 에러 등으로 인해 종료되거나, 리턴 값이 Never(비반환)인 경우에는 defer가 호출되지 X

Closure

👉 Named Closure
　　👉 일반적으로 이름이 있는 함수
　　👉 ex)

func hello() {
    print("hello")
}

👉 Unnamed Closure
　　👉 이름 없이 사용하는 익명함수
　　👉 일급 객체 특징을 갖고 있음
　　　　👉 변수에 담을 수 있음
　　　　👉 인자로 전달 가능
　　　　👉 반환 값에 사용 가능
　　👉 클로저는 Named C- & Unnamed C- 모두 포함하지만, 보통 Unnamed C-를 클로저라 함
　　👉 ex)

let closure = { (name: String) -> String in
    return "Hello, \(name)"
}

Escaping Closure

👉 @escaping 키워드가 붙은 클로저
👉 함수의 인자로 클로저를 전달하는 방식
　　👉 함수의 인자로 전달된 클로저는 기본적으로 함수의 스코프 내부에서만 사용이 가능하여, 외부 변수에 담을 수 없음
　　👉 즉, 기본적으로 탈출 불가능하다는 속성을 가지고 있음
　　👉 또한, 함수의 인자로 전달된 클로저는 해당 함수가 끝나기 이전에 반드시 해당 클로저가 실행됨
　　👉 즉, 해당 함수가 끝나게 되면 인자로 넘어간 클로저는 사용이 불가능
👉 @escaping 키워드를 붙임으로써, 함수가 리턴된 후 함수의 스코프 밖에서 클로저를 실행할 수 있음
👉 함수가 리턴된 후 함수의 스코프 밖에서 클로저를 실행할 수 있어 비동기 작업을 처리할 때 사용함

Swift Access Control(접근 제어자)

👉 open
　　👉 모듈 외부에서 access 가능
　　👉 모듈 외부 상속과 override 가능
👉 public
　　👉 모듈 외부에서 access 가능
　　👉 모듈 외부 상속과 override 불가능
👉 internal(default 값)
　　👉 같은 모듈 안에서 access 가능
👉 fileprivate
　　👉 같은 파일 안에서 access 가능
👉 private
　　👉 같은 스코프 안에서 access 가능

*****

Swift Computer Science of Swift

💛 Swift

Swift 함수 형태 및 관련 용어

rawValue(원시값)

associated Value(연관값)

연관값을 가지는 열거형 매칭 🔥

열거형 특징

Self 🆚 self

프로퍼티 종류 3가지

Property Observer

Struct 🆚 Class 🆚 Enum

class 성능 향상 방법 🔥

Optional

Optional 해제

Optional Binding

Optional Chaining

typealias

타입 캐스팅

Swift Method

Swift init

Swift 초기화 심화 개념 🔥

Protocol

Protocol Property

Any 🆚 AnyObject

객체 지향 프로그래밍 🆚 프로토콜 지향 프로그래밍

map

filter

reduce

flatMap 🆚 compactMap

Swift의 sort() 구현 방식?

Result

Subscripts

Collection 🆚 Sequence

Copy On Write

String of Swift

String 🆚 NSString

NSAttributedString 🆚 NSMutableAttributedString

KVC 🔥

KVO 🔥

Codable

CodingKey

Identifiable

Hashable & Equatable

CaseIterable

Mutating

Extension

Defer

Closure

Escaping Closure

Swift Access Control(접근 제어자)

Swift

Computer Science of Swift