[Swift🦩] #22 프로토콜 ⭐️⭐️

• 필요한 변수, 함수를 정의만 하고,
• 클래스, 구조체, 열거형 에서 채택해서 구현
• 프로토콜의 요구사항을 모두 구현하면 프로토콜을 준수 한다고 함.

1. 프로토콜 문법

protocol SomeProtocol: Hashable, Codable { // 다른 프로토콜 채택 가능.
    // 요구사항 정의
}

class SomeClass: SomeSuperClass, Hashable, Codable {
    // 상속이 먼저, 프로토콜 채택이 나중에.
}

2. Property

• 인스턴스 프로퍼티, 타입 프로퍼티를 모두 요구사항으로 넣을 수 있다.
• 이름과 타입, gettable, settable만 지정
• 계산 프로퍼티인지 저장 프로퍼티인지는 지정 X

protocol SomeProtocol {
    var mustBeSettable: Int { get set } // 무조건 set 이 가능해야함.
    var doesNotNeedToBeSettable: Int { get } // set 은 가능할수도? 아닐수도?
    static var someTypeProperty: Int { get set }
}

다른 변수를 더 구현하는 것은 상관 없으나, 프로토콜에 요구되는 변수는 모두 구현해야한다.

3. Method

• 인스턴스 메서드, 타입 메서드 가능.
• 이름, 인자, 반환값만 들어간다.
• 중괄호, 메서드 바디는 없음

protocol SomeProtocol {
    static func someTypeMethod()
}

protocol RandomNumberGenerator {
    func random() -> Double
}

class LinearCongruentialGenerator: RandomNumberGenerator {
    var lastRandom = 42.0
    let m = 139968.0
    let a = 3877.0
    let c = 29573.0
    func random() -> Double {
        lastRandom = ((lastRandom * a + c)
            .truncatingRemainder(dividingBy:m))
        return lastRandom / m
    }
}
let generator = LinearCongruentialGenerator()
print("Here's a random number: \(generator.random())")
print("And another one: \(generator.random())")

4. mutating

• 메서드가 속한 인스턴스를 변경해야 하는 경우가 있음.
• mutating 키워드를 사용.

protocol Togglable {
    mutating func toggle()
}

enum OnOffSwitch: Togglable {
    case off, on
    mutating func toggle() {
        switch self {
        case .off:
            self = .on
        case .on:
            self = .off
        }
    }
}
var lightSwitch = OnOffSwitch.off
lightSwitch.toggle() // .on

• mutating 키워드의 경우, 값 타입에서만 가능. class 타입에선 쓰지 않음.
• 그래서 protocol 내부에 mutating func 가 있는데 그 protocol 을 class 에서 채택하게 되면 mutating 키워드를 작성하지 않아도 됨.

5. init

• 프로토콜은 init 도 요구 가능하다.

protocol SomeProtocol {
    init(someParameter: Int)
}

프로토콜 내 init 을 클래스에서 구현하기

• 프로토콜 내에 있는 init 을 구현할 때는
• required 키워드를 붙여줘야 한다.

class SomeClass: SomeProtocol {
    required init(someParameter: Int) {
        // initializer implementation goes here
    }
}

• 만약 상속받은 상위 클래스에도 해당 init 이 있고,
• 채택한 프로토콜에도 해당 init 이 있다면?
• required override init 으로 같이 쓰면 된다.

protocol SomeProtocol {
    init()
}

class SomeSuperClass {
    init() {
        // initializer implementation goes here
    }
}

class SomeSubClass: SomeSuperClass, SomeProtocol {
    // "required" from SomeProtocol conformance; "override" from SomeSuperClass
    required override init() {
        // initializer implementation goes here
    }
}

failable init in protocol

• 프로토콜에 failable init 이 있다면??
• 해당 init 을 구현부에서 init 으로 구현해도, init? 으로 구현해도 사용할 수 있다.

6. 타입으로서 Protocol

• 프로토콜은 기능을 구현하지 않는다.
• 하지만? 타입으로 사용할 수가 있는데...
• 해당 프로토콜을 준수하는 어떤 타입 이라는 뜻.
• 파라미터, 반환 / 상수, 변수, 프로퍼티의 타입 / 배열, 딕셔너리, 컨테이너의 항목 타입으로 사용 가능.

class Dice {
    let sides: Int
    let generator: RandomNumberGenerator
    // generator 가 RandomNumberGenerator 라는 타입을 채택하는 어떤 타입의 인스턴스임.
    // 다운 캐스팅으로 기존 타입으로 사용 가능.
    init(sides: Int, generator: RandomNumberGenerator) 
        self.sides = sides
        self.generator = generator
    }
    func roll() -> Int {
        return Int(generator.random() * Double(sides)) + 1
    }
}

var d6 = Dice(sides: 6, generator: LinearCongruentialGenerator())
for _ in 1...5 {
    print("Random dice roll is \(d6.roll())")
}

7. Delegation ⭐️⭐️

• 클래스나 구조체가 책임의 일부를 다른 타입의 인스턴스에게 넘겨주거나 위임하는 디자인 패턴.
• 위임하는 작업을 캡슐화하는 프로토콜을 정의하고, 위임 받는 것이 그 프로토콜을 구현.
• 특정 작업에 응답하거나 / 해당 소스의 기본 타입을 알 필요 없이 외부 소스에서 데이터를 검색하는데 사용 가능.

protocol DiceGame { // 게임에 채택되는 프로토콜
    var dice: Dice { get }
    func play()
}

protocol DiceGameDelegate: AnyObject { // 게임 진행 상황을 추적하는데 채택
    func gameDidStart(_ game: DiceGame)
    func game(_ game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int)
    func gameDidEnd(_ game: DiceGame)
}

• delegate 는 강한 순환 참조를 발생시킬 수 있기 때문에 weak 로 선언.
• 프로토콜을 채택한 객체의 함수를 사용해야하니까, 그 객체를 계속 참조하고 있게 됨.
• 해당 객체는 내려가야하는데 내려가지 않는 상황이 올 수 있다.

class SnakesAndLadders: DiceGame {
    let finalSquare = 25
    let dice = Dice(sides: 6, generator: LinearCongruentialGenerator())
    var square = 0
    var board: [Int]
    init() {
        board = Array(repeating: 0, count: finalSquare + 1)
        board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
        board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
    }
    weak var delegate: DiceGameDelegate?
    func play() {
        square = 0
        delegate?.gameDidStart(self)
        gameLoop: while square != finalSquare {
            let diceRoll = dice.roll()
            delegate?.game(self, didStartNewTurnWithDiceRoll: diceRoll)
            switch square + diceRoll {
            case finalSquare:
                break gameLoop
            case let newSquare where newSquare > finalSquare:
                continue gameLoop
            default:
                square += diceRoll
                square += board[square]
            }
        }
        delegate?.gameDidEnd(self)
    }
}

• 궁금한 점 : 예를 들어서 tableviewCell 이 tableviewController 에 protocol 을 이용해서 위임을 해버릴 수도 있고, 아니면 그냥 핸들러 변수를 하나 두고 셀에 넘겨주기도 하는데? 이 두방식을 어떻게 구분해서 사용하는지?? 그냥 스타일 차이인지??? 아니면 또 프로토콜 없이 RxSwift 를 사용하기도 하는데 속도 차이가 어떻게 될까...

class DiceGameTracker: DiceGameDelegate {
    var numberOfTurns = 0
    func gameDidStart(_ game: DiceGame) {
        numberOfTurns = 0
        if game is SnakesAndLadders {
            print("Started a new game of Snakes and Ladders")
        }
        print("The game is using a \(game.dice.sides)-sided dice")
    }
    func game(_ game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int) {
        numberOfTurns += 1
        print("Rolled a \(diceRoll)")
    }
    func gameDidEnd(_ game: DiceGame) {
        print("The game lasted for \(numberOfTurns) turns")
    }
}

let tracker = DiceGameTracker()
let game = SnakesAndLadders()
game.delegate = tracker
game.play()

8. extension 으로 protocol 준수

• 소스 코드 상으로 접근이 불가능한 기존 타입에 대해서도 extension 으로 프로토콜을 준수하게 할 수 있다.
• 소스 코드 상으로 접근이 가능해도 가독성을 위해서 extension 으로 분리하기도 함.
• 계산 프로퍼티, 메서드, 서브스크립트를 extension 안에서 정의할 수 있으므로 extension 으로 protocol 채택 가능.
• 기존 인스턴스 생성 후에 프로토콜을 채택해도 프로토콜을 따르게 됨.

protocol TextRepresentable {
    var textualDescription: String { get }
}

extension Dice: TextRepresentable {
    var textualDescription: String {
        return "A \(sides)-sided dice"
    }
}

let d12 = Dice(sides: 12, generator: LinearCongruentialGenerator())
print(d12.textualDescription) // Prints "A 12-sided dice"

조건적으로 프로토콜 준수 where

• 어떤 파라미터가 특정 프로토콜을 준수하는 특정 조건에서만 프로토콜을 준수하도록 할 수 있다.

// 배열의 요소가 TextRespresentable 을 따를 때 Array 도 TextRepresentable.
extension Array: TextRepresentable where Element: TextRepresentable {
    var textualDescription: String {
        let itemsAsText = self.map { $0.textualDescription }
        return "[" + itemsAsText.joined(separator: ", ") + "]"
    }
}
let myDice = [d6, d12]
print(myDice.textualDescription)  // Prints "[A 6-sided dice, A 12-sided dice]"

확장과 함께 프로토콜 채택 선언

• 이미 프로토콜을 따르지만, 프로토콜을 채택한다고 명시하지 않은 경우
• 빈 프로토콜로 명시 가능.

struct Hamster {
    var name: String
    var textualDescription: String {
        return "A hamster named \(name)"
    }
}
extension Hamster: TextRepresentable {}

9. 이미 구현된 프로토콜 채택

• Equatable, Hashable, Comparable 프로토콜 준수성을 자동으로 제공한다.

Equtable

• Equatable 의 == != 을 사용하기 위해 매번 연산자를 구현해야하는 것이 아니다.
  • Equatable 프로토콜을 준수하는 저장 프로퍼티만 있는 struct
  • Equatable 프로토콜을 준수하는 연관된 타입만 있는 열거형
  • 연관된 타입이 없는 열거형
    에는 자동 제공됨.

struct Vector3D: Equatable {
    var x = 0.0, y = 0.0, z = 0.0
}

let twoThreeFour = Vector3D(x: 2.0, y: 3.0, z: 4.0)
let anotherTwoThreeFour = Vector3D(x: 2.0, y: 3.0, z: 4.0)
if twoThreeFour == anotherTwoThreeFour {
    print("These two vectors are also equivalent.")
}

Hashable: Equatable

• 정수로 된 hash 값을 제공하는 타입.
• 기본 제공은 Equatable 과 조건이 같음.
• 그 값 자체로 유일하다라는걸 구현하는 hash(into:) 라는 함수를 매번 구현할 필요가 없음.
• 이 프로토콜을 준수하면 구조체를 배열이나 딕셔너리에 넣을 수 있음.

https://developer.apple.com/documentation/swift/hashable#2849490

Comparable

• < > >= <= 를 기본 제공.

enum SkillLevel: Comparable {
    case beginner
    case intermediate
    case expert(stars: Int)
}
var levels = [SkillLevel.intermediate, SkillLevel.beginner,
              SkillLevel.expert(stars: 5), SkillLevel.expert(stars: 3)]
for level in levels.sorted() {
    print(level)
}
// Prints "beginner"
// Prints "intermediate"
// Prints "expert(stars: 3)"
// Prints "expert(stars: 5)"

10. 프로토콜 타입의 콜렉션

• 배열, 딕셔너리 같은 컬렉션 타입에 저장되기 위해서 사용 가능.
• 반복과 프로토콜에 있는 프로퍼티, 메서드 사용 가능.

let things: [TextRepresentable] = [game, d12, simonTheHamster]

for thing in things {
    print(thing.textualDescription)
}
// A game of Snakes and Ladders with 25 squares
// A 12-sided dice
// A hamster named Simon

11. 프로토콜 상속

• 프로토콜도 상속할 수 있다.

protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
    // protocol definition goes here
}

protocol PrettyTextRepresentable: TextRepresentable {
    var prettyTextualDescription: String { get }
}

// 기존에 TextRepresentable 을 준수하고 있는 SnakesAndLadders 에서
// PrettyTextRepresentable 을 채택
extension SnakesAndLadders: PrettyTextRepresentable {
    var prettyTextualDescription: String {
        // 이미 TextRepresentable 이므로 textualDescription 프로퍼티에 접근 가능.
        var output = textualDescription + ":\n"
        for index in 1...finalSquare {
            switch board[index] {
            case let ladder where ladder > 0:
                output += "▲ "
            case let snake where snake < 0:
                output += "▼ "
            default:
                output += "○ "
            }
        }
        return output
    }
}

12. 클래스 전용 프로토콜

• 프로토콜 상속 목록에 AnyObject 를 추가하면 클래스에서만 구현할 수 있게 만들 수 있다.
• 프로토콜에 대해 참조 의미 체계가 있다고 생각되는 경우 (...) 사용한다.

protocol SomeClassOnlyProtocol: AnyObject, SomeInheritedProtocol {
    // class-only protocol definition goes here
}

13. 프로토콜 구성

• 여러 프로토콜을 단일 요구사항으로 결합할 수 있다. Equtable & Comparable
• 모든 프로토콜의 요구사항을 가진 임시 로컬 프로토콜로 정의된 것 처럼 동작한다.

protocol Named {
    var name: String { get }
}
protocol Aged {
    var age: Int { get }
}
struct Person: Named, Aged {
    var name: String
    var age: Int
}

// Person 대신 Named & Aged 를 사용.
// Person 이 아닌 두 프로토콜을 구현한 어떤 것이라도 인자가 될 수 있음.
func wishHappyBirthday(to celebrator: Named & Aged) {
    print("Happy birthday, \(celebrator.name), you're \(celebrator.age)!")
}
let birthdayPerson = Person(name: "Malcolm", age: 21)
wishHappyBirthday(to: birthdayPerson)
// Prints "Happy birthday, Malcolm, you're 21!"

14. 프로토콜을 준수하는지 검사.

• 타입 캐스팅 처럼 is as 사용.
• is : 프로토콜을 준수하면 true 아니면 false
• as? as! : 다운 캐스팅.

15. 옵셔널 요구사항

• 프로토콜을 준수하는 타입으로 구현될 필요가 없다.
• optional 수식어를 붙임.
• obj-c 에도 사용 가능한 코드를 작성할 수 있지만 @objc 붙여야함.
• 옵셔널 요구사항에서 프로퍼티나 메서드를 사용하면 자동적으로 optional type 으로 만들어 줌.
• 반환 타입 역시 optional.

// 실제 코드에선 optional 만 있는 코드는 별로 좋지 않음.
@objc protocol CounterDataSource {
    @objc optional func increment(forCount count: Int) -> Int
    @objc optional var fixedIncrement: Int { get }
}

class Counter {
    var count = 0
    var dataSource: CounterDataSource?
    func increment() { // count 증가.
        // increment 가 optional func 이기 때문에 ? 을 붙여 체이닝.
        // 실제 구현부에 있는 함수를 실행하는 것.
        if let amount = dataSource?.increment?(forCount: count) {
            count += amount
        } else if let amount = dataSource?.fixedIncrement {
            count += amount
        }
    }
}

// ContuerDataSource 를 실제로 구현하는 부분.
class ThreeSource: NSObject, CounterDataSource {
    let fixedIncrement = 3
}

var counter = Counter()
counter.dataSource = ThreeSource()
for _ in 1...4 { 
    counter.increment()
    print(counter.count) // 3 6 9 12
}

16. 프로토콜 확장

• 프로토콜을 확장해서 메서드, 초기화 구문, 서브스크립트, 계산된 프로퍼티 구현을 할 수 있다.
• 타입이 충족해야하는 제약조건을 덧붙이는 것도 가능함.

// 직접 어디선가 프로토콜을 준수하려 구현을 하지 않아도 프로토콜만 채택하면 사용 가능.
extension RandomNumberGenerator {
    func randomBool() -> Bool {
        return random() > 0.5
    }
}

기본 구현 제공

• 메서드나 계산된 프로퍼티에 기본 구현 제공.

extension PrettyTextRepresentable  {
    var prettyTextualDescription: String {
        return textualDescription
    }
}

프로토콜 확장에 제약사항 추가.

• 컬렉션 타입인데, 원소가 Equatable 을 따르는 것만 allEqual 함수 사용 가능.

extension Collection where Element: Equatable {
    func allEqual() -> Bool {
        for element in self {
            if element != self.first { // != 사용하려고 Equatable 조건 건 것.
                return false
            }
        }
        return true
    }
}

let equalNumbers = [100, 100, 100, 100, 100]
let differentNumbers = [100, 100, 200, 100, 200]

print(equalNumbers.allEqual()) // true
print(differentNumbers.allEqual()) // false

질문

프로토콜이란 무엇인지 설명하시오.

• 프로토콜은 Swift 에서 제공하는 규칙을 정의하는 문법이다. 다른 언어의 인터페이스와 비슷하다.
• 필요한 변수나 메서드 init 을 안에서 정의만 하고 구현은 하지 않고, 실제로 프로토콜을 채택하는 부분에서 구현하게 된다.
• 프로토콜에 있는 모든 함수를 구현하면 프로토콜을 준수한다고 말한다.
• 프로토콜을 통해 delegate 라는 다른 객체에 책임을 넘기는 패턴을 사용하는데,
  • 책임을 넘기려고 하는 객체가 protocol 타입의 weak optional 변수를 생성하고, 해당 프로토콜 안에 있는 프로퍼티나 메서드를 사용하면,
  • 실제로 그 변수나 프로퍼티가 구현되어 있는 구현부에서 위임 받아서 처리하게 된다.
  • tableviewcell 에서 viewcontroller 의 정보가 필요한 상황에 delegate 를 이용해서 viewcontroller 가 넘겨서 처리할 수 있도록 구현 했었다.

• 이미 구현된 Equatable 같은 프로토콜을 채택하거나 프로토콜끼리 상속을 할 수도 있다.

Hashable이 무엇이고, Equatable을 왜 상속해야 하는지 설명하시오.

• Hashable 은 해시가 가능한 타입인데,
• 해시가 가능하기 위해서는 정수 해시값을 제공해야 한다.
• 해시값은 고유한 값이므로 input 원소가 다르면 해시값도 다르게 나와야 한다.
• 그래서 hashValue 를 생성해주는 함수가 하나 필요하고,
• 구분이 가능하려면 두 원소가 같다에 대한 정의가 있어야 하므로 Equtable 을 상속해야 한다.
• dictionary, set 의 key 는 Hashable 을 준수해야 한다.

Hashable 을 따르는 것들

• String, Integer, Float, Boolean
• Optinal, Array, Range - 안의 원소 타입이 동일할 때.
• associate value 를 구현하지 않은 enum
• 저장 프로퍼티가 모두 Hashable 한 구조체
• case 가 모두 Hashable 한 enum
• +) Hashable 을 채택하여 hash(into: ) 를 직접 구현한 custom type
• +) 기본 제공 데이터 타입은 모두 Equatable

Codable에 대하여 설명하시오.

• Codable 은 Swift 의 형식을 어떤 다른 형식으로 인코딩, 디코딩이 가능하게 만들어주는 프로토콜이다.
• json 을 다룰 때 많이 쓰인다.
• 변환하고 싶은 struct, enum, class 에 Codable 프로토콜을 채택해주면 Encoder, Decoder 를 사용해서 json 으로 변환할 수 있다.
• type 이 정확하게 지정된 변수만 축약이 가능하고, 중첩된 타입이나 Any 타입에서는 사용하기 어렵다.
• Encodable, Decodable 을 따로 채택해줄 수도 있다.
• enum CodingKeys 를 사용해서 서버의 변수 네이밍을 Swift 에 알맞게 바꿀 수도 있다.

AnyObject에 대해 설명하시오.

• 어떤 클래스의 인스턴스도 받을 수 있는 타입이다.
• 이걸 사용하면 클래스 인스턴스를 쓸 때 타입 캐스팅이 필요해서 특별한 케이스가 아니면 안 쓰는 것이 좋다.

Delegate 패턴을 활용하는 경우를 예를 들어 설명하시오.

Delegates와 Notification 방식의 차이점에 대해 설명하시오.

• 델리게이트는 위임 방식이다.

  • 어떤 이벤트가 발생했을 때 다른 클래스에서 해당 이벤트를 처리할 수 있도록 책임을 넘긴다.

• 노티피케이션은

  • 이벤트가 발생하는 것을 관찰하고 있다가,
  • 해당 이벤트가 발생하면 처리하게 된다.

차이점은,

• 델리게이트는 프로토콜을 이용해서 하기 때문에 엄격한 규칙을 지켜야한다.

• 프로토콜을 구현한 하나의 VC 안에서 보통 처리가 된다.

• delegate 에서 이벤트를 발생시키면, 이벤트가 발생했을 때 직접적으로 delegate 내의 함수를 호출해서 처리를 하기 때문에 로직의 흐름을 따라가기 쉽다.

• 노티피케이션은 이벤트를 post 로 발생시키고 observer 로 그 이벤트를 잡기 때문에 쉽게 구현이 가능하지만,

• 어떤 곳에서 발생해서 함수가 실행된건지에 대한 추적이 쉽지 않을 수 있습니다.

Protocol Oriented Programming과 Object Oriented Programming의 차이점을 설명하시오.

• 둘 다 다형성을 구현하기 위한 방법이다.

• 프로토콜 지향 프로그래밍

  • 프로토콜을 중심으로 해서 합성을 통한 수평적 구조 확장을 기반으로 한다.
  • 어떤 속성 을 가지고 있다라는 has-A 의미 구조를 표현할 수 있음.
  • value type 에도 적용이 가능하다.
  • 다중 상속이 가능함.

• 객체 지향 프로그래밍

  • 상속을 중심으로 한 수직 구조 확장을 기반으로 한다.
  • 이것은 이것이다 라는 is-A 의미 구조를 표현하기 적합.
  • 부모의 모든 것을 상속받기 때문에, 필요 없는 메서드나 변수도 상속될 수 있다.
  • 상속을 위해 value type 대신 reference type 으로 모든 것을 구현해야 한다.
  • 다중 상속이 안됨.

• 그래서 헤드퍼스트 디자인 패턴 첫 대목의 Flyable Quackable 이 자바에서 안 좋은 예시라고 해서 Swift... 가능하잖아..? 라고 생각했던 것이었다. 프로토콜 기반이니까!

• weak self 의 경우 클래스 인스턴스와 클래스 인스턴스 혹은 클로저와 클래스 인스턴스가 서로를 참조할 때 사용하고,
• unowned self 의 경우는 기본 개념은 같은데 참조하는 객체가 메모리 상에 존재한다고 확신할 수 있을 때 사용한다. 그래서 nil 인지 꼭 확인을 거쳐야함.

참고
https://bbiguduk.gitbook.io/swift/language-guide-1/protocols
https://velog.io/@hayeon/Hashable이-무엇이고-Equatable을-왜-상속해야-하는지-설명하시오