지금까지 봤던 다양한 Publisher들에서 알 수 있듯, Combine은 스트림에서 에러 타입을 꼭 정의해주어야 한다.

struct AnyPublisher<Output, Failure> where Failure : Error

Publisher에서 Operator, Subscriber로 흘러가는 동안 에러는 언제 어디서든 발생할 수 있다. 따라서 Combine을 효과적이고 안전하게 사용하기 위해서 에러를 적절하게 처리하는 것은 필수적이다! (사실 Combine뿐 아니라 모든 reactive programming에 다 해당되는 일,,)

Combine에서의 에러 핸들링 방법을 알아보자!✨

Never

본격적인 에러 핸들링 방법을 공부하기 전, Never 에 대해 잠깐 짚고 넘어가보자.

Failure 타입이 Never 인 Publisher는 절대 실패하지 않는다.

따라서 Publisher가 값을 소비하는 데에만 집중할 수 있다.

절대 실패하지 않는 Publisher를 위한 메소드

Combine에서는 절대 실패하지 않을 때만 사용할 수 있는 메소드들이 있다.

sink(receiveValue:)

func sink(receiveValue: @escaping ((Self.Output) -> Void)) -> AnyCancellable

let integers = (0...3)
integers.publisher
    .sink { print("Received \($0)") }

// Prints:
//  Received 0
//  Received 1
//  Received 2
//  Received 3

이 메소드는 subscriber를 생성하고, subscriber를 리턴하기 전에 바로 값을 무한대로 요청한다.

리턴되는 값은 유지되어야 하고, 그렇지 않으면 스트림이 취소된다.

assign(to:on:)

func assign<Root>(
    to keyPath: ReferenceWritableKeyPath<Root, Self.Output>,
    on object: Root
) -> AnyCancellable

publisher로부터 받은 값을 object의 프로퍼티에 할당해주는 메소드이다.

이전 스터디 주차에서 공부했었던 메소드라 자세한 설명은 생략!!

setFailureType

func setFailureType<E>(to failureType: E.Type) -> Publishers.SetFailureType<Self, E> where E : Error

실패하지 않는 publisher를 실패할 수 있는 publisher로 변환해야 하는 경우가 있을 것이다.

setFailureType operator를 사용하면 upstream publisher의 failure type을 바꿀 수 있다.

대신 upstream publisher의 failure type은 Never 여야 한다!

(실패할 수 있는 upstream의 에러 타입을 바꾸고 싶다면 mapError(_:) 를 사용하자)

let pub1 = [0, 1, 2, 3, 4, 5].publisher
let pub2 = CurrentValueSubject<Int, Error>(0)
let cancellable = pub1
    .setFailureType(to: Error.self)
    .combineLatest(pub2)
    .sink(
        receiveCompletion: { print ("completed: \($0)") },
        receiveValue: { print ("value: \($0)")}
     )

// Prints: "value: (5, 0)".

combineLatest 는 두 publisher의 Failure 타입이 같아야 하기 때문에, 위 예시에서는 setFailureType 으로 에러 타입을 맞춰주었다.

또한 setFailureType 은 타입에만 영향을 미치기 때문에 실제 에러는 발생하지 않는다.

assertNoFailure

func assertNoFailure(
    _ prefix: String = "",
    file: StaticString = #file,
    line: UInt = #line
) -> Publishers.AssertNoFailure<Self>

upstream publisher가 실패하면 fatal error를 일으키고, 아니면 받은 input 값을 모두 다시 publish하는 메소드

• prefix : fatal error 메시지 앞에 적을 string

• file : 에러 메시지에서 사용할 파일명

• line : 에러 메시지에서 사용할 라인 넘버

• 테스트 중 내부 무결성을 확인하고 싶을 때 사용

  → publisher가 실패로 종료될 수 없음을 확인할 때 유용!

• 개발, 테스트뿐 아니라 배포 버전에서도 fatal error를 일으키니 주의!!

public enum SubjectError: Error {
    case genericSubjectError
}

let subject = CurrentValueSubject<String, Error>("initial value")
subject
    .assertNoFailure()
    .sink(receiveCompletion: { print ("completion: \($0)") },
          receiveValue: { print ("value: \($0).") }
    )

subject.send("second value")
subject.send(completion: Subscribers.Completion<Error>.failure(SubjectError.genericSubjectError))

// Prints:
//  value: initial value.
//  value: second value.
//  The process then terminates in the debugger as the assertNoFailure operator catches the genericSubjectError.

subject 가 세 번째로 genericSubjectError 라는 에러를 보냈고, fatal exception이 발생해서 프로세스가 중단됐다.

try~ 친구들

Combine 은 에러를 발생시킬 수 있는 operator 와 그렇지 않은 operator 사이에 구분을 제공한다.

이 operator들은 publisher의 Failure 를 Swift의 Error 타입으로 바꾼다.

• map / tryMap
• scan / tryScan
• filter / tryFilter
• compactMap / tryCompactMap
• removeDuplicates / tryRemoveDuplicates
• reduce / tryReduce
• drop / tryDrop
• …

그외 너무 많다.. 그때그때 try operator가 있는지 찾아보면서 개발하자

Mapping errors

map 은 에러를 던질 수 없는 non-throwing 메소드이다. 에러를 던지고 싶을 때는 tryMap 을 사용하자.

tryMap

func tryMap<T>(_ transform: @escaping (Self.Output) throws -> T) -> Publishers.TryMap<Self, T>

struct ParseError: Error {}
func romanNumeral(from:Int) throws -> String {
    let romanNumeralDict: [Int : String] =
        [1:"I", 2:"II", 3:"III", 4:"IV", 5:"V"]
    guard let numeral = romanNumeralDict[from] else {
        throw ParseError()
    }
    return numeral
}
let numbers = [5, 4, 3, 2, 1, 0]
cancellable = numbers.publisher
    .tryMap { try romanNumeral(from: $0) }
    .sink(
        receiveCompletion: { print ("completion: \($0)") },
        receiveValue: { print ("\($0)", terminator: " ") }
     )

// Prints: "V IV III II I completion: failure(ParseError())"

mapError

func mapError<E>(_ transform: @escaping (Self.Failure) -> E) -> Publishers.MapError<Self, E> where E : Error

struct DivisionByZeroError: Error {}
struct MyGenericError: Error { var wrappedError: Error }

func myDivide(_ dividend: Double, _ divisor: Double) throws -> Double {
       guard divisor != 0 else { throw DivisionByZeroError() }
       return dividend / divisor
   }

let divisors: [Double] = [5, 4, 3, 2, 1, 0]
divisors.publisher
    .tryMap { try myDivide(1, $0) }
    .mapError { MyGenericError(wrappedError: $0) }
    .sink(
        receiveCompletion: { print ("completion: \($0)") ,
        receiveValue: { print ("value: \($0)", terminator: " ") }
     )

// Prints: "0.2 0.25 0.3333333333333333 0.5 1.0 completion: failure(MyGenericError(wrappedError: DivisionByZeroError()))"

Catching and retrying

replaceError

func replaceError(with output: Self.Output) -> Publishers.ReplaceError<Self>

스트림에서 받은 에러를 특정한 값으로 대체(replace)하는 operator

struct MyError: Error {}
let fail = Fail<String, MyError>(error: MyError())
cancellable = fail
    .replaceError(with: "(replacement element)")
    .sink(
        receiveCompletion: { print ("\($0)") },
        receiveValue: { print ("\($0)", terminator: " ") }
    )

// Prints: "(replacement element) finished".

에러를 다시 감싸고 downstream subscriber로 받은 값을 다시 넘겨주고 싶을 때는 catch(_:) 사용

catch

func `catch`<P>(_ handler: @escaping (Self.Failure) -> P) -> Publishers.Catch<Self, P> where P : Publisher, Self.Output == P.Output

upstream publisher로부터 받은 에러를 다른 publisher로 교체하는 메소드

catch vs tryCatch

catch vs replaceError

Publishers.Catch가 상위 Publisher가 에러를 낼 때 다른 Publisher로 교체하는 동작을 제공한다면, Publishers.ReplaceError는 상위 Publisher가 에러를 낼 때 특정 요소로 교체하는 동작을 제공한다.

retry

func retry(_ retries: Int) -> Publishers.Retry<Self>

upstream publisher를 이용해서 인자로 전달한 값까지 failed subscription을 다시 만든다.

• retries : 재시도할 횟수
• publisher 반환

struct WebSiteData: Codable {
    var rawHTML: String
}

let myURL = URL(string: "https://www.example.com")

cancellable = URLSession.shared.dataTaskPublisher(for: myURL!)
    .retry(3)
    .map({ (page) -> WebSiteData in
        return WebSiteData(rawHTML: String(decoding: page.data, as: UTF8.self))
    })
    .catch { error in
        return Just(WebSiteData(rawHTML: "<HTML>Unable to load page - timed out.</HTML>"))
}
.sink(receiveCompletion: { print ("completion: \($0)") },
      receiveValue: { print ("value: \($0)") }
 )

// Prints: The HTML content from the remote URL upon a successful connection,
//         or returns "<HTML>Unable to load page - timed out.</HTML>" if the number of retries exceeds the specified value.

prepend add (something) to the beginning of something else.

prepend(Output)

func prepend(_ elements: Self.Output...) -> Publishers.Concatenate<Publishers.Sequence<[Self.Output], Self.Failure>, Self>

publisher의 output 앞에 특정한 값을 붙이는 operator

• elements: publisher의 항목 전에 publish될 항목
  • 항목의 개수는 제한 없음!

let dataElements = (0...10)
cancellable = dataElements.publisher
    .prepend(0, 1, 255)
    .sink { print("\($0)", terminator: " ") }

// Prints: "0 1 255 0 1 2 3 4 5 6 7 8 9 10"

• 0, 1, 255 가 먼저 publish 되고 dataElements 의 항목들이 publish된다.

let publisher = [3, 4].publisher

publisher
  .prepend(1, 2) 
  .prepend(-1, 0)
  .sink(receiveValue: { print($0) })

/*
 -1
 0
 1
 2
 3
 4
*/

마지막에 연결된 prepend 가 가장 앞에 온다.

→ prepend(1, 2) 를 실행해서 1, 2가 붙어서 새로 publish 되고, 그 다음 prepend(-1, 0) 가 실행되어서 그 앞에 또 -1, 0이 붙어서 다시 publish 되니까?!

Publishers.Concatenate

struct Concatenate<Prefix, Suffix> where Prefix : Publisher, Suffix : Publisher, Prefix.Failure == Suffix.Failure, Prefix.Output == Suffix.Output

한 publisher의 모든 값을 다른 publisher 전에 방출하는 publisher

• prefix: suffix 가 값을 다시 방출하기 전에 모든 값을 다시 publish
• suffix: prefix가 종료된 후에 다시 값을 publish 하는 publisher

prepend(Sequence)

파라미터로 sequence를 받을 수도 있다.

잠깐,,

• Sequence가 뭐지?

  

배열이나 Range 등을 publisher로 변환하면 `Publishers.Sequence` 타입이 된다.

Publishers.Sequence는 여러 항목을 연속으로 publish하는 publisher이다.

![](https://velog.velcdn.com/images/240-coding/post/996f9bf7-a80c-41d1-96ca-b1f51ec04b57/image.png)


이 Sequence는 생성할 때 `Elements` 를 파라미터로 받는데, 이 친구는 `Sequence` 라는 프로토콜을 준수하는 타입이어야 한다.

Swift의 Array, Set, Dictionary 등은 `Collection` 프로토콜을 준수하고 있는데, `Collection` 은 `Sequence` 를 준수하고 있다.


![](https://velog.velcdn.com/images/240-coding/post/025a8d4b-db63-4018-b69c-732a22d4c161/image.png)

![](https://velog.velcdn.com/images/240-coding/post/185ab81c-3ef7-4891-b7b6-9b986ce7540e/image.png)

그래서 Array 같은 Collection 타입들을 publisher로 변환하면 Publishers.Sequence 라는 타입이 되었던 것!

// 1
let publisher = [5, 6, 7].publisher

// 2
publisher
  .prepend([3, 4])
  .prepend(Set(1...2))
    .prepend(stride(from: 6, to: 11, by: 2))
  .sink(receiveValue: { print($0) })
  .store(in: &subscriptions)

/*
 6
 8
 10
 1
 2
 3
 4
 5
 6
 7
*/

• Set 은 순서를 보장하지 않기 때문에 위처럼 1, 2 가 아닌 2, 1 처럼 출력될 수 있다.
• stride 처럼 다양한 Sequence 타입을 전달할 수 있다.

prepend(Publisher)

👀 combining operator라면서 ,, 단순한 값이 아니라 다른 publisher의 값도 붙일 수는 없나?

func prepend<P>(_ publisher: P) -> Publishers.Concatenate<P, Self> where P : Publisher, Self.Failure == P.Failure, Self.Output == P.Output

publisher의 output 앞에 매개변수로 받은 publisher가 방출한 항목을 붙이는 operator

• 어떤 publisher의 항목을 다른 publisher의 항목 앞에 붙이고 싶을 때 사용한다.

let prefixValues = [0, 1, 255]
let dataElements = (0...10)
cancellable = dataElements.publisher
    .prepend(prefixValues.publisher)
    .sink { print("\($0)", terminator: " ") }

// Prints: "0 1 255 0 1 2 3 4 5 6 7 8 9 10"

dataLements 가 값을 publish 하기 전에 prefixValues 가 값을 publish 한다.

// 1
let publisher1 = [3, 4].publisher
let publisher2 = PassthroughSubject<Int, Never>()

// 2
publisher1
  .prepend(publisher2)
  .sink(receiveValue: { print($0) })
  .store(in: &subscriptions)

// 3
publisher2.send(1)
publisher2.send(2)

/*
1
2
*/

먼저 진행된 publisher가 반드시 완료된 후에 다음 publisher가 값을 방출할 수 있다.

publisher2.send(completion: .finished)

publisher2 를 종료시키면 publisher1 도 값을 방출할 수 있다.

1
2
3
4

Appending

prepend와 비슷하다. 대신 publisher의 뒤에 값을 추가해줌!

append(Output…)

func append(_ elements: Self.Output...) -> Publishers.Concatenate<Self, Publishers.Sequence<[Self.Output], Self.Failure>>

publisher의 output 뒤에 특정한 값들을 추가하는 operator

let dataElements = (0...10)
cancellable = dataElements.publisher
    .append(0, 1, 255)
    .sink { print("\($0)", terminator: " ") }

// Prints: "0 1 2 3 4 5 6 7 8 9 10 0 1 255"

dataElements 의 모든 값들을 다시 publish 한 다음에 파라미터로 받은 값들을 publish 한다.

prepend와 차이점

append와 prepend의 가장 큰 차이점은 원래 publisher가 .finished 로 종료된 후에 작동한다는 것이다.

append()의 리턴 타입이 Publishers.Concatenate<Self, Publishers.Sequence<[Self.Output], Self.Failure>> 었고, Concatenate의 suffix는 preffix가 종료된 후에 다시 publish 된다고 했기 때문

// 1
let publisher = PassthroughSubject<Int, Never>()

publisher
    .append(3, 4)
    .append(5)
    .sink(receiveValue: { print($0) })

// 2
publisher.send(1)
publisher.send(2)

/*
1
2
*/

publisher 가 종료되지 않았기 때문에 append() 가 아무런 영향을 주지 않는다.

publisher.send(completion: .finished)

publisher를 종료시키면 원하는 결과를 얻을 수 있다.

1
2
3
4
5

Publishers.Concatenate<Prefix, Suffix> 는 항상 앞에 애가 finish 되어야 뒤에 애의 값을 republish 할 수 있다는 걸 기억하자!!

append(Sequence)

Sequence를 파라미터로 받는 append operator

// 1
let publisher  = [1, 2, 3].publisher

publisher
    .append([4, 5])    //  2
    .append(Set([6, 7]))    // 3
    .append(stride(from: 8, to: 11, by: 2))    // 4
    .sink(receiveValue: { print($0) })
    .store(in: & subscriptions)

/*
1
2
3
4
5
7    // 순서가 바뀔 수 있음
6    // 순서가 바뀔 수 있음
8
10
*/

prepend와 마찬가지로 다양한 종류의 Sequence를 append 할 수 있다.

append(Publisher)

Publisher를 파라미터로 받는 append operator

 // 1
 let publisher1 = [1, 2].publisher
 let publisher2 = [3, 4].publisher

 // 2
 publisher1
     .append(publisher2)
     .sink(receiveValue: { print($0) })

/*
1
2
3
4
*/

고급 Combining Operator

switchToLatest()

가장 최신의 publisher가 값을 방출하면 기존 publisher의 구독을 취소하고 최신 publisher로 구독을 전환(switching)하는 operator

// 1
let publisher1 = PassthroughSubject<Int, Never>()
let publisher2 = PassthroughSubject<Int, Never>()
let publisher3 = PassthroughSubject<Int, Never>()

// 2
let publishers = PassthroughSubject<PassthroughSubject<Int, Never>, Never>()

// 3
publishers
    .switchToLatest()
    .sink(receiveCompletion: { _ in print("Completed!") },
        receiveValue: { print($0) })
    .store(in: &subscriptions)

// 4
publishers.send(publisher1)
publisher1.send(1)
publisher1.send(2)

// 5
publishers.send(publisher2)
publisher1.send(3)
publisher2.send(4)
publisher2.send(5)

// 6
publishers.send(publisher3)
publisher2.send(6)
publisher3.send(7)
publisher3.send(8)
publisher3.send(9)

// 7
publisher3.send(completion: .finished)
publishers.send(completion: .finished)

1. 3개의 PassthroughSubjects 를 만듦

2. PassthroughSubjects 를 받는 PassthroughSubjects 를 만듦

3. publishers 에 switchToLatest() 적용

4. publisher1 을 publishers 로 보내고 1, 2 값을 보냄

   → 현재 publishers 는 publisher1 구독!

5. publishers 에 publisher2 를 보냄

   → publishers 가 publisher2 를 구독해서 publisher1 의 값은 무시됨

6. publishers 에 publisher3 을 보냄

   → publishers 가 publisher3 을 구독해서 publisher2 의 값은 무시됨

7. publisher3 과 publishers 을 종료해서 활성화된 모든 구독을 완료함

 1
 2
 4
 5
 7
 8
 9
 completed!

Publishers.SwitchToLatest

struct SwitchToLatest<P, Upstream> where P : Publisher, P == Upstream.Output, Upstream : Publisher, P.Failure == Upstream.Failure

🤔 위 예시에서 publishers 의 Output 타입은 PassthroughSubject 인데.. 왜 Int 값이 출력되지?

⇒ switchToLatest()는 publisher들을 납작하게 (flatten) 만든 publisher를 리턴하기 때문이다!

• switchToLatest()를 적용할 publisher는 publisher를 방출해야 한다.

• 여러 publisher들이 값을 방출하지만, downstream subscriber들에게는 하나의 publisher로부터 연속적인 데이터 스트림을 구독하는 것처럼 보인다!

• upstream publisher로부터 새 publisher를 받으면 이전 구독은 취소된다.

• 앞에 있는 publisher가 불필요한 작업을 하는 것을 막을 때 사용할 수 있다.

  예: 자주 업데이트 되는 UI publisher로부터 네트워크 요청을 하는 publisher를 만드는 경우

     let url = URL(string: "https://source.unsplash.com/random")!
  
     // 1
     func getImage() -> AnyPublisher<UIImage?, Never> {
         return URLSession.shared
             .dataTaskPublisher(for: url)
             .map { data, _ in UIImage(data: data) }
             .print("image")
             .replaceError(with: nil)
             .eraseToAnyPublisher()
     }
  
     // 2
     let taps = PassthroughSubject<Void, Never>()
  
     taps
         .map { _ in getImage() } // 3
         .switchToLatest() // 4
         .sink(receiveValue: { _ in })
         .store(in: &subscriptions)
  
     // 5
     taps.send()
  
     DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
         taps.send()
     }
     DispatchQueue.main.asyncAfter(deadline: .now() + 3.1) {
         taps.send()
     }

  1. 랜덤 이미지를 가져오는 API를 호출하는 메소드 getImage() 작성

  2. 사용자가 버튼을 터치하는 이벤트를 방출하는 PassthroughSubject 선언

  3. 버튼을 터치하면 getImage() 가 호출되고, switchToLatest()도 적용

  4. taps 에 이벤트를 3번 보냄

     image: receive subscription: (DataTaskPublisher)
     image: request unlimited
     image: receive value: (Optional(<UIImage:0x600000364120 anonymous {1080, 720}>))
     image: receive finished
     image: receive subscription: (DataTaskPublisher)
     image: request unlimited
     image: receive cancel
     image: receive subscription: (DataTaskPublisher)
     image: request unlimited
     image: receive value: (Optional(<UIImage:0x600000378d80 anonymous {1080, 1620}>))
     image: receive finished

     실제로는 2개의 이미지만 가져와진다. 두 번째 send 0.1초 뒤에 다음 send가 불려서 두 번째 구독은 취소되었기 때문!

merge(with:)

func merge(with other: Self) -> Publishers.MergeMany<Self>

같은 타입의 다른 publisher와 합쳐서 값들을 상호 교차해서 전달해주는 operator

• upstream publisher들이 이벤트를 방출하면 리턴되는 publisher가 이벤트를 방출한다.

• 최대 8개의 publisher들을 합칠 수 있다

  

 // 1
 let publisher1 = PassthroughSubject<Int, Never>()
 let publisher2 = PassthroughSubject<Int, Never>()

 // 2
 publisher1
     .merge(with: publisher2)
     .sink(receiveCompletion: { _ in print("Completed") },
               receiveValue: { print($0) })
     .store(in: &subscriptions)

 // 3
 publisher1.send(1)
 publisher1.send(2)

 publisher2.send(3)

 publisher1.send(4)

 publisher2.send(5)

 // 4
 publisher1.send(completion: .finished)
 publisher2.send(completion: .finished)

/*
1
2
3
4
5
Completed
*/

combineLatest

func combineLatest<P>(_ other: P) -> Publishers.CombineLatest<Self, P> where P : Publisher, Self.Failure == P.Failure

다른 publisher를 구독하고, publisher들로부터 마지막으로 받은 output의 튜플을 publish하는 operator

• 다른 타입의 publisher도 결합할 수 있다!

  단, Failure 타입은 같아야 함

• 각 upstream마다 버퍼 크기 1을 사용해서 가장 최근 값을 저장한다.

• 최대 4개의 publisher 결합 가능

  

let pub1 = PassthroughSubject<Int, Never>()
let pub2 = PassthroughSubject<Int, Never>()

cancellable = pub1
    .combineLatest(pub2)
    .sink { print("Result: \($0).") }

pub1.send(1)
pub1.send(2)
pub2.send(2)
pub1.send(3)
pub1.send(45)
pub2.send(22)

// Prints:
//    Result: (2, 2).    // pub1 latest = 2, pub2 latest = 2
//    Result: (3, 2).    // pub1 latest = 3, pub2 latest = 2
//    Result: (45, 2).   // pub1 latest = 45, pub2 latest = 2
//    Result: (45, 22).  // pub1 latest = 45, pub2 latest = 22

모든 upstream publisher들이 종료되면 이 publisher도 종료된다.

upstream publisher가 값을 publish하지 않으면 이 publisher도 절대 종료되지 않는다.

→ combineLatest로 결합된 모든 publisher들은 최소 한 번 이상 값을 방출해야 한다.

zip

func zip<P>(_ other: P) -> Publishers.Zip<Self, P> where P : Publisher, Self.Failure == P.Failure

다른 publisher와 결합하고, 그 값들의 쌍을 튜플 형태로 전달하는 operator

• 각 publisher들이 마지막으로 방출한 값을 튜플 형태로 downstream에 방출한다.

• 리턴되는 publisher는 모든 publisher가 이벤트를 방출할 때까지 기다린다. 그 후 가장 마지막으로 소비되지 않은 이벤트를 subscriber에게 넘겨준다.

  ⇒ 다시말해, 같은 인덱스 상에 있는 값들을 튜플 형태로 조합해서 방출한다. 지퍼를 잠그는 느낌,,

 let numbersPub = PassthroughSubject<Int, Never>()
 let lettersPub = PassthroughSubject<String, Never>()

 cancellable = numbersPub
     .zip(lettersPub)
     .sink { print("\($0)") }
 numbersPub.send(1)    // numbersPub: 1      lettersPub:        zip output: <none>
 numbersPub.send(2)    // numbersPub: 1,2    lettersPub:        zip output: <none>
 letters.send("A")     // numbers: 1,2       letters:"A"        zip output: <none>
 numbers.send(3)       // numbers: 1,2,3     letters:           zip output: (1,"A")
 letters.send("B")     // numbers: 1,2,3     letters: "B"       zip output: (2,"B")

 // Prints:
 //  (1, "A")
 //  (2, "B")

upstream publisher 중 하나라도 정상적으로 종료되거나 실패하면 zip 된 publisher도 똑같이 종료된다.

merge vs combineLatest vs zip

• 여러 Publisher로부터 가장 마지막 값 하나를 받고 싶을 때는 merge
• 여러 publisher들이 마지막으로 방출한 값들을 묶어서 받고 싶을 때는 combineLatest
• 여러 publisher들이 방출한 값을 쌍을 맞춰서 받고 싶을 때는 zip

Filtering Elements

filter(_:)

func filter(_ isIncluded: @escaping (Self.Output) -> Bool) -> Publishers.Filter<Self>

클로저에 맞는 항목만 다시 publish 하는 operator

• isIncluded: 한 항목을 파라미터로 받고 항목을 다시 publish 할지에 대한 Boolean 값을 리턴하는 클로저

let numbers: [Int] = [1, 2, 3, 4, 5]
cancellable = numbers.publisher
    .filter { $0 % 2 == 0 }
    .sink { print("\($0)", terminator: " ") }

// Prints: "2 4"

tryFilter(_:)

func tryFilter(_ isIncluded: @escaping (Self.Output) throws -> Bool) -> Publishers.TryFilter<Self>

isIncluded 클로저가 항목을 다시 publish 할지 여부를 리턴하거나 에러를 던짐.

클로저가 에러를 던지면 publisher는 에러와 함께 실패한다.

struct ZeroError: Error {}

let numbers: [Int] = [1, 2, 3, 4, 0, 5]
cancellable = numbers.publisher
    .tryFilter{
        if $0 == 0 {
            throw ZeroError()
        } else {
            return $0 % 2 == 0
        }
    }
    .sink(
        receiveCompletion: { print ("\($0)") },
        receiveValue: { print ("\($0)", terminator: " ") }
     )

// Prints: "2 4 failure(DivisionByZeroError())".

removeDuplicates(by:)

func removeDuplicates(by predicate: @escaping (Self.Output, Self.Output) -> Bool) -> Publishers.RemoveDuplicates<Self>

이전 항목과 다른 항목만 publish 하는 operator

• predicate : 두 항목이 같은지 비교하는 클로저
  • 필터링 하기 위함
  • 두 번째 항목이 첫 번째 항목과 같으면 true 를 반환함
• 중복된 항목을 publish 하는 게 아니라 consume 하는 publisher를 반환한다.

언제 쓰면 좋을까?

사용자가 연속으로 같은 문자를 입력했을 때, 중복된 문자를 무시하고 싶을 때 유용할 듯

• upstream publisher에서 중복되는 항목을 지우고 싶을 때 사용
  • 직전에 publish된 항목과 현재 publish된 항목을 비교함
• Equatable 을 구현하지 않은 타입들을 비교하거나 Equatable 을 구현한 것과 다르게 값을 비교하고 싶을 때 사용

struct Point {
    let x: Int
    let y: Int
}

let points = [Point(x: 0, y: 0), Point(x: 0, y: 1),
              Point(x: 1, y: 1), Point(x: 2, y: 1)]
cancellable = points.publisher
    .removeDuplicates { prev, current in
        // Considers points to be duplicate if the x coordinate
        // is equal, and ignores the y coordinate
        prev.x == current.x
    }
    .sink { print("\($0)", terminator: " ") }

// Prints: Point(x: 0, y: 0) Point(x: 1, y: 1) Point(x: 2, y: 1)

Publishers.RemoveDuplicates

struct RemoveDuplicates<Upstream> where Upstream : Publisher

이전 항목과 일치하지 않는 항목들만 publish하는 publisher

tryRemoveDuplicates(by:)

func tryRemoveDuplicates(by predicate: @escaping (Self.Output, Self.Output) throws -> Bool) -> Publishers.TryRemoveDuplicates<Self>

• predicate 클로저가 Boolean 값을 반환하거나 에러를 던짐.
  • 클로저가 에러를 던지면 publisher는 그 에러와 함께 종료함

struct BadValuesError: Error {}
let numbers = [0, 0, 0, 0, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
cancellable = numbers.publisher
    .tryRemoveDuplicates { first, second -> Bool in
        if (first == 4 && second == 4) {
            throw BadValuesError()
        }
        return first == second
    }
    .sink(
        receiveCompletion: { print ("\($0)") },
        receiveValue: { print ("\($0)", terminator: " ") }
     )

 // Prints: "0 1 2 3 4 failure(BadValuesError()"

Reducing Elements

ignoreOutput()

func ignoreOutput() -> Publishers.IgnoreOutput<Self>

모든 upstream 항목들을 무시하지만 upstream publisher의 completion 상태(finished or failed)는 전달해주는 operator

• 모든 upstream 항목들을 무시하는 publisher를 반환함
• publisher가 정상적으로 완료하거나 실패하는지 결정할 때 사용

struct NoZeroValuesAllowedError: Error {}
let numbers = [1, 2, 3, 4, 5, 0, 6, 7, 8, 9]
cancellable = numbers.publisher
    .tryFilter({ anInt in
        guard anInt != 0 else { throw NoZeroValuesAllowedError() }
        return anInt < 20
    })
    .ignoreOutput()
    .sink(receiveCompletion: {print("completion: \($0)")},
          receiveValue: {print("value \($0)")})

// Prints: "completion: failure(NoZeroValuesAllowedError())"

위 예시에서 ignoreOutput() operator는 1~5까지는 정상적으로 전달받지만 downstream으로 publish되지 않는다.

0 이 publish 되었을 때는 NoZeroValuesAllowedError 와 함께 stream이 종료된다.

Publishers.IgnoreOutput<Self>

이 Publisher의 Output은 Never 이다.

절대 항목을 방출하지 않기 때문!

Selecting Specific Elements

first()

func first() -> Publishers.First<Self>

스트림의 첫 번째 항목을 publish하고 종료하는 operator

• downstream이 하나 이상의 항목을 요청하면 first() operator가 바로 upstream으로부터 unlimited 를 요청함
• first() 가 값을 받기 전에 upstream이 종료되면 어떤 값도 방출하지 않고 종료된다.

let numbers = (-10...10)
cancellable = numbers.publisher
    .first()
    .sink { print("\($0)") }

// Print: "-10"

first(where:)

func first(where predicate: @escaping (Self.Output) -> Bool) -> Publishers.FirstWhere<Self>

클로저 안의 내용을 만족하는 스트림의 첫 번째 항목을 publish하고 종료하는 operator

• predicate : 한 항목을 파라미터로 받고, 그 항목을 publish 할지 여부를 리턴하는 클로저

• 첫 번째 항목을 publish 한 후에는 다른 항목들은 모두 무시하고 정상 종료한다.

  • “모두 무시”라는 표현 때문에 이후 값도 다 받긴 하지만 그냥 무시하는 건가 싶었는데 첫 번째 값을 찾으면 바로 종료되는 것 같다.

    ——— Example of: first(where:) ———
    numbers: receive subscription: (1...9)
    numbers: request unlimited
    numbers: receive value: (1)
    numbers: receive value: (2)
    numbers: receive cancel
    2
    Completed with: finished

• 아무 항목도 받지 않았다면 아무 것도 publish 하지 않고 종료한다.

let numbers = (-10...10)
cancellable = numbers.publisher
    .first { $0 > 0 }
    .sink { print("\($0)") }

// Prints: "1"

tryFirst(where:)

func tryFirst(where predicate: @escaping (Self.Output) throws -> Bool) -> Publishers.TryFirstWhere<Self>

predicate 클로저가 Boolean 값을 반환하거나 에러를 던질 수 있다. 클로저가 에러를 던지면 publisher는 실패한다.

let numberRange: ClosedRange<Int> = (-1...50)
numberRange.publisher
    .tryFirst {
        guard $0 < 99 else {throw RangeError()}
        return true
    }
    .sink(
        receiveCompletion: { print ("completion: \($0)", terminator: " ") },
        receiveValue: { print ("\($0)", terminator: " ") }
     )

// Prints: "-1 completion: finished"
// If instead the number range were ClosedRange<Int> = (100...200), the tryFirst operator would terminate publishing with a RangeError.

last()

func last() -> Publishers.Last<Self>

스트림이 종료된 후에 스트림의 마지막 항목을 publish 한다.

• upstream publisher의 마지막 항목을 방출하고 싶을 때 사용한다

let numbers = (-10...10)
cancellable = numbers.publisher
    .last()
    .sink { print("\($0)") }

// Prints: "10"

Publishers.Last

struct Last<Upstream> where Upstream : Publisher

스트림이 종료될 때까지 기다렸다가 마지막 항목을 publish하는 publisher

→ 그래서 upstream publisher는 반드시 언젠가 종료되는 publisher여야 한다!

last(where:)

func last(where predicate: @escaping (Self.Output) -> Bool) -> Publishers.LastWhere<Self>

upstream이 종료된 후에 클로저 내의 조건을 만족하는 스트림의 마지막 항목을 publish하는 operator

• predicate: 한 항목을 파라미터로 받고 publish 할지 여부를 반환하는 클로저

let numbers = (-10...10)
cancellable = numbers.publisher
    .last { $0 < 6 }
    .sink { print("\($0)") }

// Prints: "5"

tryLast(where:)

func tryLast(where predicate: @escaping (Self.Output) throws -> Bool) -> Publishers.TryLastWhere<Self>

• predicate 클로저가 Boolean 값을 리턴하거나 에러를 던진다.
• 클로저가 에러를 던지면 publisher도 실패한다.

struct RangeError: Error {}

let numbers = [-62, 1, 6, 10, 9, 22, 41, -1, 5]
cancellable = numbers.publisher
    .tryLast {
        guard 0 != 0  else {throw RangeError()}
        return true
    }
    .sink(
        receiveCompletion: { print ("completion: \($0)", terminator: " ") },
        receiveValue: { print ("\($0)", terminator: " ") }
    )
// Prints: "5 completion: finished"
// If instead the numbers array had contained a `0`, the `tryLast` operator would terminate publishing with a RangeError."

Applying Sequence Operations to Elements

drop(untilOutputFrom:)

func drop<P>(untilOutputFrom publisher: P) -> Publishers.DropUntilOutput<Self, P> where P : Publisher, Self.Failure == P.Failure

파라미터로 받은 publisher로부터 항목을 받기 전까지는 upstream publisher의 항목을 무시하는 operator

operator를 호출한 publisher를 A, 파라미터로 받은 publisher를 B라고 하면..

• B가 항목을 생성하기 전까지는 upstream publisher(A)의 항목을 drop 하는 publisher를 반환한다.
• A는 B에게 하나의 값을 요청하고, B가 값을 생성하기 전까지는 upstream publisher(A)의 모든 항목들을 무시(drop)한다.
• B가 항목을 생성하면 이 operator는 B의 구독을 취소하고 A의 이벤트가 지나가도록 허용한다.
• operator가 A로부터 구독을 받으면 downstream에서 upstream publisher로 backpressure request(?)을 통과한다.
  • Backpressure: subscriber가 항목을 받을 준비가 되어 있다는 신호를 보내서 흐름을 제어하는 것 (공식 문서)
  • Backpressure in Combine
    • subscriber가 받는 항목들을 제한하는 것
    • 데이터를 consume하는 속도보다 publish하는 속도가 더 빠를 때 메모리 이슈 등이 발생할 수 있기 때문
• B가 항목을 생성하기 전 upstream publisher가 이 요청에 대해 동작하면, operator는 upstream publisher로부터 받은 항목을 drop한다.

After this publisher receives a subscription from the upstream publisher, it passes through backpressure requests from downstream to the upstream publisher. If the upstream publisher acts on those requests before the other publisher produces an item, this publisher drops the elements it receives from the upstream publisher.

let upstream = PassthroughSubject<Int,Never>()
let second = PassthroughSubject<String,Never>()
cancellable = upstream
    .drop(untilOutputFrom: second)
    .sink { print("\($0)", terminator: " ") }

upstream.send(1)
upstream.send(2)
second.send("A")
upstream.send(3)
upstream.send(4)
// Prints "3 4"

Publishers.DropUntilOutput

struct DropUntilOutput<Upstream, Other> where Upstream : Publisher, Other : Publisher, Upstream.Failure == Other.Failure

두 번째 publisher의 항목을 받기 전까지는 upstream publisher의 항목을 무시하는 publisher

dropFirst()

func dropFirst(_ count: Int = 1) -> Publishers.Drop<Self>

특정 개수의 항목들을 drop 한 후에 항목들을 publish 하는 operator

• count 의 기본값은 1
• count 로 전달받은 개수만큼의 항목은 publish하지 않는 publisher를 리턴한다.

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
cancellable = numbers.publisher
    .dropFirst(5)
    .sink { print("\($0)", terminator: " ") }

// Prints: "6 7 8 9 10 "

drop(while:)

func drop(while predicate: @escaping (Self.Output) -> Bool) -> Publishers.DropWhile<Self>

클로저가 false를 리턴할 때까지 upstream publisher의 값을 무시하고, 나머지 항목들을 publish하는 operator

• predicate : publisher로부터 받은 항목을 drop 할지 여부를 반환하는 클로저

let numbers = [-62, -1, 0, 10, 0, 22, 41, -1, 5]
cancellable = numbers.publisher
    .drop { $0 <= 0 }
    .sink { print("\($0)") }

// Prints: "10 0, 22 41 -1 5"

한 번 클로저가 false를 반환하고 나면 그 이후 모든 값들을 publish한다.

tryDrop(while:)

func tryDrop(while predicate: @escaping (Self.Output) throws -> Bool) -> Publishers.TryDropWhile<Self>

• 클로저가 Boolean 값을 리턴하거나 에러를 던진다.

• 클로저가 에러를 던지면 publisher는 에러와 함께 실패한다.

  • 이때는 아무 값도 방출되지 않음!

    

- 에러를 던지기 전에 클로저가 `false` 를 반환하면 에러도 던지지 않고 무조건 publish 한다.

    → `filter` 는 조건에 만족하는 항목을 만난 후에도 계속 클로저의 조건을 확인하지만, `drop(while:)` 은 한 번 클로저의 조건을 만족하면 그 이후에는 조건을 다시 확인하지 않는다.

    ![](https://velog.velcdn.com/images/240-coding/post/846f0a7f-e278-4da7-bfce-6e39c34d7a69/image.png)

struct RangeError: Error {}
var numbers = [1, 2, 3, 4, 5, 6, -1, 7, 8, 9, 10]
let range: CountableClosedRange<Int> = (1...100)
cancellable = numbers.publisher
    .tryDrop {
        guard $0 != 0 else { throw RangeError() }
        return range.contains($0)
    }
    .sink(
        receiveCompletion: { print ("completion: \($0)") },
        receiveValue: { print ("value: \($0)") }
    )

// Prints: "-1 7 8 9 10 completion: finished"
// If instead numbers was [1, 2, 3, 4, 5, 6, 0, -1, 7, 8, 9, 10], tryDrop(while:) would fail with a RangeError.

prefix(_:)

func prefix(_ maxLength: Int) -> Publishers.Output<Self>

파라미터로 전달한 개수만큼의 항목을 publish한다.

⇒ upstream publisher가 방출할 수 있는 값의 개수를 제어

prefix라는 이름 그대로 먼저 항목을 publish 한 후에 완료한다. dropFirst와 반대되는 개념!

• maxLength : publish할 항목의 최대 개수
• downstream subscriber로 publish할 항목의 개수를 제한할 때 사용한다.
• 설정한 개수만큼 publish한 후에는 바로 종료된다.

let numbers = (0...10)
cancellable = numbers.publisher
    .prefix(2)
    .sink { print("\($0)", terminator: " ") }

// Prints: "0 1"

prefix(while:)

func prefix(while predicate: @escaping (Self.Output) -> Bool) -> Publishers.PrefixWhile<Self>

클로저의 조건을 만족하는 값을 방출할 때까지만 다시 publish하는 operator

• predicate : 하나의 항목을 파라미터로 받고 계속 publish 해야 하는지 여부를 반환하는 클로저
• upsteram publisher로부터 받은 항목이 조건을 만족하는 동안만 값을 방출할 때 사용한다.
• 클로저가 false 를 리턴하면 publisher는 종료된다.

let numbers = (0...10)
numbers.publisher
    .prefix { $0 < 5 }
    .sink { print("\($0)", terminator: " ") }

// Prints: "0 1 2 3 4"

tryPrefix(while:)

func tryPrefix(while predicate: @escaping (Self.Output) throws -> Bool) -> Publishers.TryPrefixWhile<Self>

• 클로저가 Boolean 값을 반환하거나 에러를 던진다.
  • 클로저가 에러를 던지면 publisher는 에러와 함께 실패한다.

struct OutOfRangeError: Error {}

let numbers = (0...10).reversed()
cancellable = numbers.publisher
    .tryPrefix {
        guard $0 != 0 else {throw OutOfRangeError()}
        return $0 <= numbers.max()!
    }
    .sink(
        receiveCompletion: { print ("completion: \($0)", terminator: " ") },
        receiveValue: { print ("\($0)", terminator: " ") }
    )

// Prints: "10 9 8 7 6 5 4 3 2 1 completion: failure(OutOfRangeError()) "

다른 값이나 시퀀스로 변형할 수 있는 operator

들어가기 전에

Operator는 Publisher다!

1주차 스터디에서 스터디원이 sink() 라는 메소드는 왜 있는 건가요?? 라고 던진 질문에 Publisher 안에 자체적으로 구현되어 있는 게 아닐까요?😅 라고만 답했었는데...

애초에 Publisher Operators 라는 메소드들이 공식적으로 정의가 되어 있었다!

받은 항목들을 가지고 downstream publisher나 subscriber를 만드는 메소드들을 Publisher Operators라고 한다.

Publisher Operators | Apple Developer Documentation

이 operator들은 publisher를 리턴한다.

이런 식으로..

• upstream value를 받는다 → 데이터를 조작한다 → 이 값을 downstream으로 보낸다

Collecting Values

collect()

func collect() -> Publishers.Collect<Self>

• 받은 항목들을 모아서 publisher가 종료될 때 하나의 배열로 방출함

• publisher가 에러를 방출하면 receiver에게 그대로 에러를 전달함

• publisher로부터 무한대로 항목을 받고, 받은 값들을 저장하기 위해 메모리를 무제한으로 사용함

  → 메모리 관리에 주의해야 함

let numbers = (0...10)
cancellable = numbers.publisher
    .collect()
    .sink { print("\($0)") }

// Prints: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"

특정 개수만큼 항목들을 묶어서 방출하고 싶으면 파라미터로 숫자를 전달한다.

func collect(_ count: Int) -> Publishers.CollectByCount<Self>

let numbers = (0...10)
cancellable = numbers.publisher
    .collect(5)
    .sink { print("\($0), terminator: " "") }

// Prints "[0, 1, 2, 3, 4] [5, 6, 7, 8, 9] [10] "

→ 파라미터는 최댓값이기 때문에 파라미터로 받은 숫자보다 더 적은 개수의 항목이 묶일 수도 있음

Publishers.Collect

struct Collect<Upstream> where Upstream : Publisher

Publishers.CollectByCount

struct CollectByCount<Upstream> where Upstream : Publisher

Mapping Values

map(_:)

func map<T>(_ transform: @escaping (Self.Output) -> T) -> Publishers.Map<Self, T>

publisher로부터 받은 값들을 변형하는 operator

let numbers = [5, 4, 3, 2, 1, 0]
let romanNumeralDict: [Int : String] =
   [1:"I", 2:"II", 3:"III", 4:"IV", 5:"V"]
cancellable = numbers.publisher
    .map { romanNumeralDict[$0] ?? "(unknown)" }
    .sink { print("\($0)", terminator: " ") }

// Prints: "V IV III II I (unknown)"

Publishers.Map

struct Map<Upstream, Output> where Upstream : Publisher

upstream publisher로부터 받은 항목들을 전달받은 클로저를 사용해서 변형하는 publisher

tryMap(_:)

func tryMap<T>(_ transform: @escaping (Self.Output) throws -> T) -> Publishers.TryMap<Self, T>

upstream publisher로부터 받은 항목들을 에러를 던지는 클로저를 이용해서 변형하는 operator

• transform : 한 항목을 파라미터로 받고, 새 항목을 리턴하는 클로저. 클로저가 에러를 던지면 publisher는 에러와 함께 실패한다.

struct ParseError: Error {}
func romanNumeral(from:Int) throws -> String {
    let romanNumeralDict: [Int : String] =
        [1:"I", 2:"II", 3:"III", 4:"IV", 5:"V"]
    guard let numeral = romanNumeralDict[from] else {
        throw ParseError()
    }
    return numeral
}
let numbers = [5, 4, 3, 2, 1, 0]
cancellable = numbers.publisher
    .tryMap { try romanNumeral(from: $0) }
    .sink(
        receiveCompletion: { print ("completion: \($0)") },
        receiveValue: { print ("\($0)", terminator: " ") }
     )

// Prints: "V IV III II I completion: failure(ParseError())"

에러 처리가 필요하면 tryMap(_:) 을, 아니면 map(_:) 을 사용하자

Publishers.TryMap

struct TryMap<Upstream, Output> where Upstream : Publisher

upstream publisher로부터 받은 항목들을 에러를 던지는 클로저를 이용해서 변형하는 pubilsher

Flattening Publishers

flatMap(maxPublishers:_:)

func flatMap<T, P>(
    maxPublishers: Subscribers.Demand = .unlimited,
    _ transform: @escaping (Self.Output) -> P
) -> Publishers.FlatMap<P, Self> where T == P.Output, P : Publisher, Self.Failure == P.Failure

Republishing Elements by Subscribing to New Publishers 새 publisher를 구독해서 항목을 새로 publish 하는 것

publisher로부터 받은 항목들을 새 publisher로 변형하는 operator

• maxPublishers : 동시에 존재하는 publisher subscription의 최댓값. 기본값은 unlimited
• transform : 항목을 파라미터로 받고, 같은 타입의 항목을 만드는 publisher를 반환하는 클로저

maxPublisher를 2로 설정했을 때 예시

• upstream publisher로부터 받은 값을 가지고 새 이벤트를 만들고 싶을 때 사용

• 클로저는 받은 값을 가지고 새 Publisher를 만든다

  • 이 Publisher는 하나 이상의 이벤트를 방출할 수 있다
  • 이 Publisher가 정상적으로 종료되어도 전체 스트림이 완료되지 않는다
  • 하지만 실패할 때는 전체 스트림도 같이 실패한다!

• flatMap은 각 output을 하나의 publisher로 변형하는데, 이 publisher들을 downstream으로 방출되는 publisher를 업데이트하기 위해 이 publisher들을 버퍼에 가지고 있는다.

  → 메모리 관리에 주의해야 한다!

public struct WeatherStation {
    public let stationID: String
}

var weatherPublisher = PassthroughSubject<WeatherStation, URLError>()

cancellable = weatherPublisher.flatMap { station -> URLSession.DataTaskPublisher in
    let url = URL(string:"https://weatherapi.example.com/stations/\(station.stationID)/observations/latest")!
    return URLSession.shared.dataTaskPublisher(for: url)
}
.sink(
    receiveCompletion: { completion in
        // Handle publisher completion (normal or error).
    },
    receiveValue: {
        // Process the received data.
    }
 )

weatherPublisher.send(WeatherStation(stationID: "KSFO")) // San Francisco, CA
weatherPublisher.send(WeatherStation(stationID: "EGLC")) // London, UK
weatherPublisher.send(WeatherStation(stationID: "ZBBB")) // Beijing, CN 

Publishers.FlatMap

struct FlatMap<NewPublisher, Upstream> where NewPublisher : Publisher, Upstream : Publisher, NewPublisher.Failure == Upstream.Failure

upstream publisher로부터 받은 항목을 새 publisher로 변형하는 publisher

🤯 map? flatMap?

[1, 2, 3].publisher.flatMap({ int in
  return (0..<int).publisher
  }).sink(receiveCompletion: { _ in }, receiveValue: { value in
    print("value: \(value)")
  })

/* Result:
value: 0
value: 0
value: 1
value: 0
value: 1
value: 2
*/

let tmp1 = [1, 2, 3].publisher.flatMap({ int in
  return (0..<int).publisher
  })

let tmp2 = [1, 2, 3].publisher.map { int in
    return (0..<int).publisher
}

/*
value: Sequence<Range<Int>, Never>(sequence: Range(0..<1))
value: Sequence<Range<Int>, Never>(sequence: Range(0..<2))
value: Sequence<Range<Int>, Never>(sequence: Range(0..<3))
*/

• Publishers.Map은 변형된 upstream publisher의 output을 output으로 가지는 publisher
• Publishers.FlatMap은 upstream publisher의 output을 요리조리 변형해서 새 publisher를 만드는 publisher
  • 그리고 애초에 flatMap은 publisher를 리턴한다.

그래서 map을 사용해서 publisher로 변형하면 output이 publisher인 publiser가 만들어지는 것!! (Publisher<NewPublisher, Error> 같은 느낌..)

하지만 flatMap을 사용하면 각 항목들을 변형한 하나의 publisher가 예쁘게 만들어진다.

Upstream Output 바꾸기

replaceNil(with:)

func replaceNil<T>(with output: T) -> Publishers.Map<Self, T> where Self.Output == T?

스트림에 있는 nil 항목을 특정 항목으로 교체하는 operator

let numbers: [Double?] = [1.0, 2.0, nil, 3.0]
numbers.publisher
    .replaceNil(with: 0.0)
    .sink { print("\($0)", terminator: " ") }

// Prints: "Optional(1.0) Optional(2.0) Optional(0.0) Optional(3.0)"

replaceEmpty(with:)

func replaceEmpty(with output: Self.Output) -> Publishers.ReplaceEmpty<Self>

빈 스트림을 전달된 항목으로 바꾸는 operator

• output : upstream publisher가 아무 값도 방출되지 않고 종료되면 방출되는 항목

let numbers: [Double] = []
cancellable = numbers.publisher
    .replaceEmpty(with: Double.nan)
    .sink { print("\($0)", terminator: " ") }

// Prints "(nan)".

Double.nan 을 방출하고 정상 종료됨

let otherNumbers: [Double] = [1.0, 2.0, 3.0]
cancellable2 = otherNumbers.publisher
    .replaceEmpty(with: Double.nan)
    .sink { print("\($0)", terminator: " ") }

// Prints: 1.0 2.0 3.0

방출되는 값이 있으면 replaceEmpty 로 전달한 값은 방출되지 않는다.

Publishers.ReplaceEmpty

struct ReplaceEmpty<Upstream> where Upstream : Publisher

Incrementally transforming output

scan(::)

func scan<T>(
    _ initialResult: T,
    _ nextPartialResult: @escaping (T, Self.Output) -> T
) -> Publishers.Scan<Self, T>

클로저한테 마지막으로 전달받은 값과 현재 항목을 가 직고 sptream publisher로부터 받은 항목들을 변형하는 operator

• initialResult : nextPartialResult 로부터 리턴받은 이전 결과
• nextPartialResult : 클로저로부터 리턴받은 이전 값과 upstream publisher로부터 방출받을 다음 항목을 인자로 받는 클로저

이전에 publish된 값들을 모아서 하나의 값으로 만들고 싶을 때 사용한다. → reduce() 랑 비슷한 느낌?

let range = (0...5)
cancellable = range.publisher
    .scan(0) { return $0 + $1 }
    .sink { print ("\($0)", terminator: " ") }
 // Prints: "0 1 3 6 10 15 ".

Publishers.Scan

struct Scan<Upstream, Output> where Upstream : Publisher

Combine?

• 비동기 이벤트를 처리하는 애플의 프레임워크.

• 시간이 지남에 따라 값을 처리하기 위한 선언형 API들을 제공한다.

• Publisher: 시간에 따라 변할 수 있는 값을 노출

• Subscriber: Publisher로부터 값을 받고 그에 대한 액션을 취함

• 여러 publisher들의 값들을 결합하고, 상호작용을 조절할 수 있음

Combine 사용의 장점

• 이벤트를 처리하는 코드를 중앙화함으로써 가독성, 유지보수
• 중첩 클로저, convention-based callbacks 등보다 사용하기 편함
  • ‘협약에-기초한 콜백 (convention-based callbacks)’ 은 이벤트를 ‘콜백 (callback) 함수’ 로 처리하려면 양쪽 사이에 서로 ‘협의해서 약속한 (convention)’ 정보가 있어야 함을 의미한다..고 한다.

Publisher

protocol Publisher<Output, Failure>

• 하나 이상의 Subscriber에게 값을 전달한다.

• Subscriber의 Input, Failure 타입과 Publisher의 Output, Failure 타입이 일치해야 함

• receive(_:) 메소드를 호출한 다음에 subscriber의 receive 메소드를 호출할 수 있음.

  • 얘네를 사용해서 subscriber와 커뮤니케이션(?) 할 수 있다.

    

- `receive` 메소드 종류는 3가지!

    → 위의 세 메소드들은 Subscriber 프로토콜 안에 있는 메소드들임. 

• 시간에 따라 값을 방출한다.
• 에러 상황을 감지하기 위해 에러도 함께 방출한다.
• 내가 방출할 값과 에러(만약 있으면)의 종류를 정의해야 한다.

Publisher는 프로토콜이기 때문에 원래는 직접 구현해야 한다. 하지만 Combine에서는 다양한 Publisher 타입(?)을 제공한다.

• Subject의 구체적인 하위클래스 사용하기 (ex: PassthroughSubject)

  send() 메소드 호출해서 실시간으로 값을 publish 할 수 있다

• CurrentValueSubject

  • subject의 기본값을 업데이트 할 때마다 값을 publish 할 때 사용

• 프로퍼티에 @Published 어노테이션 붙이기

  • 프로퍼티의 값이 바뀔 때마다 이벤트를 방출하는 퍼블리셔를 가지게 됨

Publishers..????

*Publisher..? Publishers..?? 넌 뭐냐?? 🤯 *

• Publisher 역할을 하는 타입을 모아둔 enum
• Publisher의 extension으로 정의된 Operator들은 Publishers 를 상속(??)하는 클래스나 구조체로 기능을 구현한다.
  • 예: contains(_:) Operator는 Publishers.Contains 인스턴스를 반환한다.

Publisher의 종류

• Just
  • 가장 기본적인 Publisher
  • 하나의 값만 방출하고, 절대 실패하지 않는다

["Pepperoni", "Mushrooms", "Onions", "Sausage", "Bacon", "Extra cheese", "Black olives", "Green peppers"].publisher

나는 값을 여러 번 방출하고 싶어!! → publisher로 손쉽게 변환할 수 있다.

여러 개의 값을 방출하고 종료함.

.publisher 라는 키워드를 붙여서 publisher를 만들 수 있다

예시 - NotificationCenter 사용

// create the order
let pizzaOrder = Order()
let pizzaOrderPublisher = NotificationCenter
  .default
  .publisher(for: .didUpdateOrderStatus, object: pizzaOrder)

• pizzaOrderPublisher: NotificationCenter가 pizzaOrder에 didUpdateOrderStatus 이라는 노티피케이션을 보낼 때마다 이벤트를 방출하는 Publisher

// once the user is ready to place the order
NotificationCenter
  .default
  .post(name: .didUpdateOrderStatus,
        object: pizzaOrderPublisher,
        userInfo: ["status": OrderStatus.processing])

• NotificationCenter에 데이터를 보내고 post → publisher가 값을 방출함
• 근데 아직 이 publisher를 구독한 subscriber가 없어서 아무 일도 일어나지 않는다.

❓ 궁금한 점.. notification center를 반드시 사용해야 하는가? 어떤 경우에서 사용하는 건가? 라고 생각했었는데 애플 공식문서에 있던 예시는 macOS를 개발하는 AppKit에서 사용하는 방법을 알려주는 예시였다. 나중에 Swift: NotificationCenter와 사용법 를 읽어봐도 좋을 듯!

Subscriber

protocol Subscriber<Input, Failure> : CustomCombineIdentifierConvertible

• Publisher로부터 요소의 스트림을 받는다.
  • 라이프사이클 이벤트에 따라..
• Publisher와 타입이 일치해야 한다는 거 유의
• Publisher의 subscribe(_:) 메소드 호출해서 subscriber와 publisher를 연결할 수 있다.

• publisher를 구독하고 얘네가 방출한 값을 받음
• 각 subscriber는 어떤 타입의 값과 에러를 받을 건지 정의해야 한다.

Publisher와 Subsciber 연결 과정

1. Publisher의 subscribe(_:) 메소드 호출

    func subscribe<S>(_ subscriber: S) where S : Subscriber, Self.Failure == S.Failure, Self.Output == S.Input

   Apple 왈,, receive(subscriber:) 대신 얘를 호출하라고 함. 이 함수 안에서 receive(subscriber:) 를 호출할 거임.

2. 그러면 publisher가 subscriber의 receive(subscription:) 메소드를 호출하게 됨

3. subscriber에게 Subscription 인스턴스를 전달해줌

   • Publisher에게 요소를 달라고 요구하는 역할
   • 아니면 구독을 취소할 수도 있음

4. subscriber가 처음으로 Demand를 생성함

5. publisher가 subscriber의 receive(_:) 메소드를 호출해서 새로 publish된 요소를 전달함.

6. publisher가 publish를 중단하면 receive(completion:) 메소드를 호출함

   • Subscriber.Completion 타입의 파라미터 사용
   • 퍼블리싱이 정상적으로 끝났는지 아니면 에러를 뱉었는지 나타내기 위함

     ❓ receive 메소드를 정리해보자

🤯 아니.. receive 메소드가 publisher꺼야 subcriber꺼야;; 겁나 헷갈리네

💫  Publisher

1️⃣ receive(subscriber:)

func receive<S>(subscriber: S) where S : Subscriber, Self.Failure == S.Failure, Self.Output == S.Input

publisher에게 subscriber를 붙이는 메소드

직접 이 메소드를 호출하지 않고 subscribe(_:) 를 호출하면 얘를 호출해준다.

💫 Subscriber

값을 받는 것 / 생애주기 이벤트를 받는 것으로 나뉨

1️⃣ receive(_:)

func receive(_ input: Self.Input) -> Subscribers.Demand

subscriber에게 publisher가 항목을 만들어냈음을 알려주는 메소드

• input : publish된 요소
• Subscribers.Demand : subscriber가 얼마나 많은 요소들을 더 받을 것으로 예상하는지를 나타내는 인스턴스

2️⃣ receive()

func receive() -> Subscribers.Demand

void 요소의 publisher가 다음 요청을 받을 준비가 되었음을 알려주는 메소드

이벤트가 발생했다는 것만 알려주고 싶을 때 Void input / output을 사용

3️⃣ receive(subscription:)

func receive(subscription: any Subscription)

subscriber에게 publisher를 성공적으로 구독했고, 항목을 요청할 수 있음을 알려주는 메소드

• subscription?

  publisher와 subscriber 사이의 연결을 나타냄. publisher에게 항목을 요청할 때 매개변수로 받은 subscription을 사용함.

4️⃣ receive(completion:)

func receive(completion: Subscribers.Completion<Self.Failure>)

subscriber에게 publisher의 퍼블리싱이 끝났음을 알려주는 메소드

• Subscriber.Completion : 퍼블리싱이 정상적으로 끝났는지 or 에러를 뱉었는지 알려줌

Combine의 주요 subscriber

Combine은 Publisher 타입에 있는 operator 형태의 subscriber를 제공한다.

1. sink
   • completion 시그널을 받고 새 항목을 받을 때 클로저를 실행
2. assign
   • 받은 값을 다른 프로퍼티나 publisher에게 할당

Subscribers

enum Subscribers

Publisher와 마찬가지로 subscriber 역할을 하는 타입들을 모아둔 네임스페이스가 있다.

Demand

• 요청한 항목의 개수
• subscription을 통해 subscriber → publisher에게 전달됨

max(_:)

• publisher에게 몇 번 더 값을 달라고 요청을 보낼 것인지
• 음수를 전달하면 fatal error가 발생함

unlimited

• publisher가 만들 수 있는 만큼 다 요청을 보낸다

none

• publisher로부터 어떤 값도 요청하지 않는다.

Completion

publisher가 정상적인 종료 or 에러 발생에 의해 더이상 값을 만들어내지 않음을 알려주는 신호

finished

• 정상적으로 종료됨

failure(Failure)

• 에러에 의해 publisher가 퍼블리싱을 중단함

Convenience Publishers

Just

struct Just<Output>

• 각각의 subscriber에게 output을 한 번 방출하고 종료되는 Publisher

• 반드시 값을 하나 생성하고, 에러를 생성하지 않는다.

  → Failure의 타입이 Never 로 정의되어 있기 때문

기존 Swift에서의 Never?

Never 는 코드에서 실행되면 안되는 부분을 명시적으로 나타냅니다.

Never 를 이용해서 코드를 볼 때 ‘아 이부분은 실행이 되면 안되는 부분이구나’ 라고 판단할 수 있을 것이다. 앱을 강제 종료 해야 한다거나, UIEvent 에 Error 를 써야 할 때 활용할 수 있을 것 같다. 고 한다..

Swift 에서 Never 란 무엇일까?

Never keyword in Swift: return type explained with code examples

Publisher가 에러를 뱉지 않으면 Never 를 사용함

• publisher의 체인을 시작할 때 사용할 수 있다고 한다.

Future

final class Future<Output, Failure> where Failure : Error

하나의 값을 만들고 결과를 보내는 (종료 or 실패) publisher

• 하나의 값을 비동기로 publish 해야 할 때 사용

  → escaping closure로 구현되어 있다

Future.Promise

typealias Promise = (Result<Output, Failure>) -> Void

• Future 안에서 호출되는 클로저의 typealias
• Result<Output, Failure> : Future가 publish한 값 or 에러

public init(_ attemptToFulfill: @escaping (@escaping (Result<Output, Failure>) -> Void) -> Void)

사실상 이렇게 정의되어 있는 것

func generateAsyncRandomNumberFromFuture() -> Future <Int, Never> {
    return Future() { promise in
        DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
            let number = Int.random(in: 1...10)
            promise(Result.success(number))
        }
    }
}

Future는 Swift Concurrency로 대체 가능하다고 하는데,, 나중에 알아보는 걸로~

Deferred

Defer: 미루다, 연기하다

struct Deferred<DeferredPublisher> where DeferredPublisher : Publisher

새로운 Subscriber의 Publisher를 만들기 위해 클로저를 실행하기 전 Subscription을 기다리는 Publisher

• init의 createPublisher 는 subscribe(_:) 가 호출될 때 실행된다. 이름 그대로 나중에 호출될 Publisher를 새로 만드는 클로저

createPublisher

let createPublisher: () -> DeferredPublisher

createPublisher 에 의해 리턴된 publisher는 subscription을 바로 받는다.

Empty

struct Empty<Output, Failure> where Failure : Error

아무 값도 publish 하지 않고, 즉시 종료될 수 있는 publisher

• Empty(completeImmediately: false) : 어떤 값도 보내지 않고, 결과(종료 or 실패)도 보내지 않는 “Never” publisher
• completeImmediately : Publisher가 바로 completion을 보낼지 여부
  • true면 subscriber에게 subscription을 보내고 바로 종료
  • false면 절대 완료되지 않음
• init(completeImmediately:outputType:failureType:)
  • empty publisher를 subscriber나 특정한 output과 failure 타입이 정해진 publisher와 연결할 때 사용하는 생성자

Fail

struct Fail<Output, Failure> where Failure : Error

특정한 에러와 함께 바로 종료되는 publisher

• init(outputType:failure:)
  • 특정한 output 타입을 요구하는 다른 subscriber나 publisher와 연결하고 싶을 때 사용하는 생성자

Record

struct Record<Output, Failure> where Failure : Error

여러 개의 input들과 하나의 completion을 기록하고, 나중에 subscriber에게 전달해주는 publisher

• Record Publisher를 생성할 때 output들을 함께 배열 형태로 매개변수로 전달한다.
• 기존에 있던 recording 을 가지고도 새로 생성 가능

Recording

Record가 기록한 결과를 보관해두는 역할을 하는 구조체

• 기록된 output들의 시퀀스
• Subscriber에게 보낼 output과 completion을 설정함
• receive(_:) , receive(completion:) 로 각각 새 output과 completion을 저장함
  • output은 completion이 추가된 후에는 생성 불가능
  • completion은 하나만 추가 가능

AnyPublisher

@frozen
struct AnyPublisher<Output, Failure> where Failure : Error

다른 publisher를 감싸서 타입을 지우는 publisher

언제 사용하지?

• 자세한 타입을 감추고 싶을 때

• Subject 의 send(_:) 메소드가 호출되는 걸 막고 싶을 때

  → 값 변경을 막음

eraseToAnyPublisher() 를 사용해서 publisher를 AnyPublisher로 감쌀 수 있다

Convenience Subscribers

Sink

final class Sink<Input, Failure> where Failure : Error

무한정으로 값들을 요청하는 subscriber

• receiveCompletion: completion에서 실행될 클로저
• receiveValue: 값을 받았을 때 실행할 클로저

Assign

final class Assign<Root, Input>

받은 항목을 key path를 사용해서 프로퍼티에 할당하는 subscriber

• Assign의 Failure 타입은 Never 이다.

• init(object:keyPath:)

  • subscriber는 새 값을 받을 때마다 object 의 프로퍼티에 값을 할당한다.

  • 할당해줄 프로퍼티는 keyPath 를 사용해서 나타낸다.

    (key-path expression은 여기를 참고하자..)

class SampleObject {
    var intValue: Int {
        didSet {
            print("intValue Changed: \(intValue)")
        }
    }

    init(intValue: Int) {
        self.intValue = intValue
    }

    deinit {
        print("sample object deinit")
    }
}

let myObject = SampleObject(intValue: 5)

let assign = Subscribers.Assign<SampleObject, Int>(object: myObject, keyPath: \.intValue)

let intArrayPublisher = [6,7,8,9].publisher
intArrayPublisher.subscribe(assign)

AnySubscriber

@frozen
struct AnySubscriber<Input, Failure> where Failure : Error

• 타입을 지운 subscriber

• AnyPublisher와 마찬가지로 자세한 타입을 보여주고 싶지 않을 때 사용

• Subscriber 를 직접 구현하지 않고, 프로토콜 안에 정의된 메소드를 위한 클로저를 사용해서 커스텀 subscriber를 만들고 싶을 때도 사용한다고 한다..

  → 많이 사용할 일은 없지 않을까?

Convenience Publishers와 비교?

• Publisher들은 Publisher 프로토콜을 채택한 구조체 (Future 제외)였음
• Subscriber들은 Subscribers 안에 정의되어 있고, class 타입이다.

Cancellable

Cancellable

protocol Cancellable

어떤 작업에 대한 취소가 가능함을 나타내는 프로토콜

cancel()

• 할당된 자원을 모두 해제함
• 타이머, 네트워크 접근, 디스크 I/O로 발생하는 사이드이펙트를 막을 수 있다

store(in:)

• cancellable 인스턴스를 저장하는 메소드

  → 파라미터로 받은 곳에 저장함

Subscription 프로토콜이 Cancellable 을 채택

→ thread-safe 하기 위해

AnyCancellable

final class AnyCancellable

취소되었을 때 클로저를 실행하는 type-erasing cancellable 객체

• Subscriber는 “cancellation token”을 갖기 위해 이 타입을 사용할 수 있다

  → caller가 publisher를 cancel하기 위해 사용

• deinit 되었을 때 자동으로 cancel() 을 호출한다.

할 일 목록을 추가하는 화면을 만들어보자.

AddListViewController

홈 뷰컨과 같이 AddList 뷰컨도 ViewModel을 생성하고 이를 View에게 전달하는 작업과 화면 전환 로직만을 담당한다

class AddListViewController: UIViewController {
      private var addListView: AddListView!
      ...
      private function setupAddListView() {
          let viewModel = AddListViewModel(tasksListService: TasksListService())
          addListView = AddListView(viewmodel: viewmodel)
          addListView.delegate = self
          self.view = addListView
      }
}

AddListView

할일 추가 화면에 있는 UI 컴포넌트들은 다음과 같다.

• UITextField (제목 입력)
• UIButton (추가 버튼, 뒤로 가기 버튼)
• IconSelector

bindViewToModel 메소드에서 위 컴포넌트들과 ViewModel을 바인딩해준다.

먼저 titleTextField 를 바인딩해보자.

titleTextfield
    .rx.text
    .map({ !($0?.isEmpty)! })
    .bind(to: addListButton.rx.isEnabled)
    .disposed(by: disposeBag)
titleTextfield.rx.text
    .map({ $0! })
    .bind(to: viewModel.input.title )
    .disposed(by: disposeBag)

map 메소드를 사용해서 텍스트 필드에 값이 입력되어 있는지 여부를 방출한다.

또한 UIButton의 tap 이벤트도 ViewModel과 바인딩해준다.

addListButton.rx.tap
    .bind(to: viewModel.input.addList)
    .disposed(by: disposeBag)
backButton.rx.tap
    .bind(to: viewModel.input.dismiss)
    .disposed(by: disposeBag)
viewModel.output.dismiss
    .drive(onNext: { [self] _ in
        delegate?.navigateBack()
    })

iconSelectorView 에는 선택한 아이콘의 이름을 방출하는 BehaviorRelay를 추가한다.

var selectedIcon = BehaviorRelay<String>(value: "checkmark.seal.fill")

그리고 selectedIcon 과 ViewModel을 바인딩해준다.

iconSelectorView.selectedIcon
    .bind(to: viewModel.input.icon)
    .disposed(by: disposeBag)

AddListViewModel

이 ViewModel에서는 Model과 상호작용 할 수 있게 TaskListService 에 레퍼런스를 전달하고 TaskListModel 객체를 초기화한다.

class AddListViewModel {
    var output: Output!
    var input: Input!
    struct Input {
        let icon: PublishRelay<String>
        let title: PublishRelay<String>
        let addList: PublishRelay<Void>
        let dismiss: PublishRelay<Void>
    }
    struct Output {
        let dismiss: Driver<Void>
    }
    ...
}

class AddListViewModel {
    ...
    private var tasksListService: TasksListServiceProtocol!
    private(set) var list: TasksListModel!
    private let dismiss = BehaviorRelay<Void>(value: ())
    init(tasksListService: TasksListServiceProtocol) {
        self.tasksListService = tasksListService
        self.list = TasksListModel(id: ProcessInfo().globallyUniqueString, icon: "checkmark.seal.fill",
        createdAt: Date())
        // Inputs
        let icon = PublishRelay<String>()
        _ = icon.subscribe(onNext: { [self] newIcon in
            list.icon = newIcon
        })
        let title = PublishRelay<String>()
        _ = title.subscribe(onNext: { [self] newTitle in
            list.title = newTitle
        })
        let addList = PublishRelay<Void>()
        _ = addList.subscribe(onNext: { [self] _ in
            tasksListService.saveTasksList(list)
            dismiss.accept(())
        })
        let dismissView = PublishRelay<Void>()
        _ = dismissView.subscribe(onNext: { [self] _ in
            dismiss.accept(())
        })
        input = Input(icon: icon, title: title, addList: addList, dismiss: dismissView)
        // Outputs
        let backNavigation = dismiss.asDriver()
        output = Output(dismiss: backNavigation)
       ...
    }
}

Tasks List Screen

이 화면은 목록 안에 있는 태스크를 보여주고, 완료 표시를 하고, 태스크를 추가하거나 삭제할 수 있는 화면이다.

TaskListViewController

이 뷰컨이 수행하는 역할은 다음과 같다.

• TaskListViewModel 인스턴스 초기화
• View에게 ViewModel 넘겨주기
• 태스크 추가 화면/홈 화면으로의 내비게이션 관리

class TaskListViewController: UIViewController {
    private var taskListView: TaskListView!
    private var tasksListModel: TasksListModel!
    init(tasksListModel: TasksListModel) {
        **self.tasksListModel = tasksListModel**
        super.init(nibName: nil, bundle: nil)
    }
    ...
    private func setupTaskListView() {
        **let viewModel = TaskListViewModel(tasksListModel: tasksListModel, taskService: TaskService(), tasksListService: TasksListService())
        taskListView = TaskListView(viewModel: viewModel)
        taskListView.delegate = self
        self.view = taskListView**
    }
}
extension TaskListViewController: TaskListViewControllerDelegate {
    func addTask() {
        let addTaskViewController = AddTaskViewController(tasksListModel: tasksListModel)
        addTaskViewController.modalPresentationStyle = .pageSheet
        present(addTaskViewController, animated: true)
    }
}
extension TaskListViewController: BackButtonDelegate {
    func navigateBack() {
        navigationController?.popViewController(animated: true)
    }
}

이 화면에서는 홈 화면에서 선택한 리스트에 있는 태스크들을 보여주기 때문에 초기화를 할 때 tasksListModel 을 전달해야 한다. 그리고 이 ViewModel은 다시 TaskListViewModel 에 전달된다.

TaskListView

TaskListView는 HomeView와 유사한 컴포넌트들을 가지고 있다.

• 태스크들의 목록을 보여주는 UITableView
• 태스크를 삭제/추가하는 버튼
• 태스크 목록 제목
• HomeView로 돌아가는 버튼

그외 태스크를 수정하거나 상태를 변경할 수 있는 기능들이 포함될 수 있다.

이런 기능들을 고려하면서 먼저 UITableView와 ViewModel을 바인딩해보자!

tableView.rx
    .setDelegate(self)
    .disposed(by: disposeBag)
tableView.rx.itemDeleted
    .bind(to: viewModel.input.deleteRow)
    .disposed(by: disposeBag)
viewModel.output.tasks
    .drive(tableView.rx.items(cellIdentifier: TaskCell.reuseId, cellType: TaskCell.self)) { (index, task, cell) in
        cell.setParametersForTask(task, at: index)
        cell.checkButton.rx.tap
            .map({ IndexPath(row: cell.cellIndex, section: 0) })
            .bind(to: viewModel.input.updateRow)
            .disposed(by: cell.disposeBag)
    }
    .disposed(by: disposeBag)

addTaskButton.rx.tap
    .asDriver()
    .drive(onNext: { [self] in
        delegate?.addTask()
    })
    .disposed(by: disposeBag)
backButton.rx.tap
    .asDriver()
    .drive(onNext: { [self] in
        delegate?.navigateBack()
    })
    .disposed(by: disposeBag)

이 버튼들을 누르면 delegate를 통해 뷰컨의 메소드를 호출한다.

viewModel.output.pageTitle
    .drive(pageTitle.rx.text)
    .disposed(by: disposeBag)
viewModel.output.hideEmptyState
    .drive(emptyState.rx.isHidden)
    .disposed(by: disposeBag)

페이지 제목과 빈 화면 여부도 바인딩해준다.

viewModel.input.reload.accept(())

마지막으로 reload를 accept한다. accept하면 ViewModel이 데이터베이스를 호출해서 생성된 태스크 목록을 불러오고 이를 테이블 뷰에 보여준다.

TasksListViewModel

class TaskListViewModel {
    var output: Output!
    var input: Input!
    struct Input {
        let reload: PublishRelay<Void>
        let deleteRow: PublishRelay<IndexPath>
        let updateRow: PublishRelay<IndexPath>
    }
    struct Output {
        let hideEmptyState: Driver<Bool>
        let tasks: Driver<[TaskModel]>
        let pageTitle: Driver<String>
    }
    ...
}

TaskListViewModel의 Input과 Output은 다음과 같다. 이제 이 속성들을 초기화해보자.

class TaskListViewModel {
    ...
    init(tasksListModel: TasksListModel,
         taskService: TaskServiceProtocol,
         tasksListService: TasksListServiceProtocol) {
        self.tasksListModel = tasksListModel
        self.taskService = taskService
        self.tasksListService = tasksListService
        // Inputs
        let reload = PublishRelay<Void>()
        _ = reload.subscribe(onNext: { [self] _ in
            fetchTasks()
        })
        let deleteRow = PublishRelay<IndexPath>()
        _ = deleteRow.subscribe(onNext: { [self] indexPath in
            deleteTaskAt(indexPath: indexPath)
        })
        let updateRow = PublishRelay<IndexPath>()
        _ = updateRow.subscribe(onNext: { [self] indexPath in
            updateTaskAt(indexPath: indexPath)
        })
        input = Input(reload: reload, deleteRow: deleteRow, updateRow: updateRow)
        // Outputs
        let items = tasks
            .asDriver(onErrorJustReturn: [])
        let hideEmptyState = tasks
            .map({ items in
                return !items.isEmpty
            })
            .asDriver(onErrorJustReturn: false)
        let pageTitle = pageTitle
            .asDriver(onErrorJustReturn: "")
        output = Output(hideEmptyState: hideEmptyState, tasks: items, pageTitle: pageTitle)
        ...
    }
    ...
}

개인적으로 ViewModel의 Output 역할이 항상 헷갈렸기 때문에 Output 속성들의 역할만 정리하자면

• hideEmptyState: 태스크들이 존재하는지 여부를 Bool값으로 리턴한다.
• tasks: 태스크들이 담긴 배열을 방출한다. 이 태스크의 타입은 TaskModel이고 데이터베이스에서 받아오는 값이다.
• pageTitle: 태스크 목록의 제목

이제 데이터베이스 (Model)에 접근하는 메소드를 작성하자.

class TaskListViewModel {
    ...
    private var tasksListModel: TasksListModel!
    private var taskService: TaskServiceProtocol!
    private var tasksListService: TasksListServiceProtocol!
    let tasks = BehaviorRelay<[TaskModel]>(value: [])
    let pageTitle = BehaviorRelay<String>(value: "")
    init(tasksListModel: TasksListModel,
         taskService: TaskServiceProtocol,
         tasksListService: TasksListServiceProtocol) {
        ...
        NotificationCenter.default.addObserver(self,
                           selector: #selector(contextObjectsDidChange),
                           name: NSNotification.Name.NSManagedObjectContextObjectsDidChange,
                           object: CoreDataManager.shared.mainContext)
    }
    @objc func contextObjectsDidChange() {
        fetchTasks()
    }
    func fetchTasks() {
        guard let list = tasksListService.fetchListWithId(tasksListModel.id) else { return }
        let orderedTasks = list.tasks.sorted(by: { $0.createdAt.compare($1.createdAt) == .orderedDescending })
        tasks.accept(orderedTasks)
        pageTitle.accept(list.title)
    }
    func deleteTaskAt(indexPath: IndexPath) {
        taskService.deleteTask(tasks.value[indexPath.row])
    }
    func updateTaskAt(indexPath: IndexPath) {
        var taskToUpdate = tasks.value[indexPath.row]
        taskToUpdate.done.toggle()
        taskService.updateTask(taskToUpdate)
    }
}

Add Task Screen

AddTaskViewController

초기화될 때 tasksListModel 을 받고 AddTaskViewModel 을 생성한 후 이를 View에 전달한다.****

class AddTaskViewController: UIViewController {
    private var addTaskView: AddTaskView!
    private var tasksListModel: TasksListModel!
    init(tasksListModel: TasksListModel) {
        super.init(nibName: nil, bundle: nil)
        self.tasksListModel = tasksListModel
    }
    ...
    private func setupAddTaskView() {
        let viewModel = AddTaskViewModel(tasksListModel: tasksListModel, taskService: TaskService())
        addTaskView = AddTaskView(viewModel: viewModel)
        addTaskView.delegate = self
        self.view = addTaskView
    }
}

AddTaskView

이 View의 코드는 AddListView 와 유사하다.

func bindViewToModel(_ viewModel: AddTaskViewModel) {
    titleTextfield.rx.text
        .map({!($0?.isEmpty)!})
        .bind(to: addTaskButton.rx.isEnabled)
        .disposed(by: disposeBag)
    titleTextfield.rx.text
        .map({ $0! })
        .bind(to: viewModel.input.title )
        .disposed(by: disposeBag)
    addTaskButton.rx.tap
        .bind(to: viewModel.input.addTask)
        .disposed(by: disposeBag)
    iconSelectorView.selectedIcon
        .bind(to: viewModel.input.icon)
        .disposed(by: disposeBag)
    viewModel.output.dismiss
        .skip(1)
        .drive(onNext: { [self] in
            delegate?.addedTask()
        })
        .disposed(by: disposeBag)
}

AddTaskViewModel

AddTaskViewModel 은 태스크를 생성한 태스크를 데이터베이스에 저장하는 역할을 담당한다.

class AddTaskViewModel {
    var output: Output!
    var input: Input!
    struct Input {
        let icon: PublishRelay<String>
        let title: PublishRelay<String>
        let addTask: PublishRelay<Void>
    }
    struct Output {
        let dismiss: Driver<Void>
    }
    ...
}

class AddTaskViewModel {
    ...
    private var tasksListModel: TasksListModel!
    private var taskService: TaskServiceProtocol!
    private(set) var task: TaskModel!
    let dismiss = BehaviorRelay<Void>(value: ())
    init(tasksListModel: TasksListModel,
         taskService: TaskServiceProtocol) {
        self.tasksListModel = tasksListModel
        self.taskService = taskService
        self.task = TaskModel(id: ProcessInfo().globallyUniqueString, 
                                                  icon: "checkmark.seal.fill",
                                                  done: false,
                                                  createdAt: Date())
        // Inputs
        let icon = PublishRelay<String>()
        _ = icon.subscribe(onNext: { [self] newIcon in
            task.icon = newIcon
        })
        let title = PublishRelay<String>()
        _ = title.subscribe(onNext: { [self] newTitle in
            task.title = newTitle
        })
        let addTask = PublishRelay<Void>()
        _ = addTask.subscribe(onNext: { [self] _ in
            taskService.saveTask(task, in: tasksListModel)
            dismiss.accept(())
        })
        input = Input(icon: icon, title: title, addTask: addTask)
        // Outputs
        let dismissView = dismiss.asDriver()
        output = Output(dismiss: dismissView)
    }
}

input.addTask 는 데이터베이스에 새 태스크를 추가하는 메소드를 실행한 후 dismiss 메소드를 호출한다.

드디어 기능 개발 부분은 다 읽었다..!!! 여러 번 구현 과정을 보고, 회사에서도 개발을 하니까 확실히 혼자 공부할 때보다 이해가 훨씬 잘 된다! 다음은 이제 테스트 방법... 상반기 안에 이 책 꼭 완독해야지..👀

이제 MVVM을 활용해서 투두 애플리케이션을 만들어보자.

MVVM은 MVP 아키텍처와 비슷하다. ViewModel이 Presenter와 비슷한 기능을 하기 때문이다.

MVP는 View와 Presenter의 결합도가 높다는 단점이 있다. 즉, View와 Presenter가 서로를 참조해야 한다.

하지만 데이터 바인딩을 사용하면 이 결합도를 낮출 수 있다!

AppDelegate and SceneDelegate

AppDelegate, SceneDelegate에서 첫 화면으로 쓰일 ViewController 객체를 생성한다. 이때 뷰컨 객체에 서비스에 대한 dependency를 전달하지 않는다. ViewModel 안에서 dependency를 주입할 것이기 때문!

Home Screen

Home Screen의 메인 컴포넌트는 HomeViewModel 이다. 이 뷰모델은 HomeView 에 바인딩되어 있다.

HomeViewController

뷰컨에서 HomeViewModel 의 객체를 생성하고, 이를 View에게 전달한다.

또한 화면 전환 역시 뷰컨이 담당한다.

extension HomeViewController: HomeViewControllerDelegate {
    func addList() {
        navigationController?.pushViewController(AddListViewController(), animated: true)
    }
    func selectedList(_ list: TasksListModel) {
        let taskViewController = TaskListViewController(tasksListModel: list)
        navigationController?.pushViewController(taskViewController, animated: true)
    }
}

Coordinator 패턴을 사용하면 뷰컨에서 화면전환 로직을 제거할 수 있다.

HomeView

MVVM의 View에서 특히 주목해야 할 것은 데이터 바인딩을 사용해서 ViewModel의 상태 변경을 감지하는 방법이다.

RxSwift를 사용하면 쉽게 View의 컴포넌트들과 Model을 연결할 수 있다.

class HomeView: UIView {
    ...
    private let viewModel: HomeViewModel!
    private let disposeBag = DisposeBag()
    init(frame: CGRect = .zero, viewModel: HomeViewModel) {
        self.viewModel = viewModel
        ...
        bindViewToModel(viewModel)
    }
}
private extension HomeView {
    ...
    func bindViewToModel(_ viewModel: HomeViewModel) {
        ...
    }
}

View의 컴포넌트와 ViewModel 바인딩하기

먼저 UITableView 를 바인딩해보자. 일단 테이블 뷰의 Delegate를 설정한다.

tableView.rx
         .setDelegate(self)
         .disposed(by: disposeBag)

그 다음 섹션, 행, 항목의 수에 대한 정보를 전달한다.

viewModel.output.lists
    .drive(tableView.rx.items(cellIdentifier: ToDoListCell.reuseId, cellType: ToDoListCell.self)) { (_, list, cell) in
        cell.setCellParametersForList(list)
    }
.disposed(by: disposeBag)

Input/Output 접근법에 따르면, 태스크(할 일)의 목록이 ViewModel의 output이 된다. tableView.rx.items() 메소드를 사용해서 이 데이터와 테이블 뷰 cell들을 바인딩한다.

다음으로 사용자가 셀을 선택하는 액션을 구독한다. 이때는 input.selectRow 파라미터를 사용한다.

tableView.rx.itemSelected
    .bind(to: viewModel.input.selectRow)
    .disposed(by: disposeBag)
viewModel.output.selectedList
    .drive(onNext: { [self] list in
        delegate?.selectedList(list)
    })
    .disposed(by: disposeBag)

1. 사용자가 table view의 cell을 선택한다.
2. 사용자가 선택한 cell의 indexPath를 ViewModel에 전달한다.
   1. itemSelected 는 선택한 셀의 indexPath를 반환해준다.
3. 이에 대한 TaskListModel 을 output으로 방출한다.

addListButton.rx.tap
    .asDriver()
    .drive(onNext: { [self] in
        delegate?.addList()
    })
    .disposed(by: disposeBag)

버튼을 탭했을 때 실행될 로직은 위와 같이 작성한다. rx를 사용하면 버튼 이벤트를 tap 이라는 메소드로 간단하게 처리할 수 있다.

마지막으로 table view를 reload하는 코드를 추가한다.

viewModel.input.reload.accept(())

HomeViewModel

ViewModel은 Model로부터 데이터를 얻은 데이터를 View에게 전달하고, View의 비즈니스 로직을 관리한다.

class HomeViewModel {
    var output: Output!
    var input: Input!
    struct Input {
        let reload: PublishRelay<Void>
        let deleteRow: PublishRelay<IndexPath>
        let selectRow: PublishRelay<IndexPath>
    }
    struct Output {
        let hideEmptyState: Driver<Bool>
        let lists: Driver<[TasksListModel]>
        let selectedList: Driver<TasksListModel>
    }
    ...
}

HomeViewModel 의 Input과 Output은 위와 같이 구성되어 있다.

Input과 Output을 정의한 다음에는 ViewModel의 생성자 안에서 동작을 정의한다.

    init(taskListService: TasksListServiceProtocol) {
        ...
              // Inputs
        let reload = PublishRelay<Void>()
        _ = reload.subscribe(onNext: { [self] _ in
            fetchTasksLists()
        })
        let deleteRow = PublishRelay<IndexPath>()
        _ = deleteRow.subscribe(onNext: { [self] indexPath in
            tasksListService.deleteList(listAtIndexPath(indexPath))
        })
        let selectRow = PublishRelay<IndexPath>()
        _ = selectRow.subscribe(onNext: { [self] indexPath in
        taskList.accept(listAtIndexPath(indexPath))
        })
        self.input = Input(reload: reload, deleteRow: deleteRow, selectRow: selectRow)
        // Outputs
        let items = lists
            .asDriver(onErrorJustReturn: [])
        let hideEmptyState = lists
            .map({ items in
                return !items.isEmpty
            })
            .asDriver(onErrorJustReturn: false)
             let selectedList = taskList.asDriver()
        output = Output(hideEmptyState: hideEmptyState, lists: items, selectedList: selectedList)
        ...

다시 또 정리해보자..

• Input: 사용자와 인터랙션이 발생하면 이를 Input 속성에게 전달(바인딩)한다. ViewModel 내에서 Input 속성들을 구독하고 있기 때문에 인터랙션이 일어난 후에 ViewModel에서 관련된 처리를 해줄 수 있다.
• Output: Output 속성을 구독하고 무언가 처리하는 건 View이기 때문에, ViewModel에서는 asDriver() 메소드를 사용해서 각 Output들을 driver로 변환만 해준다.

그리고 Model에 접근하는 메소드 역시 ViewModel에서 작성한다.

이제 MVVM 패턴을 적용해서 투두 앱을 만들어보자! 이전 글과 마찬가지로 새롭게 알게 된 내용이나 기억하고 싶은 내용 위주로만 작성할 예정이다.

MVVM Layer

Model

• 비즈니스 로직과 관련된 모든 것들
• 모델 안에서 일어난 변화를 ViewModel이 알아야 한다. 이를 위해 ViewModel의 init 메소드 안에서 옵저버를 등록한다.

Model 디렉토리 안에 있는 하위 디렉토리들은 아래와 같다.

📂 Core Data

• CoreDataManager.swift 파일이 있는 곳

📂 Models

• 데이터베이스 엔티티를 모델로 변환하는 모델들을 포함한다. 이를 구현할 때 필요한 프로토콜도 포함한다.

📂 Services

• 데이터베이스에 데이터를 업로드하는 로직과 관련된 클래스들을 포함한다.
• 그외에도 데이터베이스로부터 데이터를 받는 클래스, 이를 모델로 변환하는 클래스들도 포함한다.

📂 Extensions

• 이 프로젝트에서는 UIColor, NSManagedObject 익스텐션들을 포함한다.
  • NSManagedObject는 테스트를 할 때 사용됨

📂 Constants

• 앱 내에서 사용되는 상수 파라미터들을 포함한다.

View

• View와 ViewController 파일들이 있는 곳
• MVVM에서 컨트롤러는 화면간 내비게이션과 데이터 전달(델리게이트 패턴 등) 기능만을 가지고 있다는 것 잊지 말기!

ViewModel

• Model과 View를 연결하는 ViewModel들만을 포함한다.

RxSwift 잠깐 복습하고 넘어가기

RxSwift는 비동기적으로 코드를 작성할 수 있게 도와주는 라이브러리다. 새로운 데이터를 받으면 동작할 코드를 연속적이고 독립적으로 간단하게 작성할 수 있다.

Observables and Observers

• Observable: 변경이 생기면 알림을 방출한다.
• Observer: Observable을 구독해서 알림을 받는다.

Observable은 한 개 이상의 Observer를 가질 수 있다.

Input/Output Approach

Input/Output 접근법은 서로 다른 컴포넌트와 이벤트를 바인딩하고 RxSwift를 더 체계적으로 사용하기 위한 방법이다.

• Input: View에서 일어나는 모든 이벤트와 인터랙션. ViewModel에 영향을 주는 것들이다. (텍스트 입력, 버튼 터치 등)
• Output: 모델에서 일어나는 변화들. 얘네들은 반드시 View에 반영되어야 한다.

class ExampleViewModel {
    var output: Output!
    var input: Input!

    struct Input {
        let text: PublishRelay<String>
    }

    struct Output {
        let title: Driver<String>
    }

    init() {
        let text = PublishRelay<String>()

        let capsTitle = text
            .map({
                return text.uppercased()
            })
            .asDriver(onErrorJustReturn: "")
        input = Input(text: test)
        output = Output(title: capsTitle)
    }
}

Input/Output 접근법을 사용해서 ViewModel을 구현한 예시이다.

• PublishRelay

  • 구독한 이후 발생하는 값들을 방출한다.
  • 예제에서는 UITextField 에서 입력한 문자열 값이 방출될 것이다.

• Driver

  • 메인 스레드에서 동작하는 Observable이다.

    → 기본적으로 Observable은 백그라운드 스레드에서 동작한다고 한다. 그래서 View를 업데이트하기 위해 Driver를 사용하는 것..!!!

  • 예제에서는 UITextField 에서 받아온 값을 UI 컴포넌트에 전달한다.

나중에 알게 되었는데, ViewModel 초기화 시점에 Input의 스트림을 생성하지 않고 View에게 Input을 전달받고 Output 스트림을 생성해서 리턴하는 메소드를 정의하는 방법도 있다고 한다. 참고1, 참고2

그럼 ViewModel과 View는 어떻게 바인딩해줄까?

class ExampleView {
    func bind() {
        textfield.rx.text
            .bind(to: viewModel.input.text)
            .disposed(by: disposeBag)

        viewModel.output.title
            .drive(titleLabel.rx.text)
            .disposed(by: disposeBag)
    }
}

• UITextField 의 text 파라미터를 ViewModel의 text 변수(Input)와 바인딩한다. 사용자가 텍스트필드에 텍스트를 입력하면 ViewModel이 이를 받게 된다.
• ViewModel Output의 title 변수를 UILabel 의 text 파라미터와 바인딩한다. 사용자가 타이핑을 하면 ViewModel의 text가 대문자로 변환되고, View에 전달되어서 화면에 표시된다.

흠…🤔

• Subscribe / Bind / Drive에 대한 차이점 정리는 요기로.. Rx에 익숙해지면 나도 더 자세히 공부해봐야지!!!

• bind(to:)는 새 구독을 생성하고 항목들을 Observer들에게 보내주는 메소드이다.

• drive 는 Drive 에서만 정의되며, bind(to:) 대신 사용할 수 있다고 한다..

  → 그니까 텍스트필드의 텍스트를 구독해서 뷰모델의 input에 알려주고, 뷰모델의 output을 구독해서 타이틀라벨의 텍스트에게 알려주는…..

🤯 너무 헷갈린다.. 그래서 누가 누굴 구독하는 거야?

1. bind(to:) 메소드는 다음과 같은 형태로 작성되어 있다.

    public func bind(to relays: PublishRelay<Element>...) -> Disposable {
        bind(to: relays)
    }

   이 메소드는 새 구독을 생성하고 항목을 publish relay들에게 보내는 메소드라고 한다.

   안에 있는 bind 메소드가 어떻게 구현되어 있는지 더 뜯어보자.

    private func bind(to relays: [PublishRelay<Element>]) -> Disposable {
        subscribe { e in
            switch e {
            case let .next(element):
                 relays.forEach {
                    $0.accept(element)
                }
            case let .error(error):
                rxFatalErrorInDebug("Binding error to publish relay: \(error)")
            case .completed:
                break
            }
        }
    }

   이 bind 메소드를 호출하는 Observable을 구독하고, 새 항목이 방출되면 파라미터로 받은 relay에게 그 항목을 전달하는 것 같다!

   to 라는 파라미터 이름을 방출된 항목을 받는 친구를 가리키는 거라고 생각해야겠다.

2. drive() 는 종류가 다양하다. Observer와 Relay 모두 파라미터로 받을 수 있다.

    public func drive<Observer: ObserverType>(_ observers: Observer...) -> Disposable where Observer.Element == Element {
        MainScheduler.ensureRunningOnMainThread(errorMessage: errorMessage)
        return self.asSharedSequence()
                   .asObservable()
                   .subscribe { e in
                    observers.forEach { $0.on(e) }
                   }
        }

   이 메소드도 새 구독을 생성하고 항목을 observer에게 보내주는 메소드라고 한다. 대신 메인 스레드에서만 호출된다.

결론은 bind(to:) 와 drive() 모두 메소드를 호출하는 Observable을 구독하는 것이고, 파라미터로 받은 Observer가 변경된 값을 전달받는 듯 하다!

• MVVM은 웹 인터페이스의 이벤트 기반 프로그래밍을 단순화하기 위해 고안된 패턴이다.

• MVP 패턴에서 발전된 패턴으로, Presenter 레이어가 ViewModel 레이어로 대체되었다.

  → View와 Presenter 사이의 결합도를 낮추고자 한 패턴이다.

Components in MVVM

Model

비즈니스 로직과 데이터를 저장, 조작, 접근하는 컴포넌트이다. Model에 포함되는 요소들은 다음과 같다.

• 데이터 저장과 관련된 클래스
• 애플리케이션의 통신을 제어하는 클래스
• 외부에서 받은 정보를 모델 객체로 변환하는 책임을 가짐
• 익스텐션, 상수들

Model 레이어는 ViewModel 레이어와만 소통할 수 있다. Model은 View의 존재를 몰라야 한다!

View

UIView와 UIViewController를 모두 포함한다.

• 사용자에게 업데이트된 정보를 항상 보여주어야 한다. 이때 정보는 ViewModel이 전해줌!
• View는 어떤 로직도 바꾸지 않는다.
• ViewModel에 대한 여러 레퍼런스를 가질 수 있다.

Controller는 코디네이션이나 라우팅하는 함수, 화면간의 내비게이션, 델리게이트 패턴을 통해 받은 정보를 전달하는 로직만을 갖게 된다.

ViewModel

ViewModel은 MVVM의 중심이 되는 레이어이다. MVC의 컨트롤러나 MVP의 프레젠터 같은 느낌.

• ViewModel은 항상 View의 현재 상태를 보여주어야 한다.
• View를 제어하는 Input/Output 정보를 가공한다.
• View는 ViewModel을 소유하고, ViewModel은 Model을 소유한다.
  • View ← ViewModel ← Model

ViewModel은 데이터 바인딩을 통해 View에 연결된다. 이를 통해 ViewModel이 관리하는 정보의 상태가 변하면 View가 자동으로 업데이트 될 수 있다.

Data Binding

View와 ViewModel 사이에 데이터 바인딩을 하는 방법은 여러 가지가 있다.

• RxSwift, Bond, Combine 같은 라이브러리 사용
• KVO (Key-Value observing) 패턴 사용
• Delegate 패턴, 클로져 사용

Advantages and Disadvantages of MVVM

Advantages

• 책임이 더욱 명확하게 분리된다.

  → 유지가 쉽다.

• 테스트를 하기 쉽다.

  → View를 고려하지 않고 ViewModel의 비즈니스 로직을 테스트할 수 있다. 또한 MVC와 다르게 컨트롤러가 Model에 의존하지 않기 때문에 컨트롤러도 테스트하기 용이함!

• MVC 아키텍처에서 마이그레이션 할 때 자주 사용된다.

Disadvantages

• 외부 라이브러리를 사용하는 경우 고려해야 될 점들
  • 앱의 용량이 증가한다.
  • 앱의 성능에도 영향을 준다.
  • 외부 라이브러리를 정확하게 사용하기 위한 러닝 커브
• 데이터 바인딩은 선언형 패러다임으로, 프로그램이 어떻게 동작할지가 아닌 무엇을 해야 할지에 대한 코드를 작성한다. 이는 디버깅을 어렵게 만들고, UIKit보다 SwiftUI에 대한 이해를 더욱 필요로 한다.
• 아키텍처를 제대로 적용하지 않으면 ViewModel에 해당하지 않는 함수를 오버로딩 하게 될 수 있다.
• 처음 시작할 때는 복잡하다. 😅

MVC 패턴을 공부한지 9개월이 지나고 나서 다음 공부하는 나란 사람..ㅎㅎ;;

관찰 가능한 데이터를 새로운 시퀀스로 변형하는 operator이다.

ToArray

여러 개의 항목들을 하나의 배열로 변환해주는 operator이다.

let disposeBag = DisposeBag()

Observable.of(1, 2, 3, 4, 5)
    .toArray()
    .subscribe({
        print($0)
    }).disposed(by: disposeBag)

// 실행결과
// success([1, 2, 3, 4, 5])

toArray() 의 반환 타입이 Single<[Element]> 인데, 그래서 subscribe에 onNext 가 없는 것 같다. 나중에 업데이트 된 것 같은데 더 알아봐야 할 듯

Map

시퀀스의 각 항목들에 함수를 적용하는 함수. Swift의 map과 유사하다.

let disposeBag = DisposeBag()

Observable.of(1, 2, 3, 4, 5)
    .map {
        return $0 * 2
    }.subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

/* 실행 결과
2
4
6
8
10
*/

FlatMap

Observable에 의해 방출된 항목을 다시 Observable로 변형하고 방출된 항목을 다시 하나의 Observable로 평면화한다.

let disposeBag = DisposeBag()

struct Student {
    var score: BehaviorRelay<Int>
}

let john = Student(score: BehaviorRelay(value: 75))
let mary = Student(score: BehaviorRelay(value: 95))

let student = PublishSubject<Student>()
    .flatMap { $0.score.asObservable() }
    .subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

student.onNext(john)
john.score.accept(100)
student.onNext(mary)

// 실행결과
// 75
// 100
// 95

john의 score 값을 변경하려면 같이 accept 메소드를 사용해야 한다.

위 예시처럼 내부에 있는 Observable을 변형하고 평면화할 때 유용하다고 한다.

Map은 단순한 값을 반환하지만 flatMap은 Observable을 반환하는 것이 가장 큰 차이인 것 같다. 아직은 둘의 차이점이 완전히 와닿지는 않음 ㅠ-ㅠ

[RxSwift] map vs flatMap

FlatMapLatest

let disposeBag = DisposeBag()

struct Student {
    var score: BehaviorRelay<Int>
}

let john = Student(score: BehaviorRelay(value: 75))
let mary = Student(score: BehaviorRelay(value: 95))

let student = PublishSubject<Student>()
    .flatMapLatest { $0.score.asObservable() }
    .subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

student.onNext(john)
john.score.accept(100)

student.onNext(mary)
john.score.accept(45)

/* 실행 결과
75
100
95
*/

flatMap에서 발생하는 이벤트 중 가장 최신 이벤트만 관찰하고 싶을 때 사용하는 operator이다.

위 예시에서는 마지막으로 mary를 observe 하고 있기 때문에 john의 score 값을 바꿔도 이벤트가 무시되는 것을 볼 수 있다.

Combining Operators

StartWith

Observable의 항목들을 방출하기 전 특정 시퀀스를 먼저 방출한다.

let disposeBag = DisposeBag()

let numbers = Observable.of(2, 3, 4)

let observable = numbers.startWith(1)
observable.subscribe(onNext: {
    print($0)
}).disposed(by: disposeBag)

/* 실행 결과
1
2
3
4
*/

Concat

둘 이상의 Observable을 하나로 합쳐주는 Operator이다.

let disposeBag = DisposeBag()

let first = Observable.of(1, 2, 3)
let second = Observable.of(4, 5, 6)

let observable = Observable.concat([first, second])

observable.subscribe(onNext: {
    print($0)
}).disposed(by: disposeBag)

/* 실행 결과
1
2
3
4
5
6
*/

Merge

여러 개의 Observable들을 하나로 합치는 operator이다. concat operator와 달리 각 값들의 도착 시간을 기준으로 순서가 정해진다.

let disposeBag = DisposeBag()

let left = PublishSubject<Int>()
let right = PublishSubject<Int>()

let source = Observable.of(left.asObservable(), right.asObservable())

let observable = source.merge()
observable.subscribe(onNext: {
    print($0)
}).disposed(by: disposeBag)

left.onNext(5)
left.onNext(3)
right.onNext(2)
right.onNext(1)
left.onNext(99)

/* 실행 결과
5
3
2
1
99
*/

left 와 right 를 observe 하는 Observable을 만들고, 여기에 merge operator를 적용한다.

CombineLatest

두 Observable의 최신 항목들을 합쳐서 새로운 결과를 만드는 operator이다.

let disposeBag = DisposeBag()

let left = PublishSubject<Int>()
let right = PublishSubject<Int>()

let observable = Observable.combineLatest(left, right, resultSelector: {
    lastLeft, lastRight in
    "\(lastLeft) \(lastRight)"
})

let disposable = observable.subscribe(onNext: { value in
    print(value)
})

left.onNext(45)
right.onNext(1)
left.onNext(30)
right.onNext(1)
right.onNext(2)

/* 실행 결과
45 1
30 1
30 1
30 2
*/

combineLast operator는 resultSelector 라는 파라미터를 가진다!

WithLatestFrom

source Observable을 다른 Observable들과 결합해서 새로운 observable을 만든다. source Observable에서 항목이 방출될 때만 다른 observable들의 최신 값들과 source observable의 값이 합쳐진다.

let disposeBag = DisposeBag()

let button = PublishSubject<Void>()
let textField = PublishSubject<String>()

let observable = button.withLatestFrom(textField)
let disposable = observable.subscribe(onNext: {
    print($0)
})

textField.onNext("Sw")
textField.onNext("Swif")
textField.onNext("Swift")

button.onNext(())
button.onNext(())

/* 실행 결과
Swift
Swift
*/

위 예제에서는 button 이 source observable이자 트리거 역할을 한다.

Rx: combineLatest vs withLatestFrom

Reduce

Observable이 방출하는 항목들마다 함수를 적용하고 최종 값을 마지막으로 방출한다. 기존에 Swift에 있는 reduce 와 유사하다.

let disposeBag = DisposeBag()

let source = Observable.of(1, 2, 3)

// 방법 1
source.reduce(0, accumulator: +)
    .subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

// 방법 2
source.reduce(0, accumulator: {
    summary, newValue in
    return summary + newValue
}).subscribe(onNext: {
    print($0)
}).disposed(by: disposeBag)

/* 실행 결과
6
*/

Scan

reduce와 유사한데 함수가 적용된 결과값을 계산 과정 중에 계속 방출해준다는 차이점이 있다.

이름 그대로 계산 과정을 스캔하는 느낌 👀

let disposeBag = DisposeBag()

let source = Observable.of(1, 2, 3, 5, 6)

source.scan(0, accumulator: +)
    .subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

/* 실행 결과
1
3
6
11
17
*/

Ignoring Operator

1, 2, 3이라는 세 가지 값을 가지고 있는 시퀀스가 있다고 해보자. ignoreElements() 라는 ignoring operator를 사용하면 시퀀스의 모든 원소들을 무시한다. 그런데 이때도 completed 이벤트는 발생하게 된다.

let strikes = PublishSubject<String>()

let disposeBag = DisposeBag()

strikes
    .ignoreElements()
    .subscribe { _ in
        print("[Subscription is called]")
    }.disposed(by: disposeBag)

strikes.onNext("A")
strikes.onNext("B")
strikes.onNext("C")

위 코드를 실행해보면 아무 것도 출력되지 않는다. ignoreElements() 라는 operator를 실행했기 때문!

이 subscription은 onCompleted 라는 completed 이벤트가 발생했을 때만 호출된다.

strikes.onCompleted()

위 코드를 추가해주면 [Subscription is called] 라는 문구가 잘 출력된다.

Ignoring Operator는 실제 값은 상관없고 observation이 완료되었는지만 구독받고 싶을 때 사용하면 좋다.

elementAt()

어떤 시퀀스가 있을 때 elementAt() 메소드를 사용하면 인자로 전달된 인덱스에 있는 값을 얻을 수 있다.

let strikes = PublishSubject<String>()
let disposeBag = DisposeBag()

strikes.element(at: 2)
    .subscribe(onNext: { _ in
        print("You are out!")
    }).disposed(by: disposeBag)

strikes.onNext("X")
strikes.onNext("X")
strikes.onNext("X") // You are out!

strikes 에서 elementAt() 메소드를 호출하고 구독했다. 이후 세 번째 값이 방출되었을 때 이벤트가 실행이 된다. 두 번째 값까지만 방출하면 이벤트는 실행되지 않는다.

Filter Operator

조건에 맞는 값만 방출하는 operator이다.

let strikes = PublishSubject<String>()
let disposeBag = DisposeBag()

Observable.of(1, 2, 3, 4, 5, 6, 7)
    .filter { $0 % 2 == 0 }
    .subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

// 출력 결과
// 2
// 4
// 6

위 Observable에서 filter() 메소드를 호출하여 짝수 값이 방출될 때만 이벤트가 호출되는 것을 볼 수 있다.

Skip Operator

Skip

파라미터로 받은 숫자만큼 방출된 항목들을 건너뛰는 operator이다.

let strikes = PublishSubject<String>()
let disposeBag = DisposeBag()

Observable.of("A", "B", "C", "D", "E", "F")
    .skip(3)
    .subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

// 실행 결과
// D
// E
// F

SkipWhile

조건식을 만족할 때까지 계속 건너뛴다. 한 번 조건식이 false 가 되면 이후 다른 값들은 모두 시퀀스의 항목에 포함된다.

let strikes = PublishSubject<String>()
let disposeBag = DisposeBag()

Observable.of(2, 2, 3, 4, 4)
    .skip(while: { $0 % 2 == 0 })
    .subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

/* 실행 결과:
3
4
4
*/

SkipUntil

트리거 역할을 하는 Operator가 이벤트를 방출하기 전까지 항목을 건너뛴다.

다른 observable을 기반으로 하기 때문에 동적으로 요소들을 필터링 할 수 있다는 장점이 있다!

let strikes = PublishSubject<String>()
let disposeBag = DisposeBag()

let subject = PublishSubject<String>()
let trigger = PublishSubject<String>()

subject.skip(until: trigger)
    .subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

subject.onNext("A")
subject.onNext("B")

trigger.onNext("X")

subject.onNext("C")

/* 실행 결과
C
*/

trigger 가 항목을 방출한 후에야 subject 의 C라는 항목이 방출된 것을 볼 수 있다.

Taking Operator

Skip Operator와 유사하지만 정반대로 동작하는 operator이다.

Take

처음부터 n개의 항목들만 방출한다.

let strikes = PublishSubject<String>()
let disposeBag = DisposeBag()

Observable.of(1, 2, 3, 4, 5, 6)
    .take(3)
    .subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

/* 실행 결과:
1
2
3
*/

TakeWhile

조건식을 만족하는 동안 항목들을 방출한다. 조건식이 false 가 되면 더 이상 방출을 하지 않는다.

let strikes = PublishSubject<String>()
let disposeBag = DisposeBag()

Observable.of(2, 4, 6, 7, 8, 10)
    .take(while: {
        $0 % 2 == 0
    }).subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

/* 실행 결과:
2
4
6
*/

TakeUntil

트리거 역할을 하는 observable이 항목을 방출하거나 종료되기 전까지 항목들을 방출한다.

let strikes = PublishSubject<String>()
let disposeBag = DisposeBag()

let subject = PublishSubject<String>()
let trigger = PublishSubject<String>()

subject.take(until: trigger)
    .subscribe(onNext: {
        print($0)
    }).disposed(by: disposeBag)

subject.onNext("1")
subject.onNext("2")

trigger.onNext("X")

subject.onNext("3")

/* 실행 결과:
1
2
*/

trigger 가 X라는 항목을 방출하기 전까지만 subject 의 항목이 출력되는 것을 볼 수 있다.

Subject는 Observable이자 Observer이다.

이벤트를 받으면 그 이벤트를 다시 구독자들에게 전달하는 역할을 한다.

→ 값을 방출할 수 있을 뿐 아니라 Observe도 가능하다!!

Subject에는 Publish Subject, Behavior Subject, Replay Subject, BehaviorRelay등 다양한 종류가 있다.

[RxSwift] Subject의 종류

Publish Subject 써보기

let subject = PublishSubject<String>()

subject.onNext("Issue 1")

subject.subscribe { event in
    print(event)
}

subject.onNext("Issue 2")
subject.onNext("Issue 3")

subject.dispose()

subject.onCompleted()

subject.onNext("Issue 4")

// 실행 결과
next(Issue 2)
next(Issue 3)

Publish Subject는 초깃값 없이 생성되고, 구독한 이후 방출되는 이벤트만 전달받는다.

• onNext() 메소드를 사용해서 값을 방출한다.
• Issue1은 subscribe를 하기 전 방출되었기 때문에 이벤트가 출력되지 않는다.
• dispose() 메소드를 호출한 후에 호출된 메소드들의 결과는 적용되지 않는다.
• dispose() 를 호출하지 않고 onCompleted() 만 호출하면 completed가 출력된다.

Behavior Subject

Behavior Subject는 Publish Subject와 비슷하다. 대신 초기화를 할 때 초깃값을 전달해주어야 한다. 구독을 하면 가장 최신 이벤트를 전달받는다.

let disposeBag = DisposeBag()

let subject = BehaviorSubject(value: "Initial Value")

subject.onNext("Last Issue")

subject.subscribe { event in
    print(event)
}

subject.onNext("Issue 1")

// 실행 결과
next(Last Issue)
next(Issue 1)

초깃값을 설정한 후 방출된 최신 값이 Last Issue 이므로 Last Issue를 방출하고, 그 다음 Issue 1 이 방출되었기 때문에 Issue 1도 출력된다.

Replay Subject

설정한 버퍼 크기만큼의 이벤트를 저장하고, Observer가 구독을 시작하면 버퍼에 있는 모든 이벤트를 전달한다.

let subject = ReplaySubject<String>.create(bufferSize: 2)

subject.onNext("Issue 1")
subject.onNext("Issue 2")
subject.onNext("Issue 3")

subject.subscribe {
    print($0)
}

// 실행 결과
next(Issue 2)
next(Issue 3)

버퍼 크기를 2로 설정했기 때문에 가장 마지막으로 방출된 두 개의 이벤트가 전달된 것을 볼 수 있다.

let subject = ReplaySubject<String>.create(bufferSize: 2)

subject.onNext("Issue 1")
subject.onNext("Issue 2")
subject.onNext("Issue 3")

subject.subscribe {
    print($0)
}

subject.onNext("Issue 4")
subject.onNext("Issue 5")
subject.onNext("Issue 6")

print("[Subscription 2]")
subject.subscribe {
    print($0)
}

첫 번째 subscribe 밑에 3개의 이벤트와 새로운 subscribe 메소드를 하나 추가하고 코드를 실행시키면 아래와 같은 실행결과가 나온다.

next(Issue 2)
next(Issue 3)
next(Issue 4)
next(Issue 5)
next(Issue 6)
[Subscription 2]
next(Issue 5)
next(Issue 6)

두 번째 subscription은 가장 마지막에 방출된 이벤트인 Issue5와 Issue6을 출력한다.

Variable (*deprecated)

Variable은 behavior subject를 감싸고 있으며, 현재 값의 상태를 저장한다. 이 값은 value 프로퍼티를 사용해서 접근할 수 있다.

let variable = Variable("Initial Value")

variable.value = "Hello world"

variable.asObservable()
    .subscribe {
        print($0)
}

// next(Hello World)

Variable은 RxSwift에서 공식적으로 deprecated되었다고 한다 😱 대신 BehaviorRelay 나 BehaviorSubject 를 사용해야 한다. (참고: What’s New in RxSwift5)

Behavior Relay

BehaviorRelay는 RxCocoa 를 import해야 사용할 수 있다.

let relay = BehaviorRelay(value: "Initial Value")

relay.asObservable()
    .subscribe {
        print($0)
    }

relay.value = "Hello World" // Error!

relay.accept("Hello World")

BehaviorRelay의 value 는 읽기 전용이기 때문에 값을 직접 수정할 수 없다. 대신 accept() 라는 메소드를 사용해서 새 값을 넣어줄 수 있다.

// 실행 결과
next(Initial Value)
next(Hello World)

BehaviorRelay의 값이 배열이라면 나중에 값을 어떻게 변경해줄 수 있을까?

let relay = BehaviorRelay(value: ["Item 1"])

// 방법 1
var value = relay.value
value.append("Item 2")
value.append("Item 3")

relay.accept(value)

// 방법 2
relay.accept(relay.value + ["Item 2", "Item 3"])

relay.asObservable()
    .subscribe {
        print($0)
    }

value 의 값을 직접 변경해줄 수 없기 때문에 새 변수에 값을 담아서 append 하거나 value 에 저장된 배열과 새 값들을 저장한 배열을 합쳐서 accept 해주는 식으로 저장해주어야 한다.

next(["Item 1", "Item 2", "Item 3"])

BehaviorRelay는 UI에서 사용하기 좋도록 변형된 Subject라고 한다. 더 자세한 차이점 및 사용 방법은 나중에 공부해야 할 듯!

예를 들어 iOS 애플리케이션에서 사용자가 탭을 세 번 하면 세 개의 이벤트가 순차적으로 발생될 것이고, 이 이벤트는 언젠가 종료될 것이다.

하지만 어느 순간 에러가 발생해서 이벤트가 완전히 종료되기 전에 프로그램이 종료된다면..??!! 😱

그래서 이벤트들을 구독하자!!는 것이 Observable의 개념이다. Observable을 구독하면 이벤트들의 값이 변할 때마다 이 사실을 알 수 있게 된다.

Observable 써보기

let observable = Observable.just(1)

let observable2 = Observable.of(1, 2, 3) // Observable<Int>

let observable3 = Observable.of([1, 2, 3]) // Observable<[Int]>

let observable4 = Observable.from([1, 2, 3, 4, 5]) // Observable<[Int]>

• Observable.just() : 하나의 값을 방출할 때 사용
• Observable.of() : 여러 개의 값을 방출할 때 사용. 여기서 observable2 와 observable3 의 자료형 차이 주목!! observable2는 개별적인 값, observable3은 배열을 저장하고 있음
• Observable.from() : 하나의 배열을 받아서 배열의 요소들을 순서대로 방출할 때 사용
  • of() 에 배열을 넣으면 배열 자체가 하나의 항목으로 방출되지만, from() 을 사용하면 배열의 요소들이 순서대로 방출된다!!

Subscription 구현해보기

observable4.subscribe { event in
    print(event)
}

Observable을 구독(subscribe)해서 Observable이 가지고 있는 값에 접근할 수 있다.

subscribe 는 실제 값을 가지고 있는 게 아니라 이벤트를 전달해준다. (이벤트, 다음 이벤트, 다음 값, 그 다음 이벤트, 그 다음 값…)

next(1)
next(2)
next(3)
next(4)
next(5)
completed

위 코드를 실행해보면 다음과 같은 결과가 나온다. 실제 저장된 값이 아닌 이벤트가 출력되는 것을 볼 수 있다!

또한 Observable의 모든 값을 출력하고 나면 completed 라는 이벤트가 발생된다.

전 실제 값을 얻고 싶은데요..? 🤔

observable4.subscribe { event in
    if let element = event.element {
        print(element)
    }
}

element 라는 프로퍼티를 사용하면 실제 값에 접근할 수 있다.

observable.subscribe(onNext: { element in
    print(element)
})

위 방법은 옵셔널 언래핑도 해줘야 하고 귀찮으니까..!!! onNext 를 사용하면 더 쉽게 값에 접근할 수 있다.

// 결과
1
2
3
4
5

Disposing and Terminating

subscription을 생성하면 subscriber가 리턴되는데, 이 subscriber는 특정 시퀀스를 관찰(observe)하고 있다.

언젠가 이 subscriber를 사용하지 않게 되면 이 구독을 해제해주어야 한다. 이를 dispose라고 함! 구독을 해제해주지 않으면 메모리 누수 같은 문제가 발생할 수 있기 때문에 꼭 dispose를 해주어야 한다. 🤯

let subscription = observable.subscribe(onNext: { element in
    print(element)
})

subscription.dispose()

dispose() 라는 메소드를 사용해서 dispose를 해줄 수 있다. 하지만 위와 같이 subscription과 dispose를 따로따로 해주면 어느 시점에 dispose를 해줘야 할지 알기 어렵다.

let disposeBag = DisposeBag()

Observable.of("A", "B", "C")
    .subscribe {
        print($0)
    }
    .disposed(by: disposeBag)

그래서 위처럼 subscribe와 disposed 메소드를 이어서 작성해주면 observable가 종료되는 시점에 dispose가 잘 실행될 수 있다.

여기서 DisposeBag 은 이름 그대로 disposable을 담은 가방이다. Dispose 해야 하는 리소스들이 많으면 일일이 dispose() 메소드를 호출해서 구독 해제를 시켜줘야 하는데 너무 귀찮고 번거로우니까!! DisposeBag에 담아주면 이 DisposeBag이 알아서 dispose() 메소드를 호출해준다.

RxSwift) Dispose /Disposable / DisposeBag 이해하기

create로 Observable를 생성하기

Observable<String>.create { observer in
    observer.onNext("A")
    observer.onCompleted()
    observer.onNext("?")
    return Disposables.create()
}.subscribe(onNext: { print($0) }, onError: { print($0) }, onCompleted: { print("Completed") }, onDisposed: { print("Disposed") })
    .disposed(by: disposeBag)

create 메소드를 사용하면 onNext , onCompleted , onError 같은 메소드를 클로저 안에서 직접 호출할 수 있다.

A
Completed
Disposed

이때 onCompleted나 onError가 호출되면 Observable이 dispose 된다. 그래서 위 코드를 실행해보면 onCompleted 다음에 있는 observer.onNext("?") 는 방출이 되지 않는다.

회사에서 개발하려면 MVVM이랑 RxSwift는 모르면 안 될 것 같아서 RxSwift 공부 시작..!! ^-ㅠ

함수형 프로그래밍이란?

함수형 프로그래밍에서 모든 변수는 상수이기 때문에 값을 변경할 수 없다.

mutable state

mutable state는 누구나 값을 마음대로 변경할 수 있다는 것

⇒ concurrency (동시성) 관련 작업을 할 때 데드락과 같은 문제가 일어날 수 있다.

Immutable state

함수형 프로그래밍에서는 모든 것이 immutable state이기 때문에 값을 변경할 수 없다.

⇒ 데드락 등의 문제도 일어나지 않고, 다른 것들에 대한 의존 관계도 가지지 않는다!

First-class and higher-order function

고차함수(Higher-Order Function, HOF)는 아래 조건 중 하나 이상을 만족하는 함수를 말한다.

• 하나 이상의 함수를 인자로 받는다.
• 함수를 결과로 반환한다.

즉, 함수를 다루는 함수라고 할 수 있음!

Pure Function

• 같은 Input 값을 넣으면 항상 같은 Output 값이 나오는 함수
• 주어진 Input을 가지고 계산하는 것 이외에 프로그램에 다른 영향(side effect)를 미치면 안 된다.

함수형 프로그래밍에서 모든 것은 HOF이고 Pure Function임!

RxSwift란?

테이블 뷰, 탭 바, 정렬/필터 버튼이 있는 앱을 생각해보자

이 앱에는 이미지 다운로드, 탭 등등 다양한 action들이 있을 거고, 이런 액션들은 모두 비동기적으로 접근할 수 있어야 한다. 이때 Notification Center, 델리게이트 패턴, GCD, 클로저를 사용해야 하는데 얘네는 사실 비동기를 위해 완전히 설계된 것이 아님!! 그래서 async 같은 코드들을 더 추가해줘야 한다는 문제가 있다.

RxSwift를 사용하면 비동기 코드를 더욱 간결하고 유지하기 쉽게 작성할 수 있다 😎

다시 한 번 우리 팀의 프로젝트를 간단하게 소개하자면, 사용자가 영어로 말한 것을 STT로 변환하고 이를 기반으로 사용자의 영어 말하기를 분석해주는 앱이다.

프로젝트 개발 단계에서 가장 많이 신경쓰고 고민했던 부분은 앱 내에서 데이터를 저장하고 관리하는 것이었다.

열심히 UI들을 만들고 보니, 사용자 정보도 저장해야 하고, 이미지나 음성 파일들도 저장해야 하고… 생각보다도 데이터를 저장해야 하는 경우가 정말 다양했다.

실제로 iOS에서 데이터를 저장하는 방법은 굉장히 다양하다. 우리 프로젝트에서도 여러 방법을 사용해서 데이터를 저장했었다. 그래서 이 글에서 iOS에서 데이터를 저장하는 방법들을 우리 프로젝트에서 적용한 방식과 함께 소개하고자 한다. 👀

1. 사용자 정보를 저장할 때 - UserDefaults

우리 앱에서는 홈 화면뿐만 아니라 스피킹 분석 화면 등 사용자의 닉네임을 필요로 하는 화면이 여기저기에 있다.

닉네임, 이메일, 자기소개 같은 사용자의 데이터를 저장하기 위해서 UserDefaults 를 사용하였다.

UserDefaults가 뭐지?

UserDefaults는 사용자의 기본 데이터베이스에 대한 인터페이스이다. 키-값 쌍으로 저장되며, 앱을 실행하면 영구적으로 데이터가 저장된다.

주로 간단한 사용자의 정보나 설정 등을 저장할 때 사용된다.

UserDefaults 클래스의 메소드를 사용해서 Bool, Float, Double, Int, String, URL 같은 기본 자료형 데이터를 쉽게 저장할 수 있다.

데이터 저장하기

UserDefaults를 사용하기 위해서는 먼저 UserDefaults의 인스턴스를 생성해주어야 한다.

let defaults = UserDefaults.standard

그 다음 set 메소드를 사용하여 데이터와 데이터에 대한 고유한 키값을 함께 저장해주면 된다.

defaults.set(25, forKey: "Age")
defaults.set(true, forKey: "UseTouchID")
defaults.set(CGFloat.pi, forKey: "Pi")

데이터 가져오기

그럼 UserDefaults에 저장된 데이터는 다시 어떻게 가져올 수 있을까? 데이터를 가져오는 것도 역시 아주 간단하다. 단, 데이터를 읽을 때는 저장된 데이터의 타입과 맞는 메소드를 호출해야 한다.

대표적인 메소드들은 다음과 같다.

• integer(forKey:)
  • key 값이 존재하면 데이터를 반환하고, 그렇지 않으면 0을 반환한다.
• bool(forKey:)
  • key 값이 존재하면 데이터를 반환하고, 그렇지 않으면 false를 반환한다.
• float(forKey:)
  • key 값이 존재하면 데이터를 반환하고, 그렇지 않으면 0.0을 반환한다.
• double(forKey:)
  • key 값이 존재하면 데이터를 반환하고, 그렇지 않으면 0.0을 반환한다.
• object(forKey:)
  • Any? 를 반환하여 원하는 데이터 타입으로 형변환하여 사용할 수 있다.

SpeaKing에서 사용 방법

위 메소드들만 사용해도 문제는 없지만 약간의 불편한 점이 있다.

1. UserDefaults를 사용할 때마다 UserDefaults.standard 에 접근해야 한다.
2. 데이터의 키값을 기억하고 있어야 하고, 일일이 타이핑 해야 한다. 오타가 날 확률도 있다. 🤯

그래서 우리 프로젝트에서는 더 편리하게 UserDefaults에 접근할 수 있도록 UserDefaultsManager 라는 커스텀 클래스를 만들어서 사용하였다.

// UserDefaultsManager.swift

class UserDefaultsManager {
    enum UserDefaultsKeys: String, CaseIterable {
        case email
        case nickname
        case intro
    }

    static func setData<T>(value: T, key: UserDefaultsKeys) {
        let defaults = UserDefaults.standard
        defaults.set(value, forKey: key.rawValue)
    }

    static func getData<T>(type: T.Type, forKey: UserDefaultsKeys) -> T? {
        let defaults = UserDefaults.standard
        let value = defaults.object(forKey: forKey.rawValue) as? T
        return value
    }

    static func removeData(key: UserDefaultsKeys) {
        let defaults = UserDefaults.standard
        defaults.removeObject(forKey: key.rawValue)
    }
}

• 클래스 내에서 UserDefaultsKeys 라는 열거형을 정의하여 필요한 키값을 일일이 타이핑하거나 기억할 필요 없이 편리하게 사용할 수 있도록 하였다.
• 데이터를 생성하고, 읽고, 삭제하는 메소드를 구현하여 부가적인 설정 없이 바로바로 데이터를 관리할 수 있도록 하였다.

UserDefaultsManager 클래스를 사용한 실제 예시는 다음과 같다.

AF.request(url, method: .get, headers: headers)
            .validate()
            .responseDecodable(of: ProfileModel.self) { response in
                switch response.result {
                case .success(let response):
                    UserDefaultsManager.setData(value: response.result.email, key: .email)
                    UserDefaultsManager.setData(value: response.result.nickname, key: .nickname)
                    UserDefaultsManager.setData(value: response.result.intro, key: .intro)
                    completion()
                case .failure(let error):
                    debugPrint(error)
                }
            }

⬆️ 서버에서 사용자 정보를 받아온 후 UserDefaults에 저장

let nickname = UserDefaultsManager.getData(type: String.self, forKey: .nickname) ?? "사용자"

⬆️ 홈 화면에서 사용자의 닉네임을 표시하기 위해 UserDefaults에 저장된 사용자 닉네임 데이터를 가져옴

2. 민감한 정보를 저장할 때 - Keychain

SpeaKing 서버의 API들은 호출할 때 사용자의 JWT 토큰을 request header에 넣어주도록 구현되어 있다. 따라서 앱에서 SpeaKing 서버 API를 호출하기 위해 사용자의 JWT 토큰을 어딘가에 저장해두어야 한다.

🤔 토큰도 그냥 UserDefaults에 저장하면 되지 않을까?

→ Noooo!!!!!!!!

UserDefaults의 데이터들은 property list 문서 (.plist)에 저장된다. 사용자가 특정 툴 등을 사용하면 UserDefaults에 쉽게 접근해서 이 데이터를 확인하고 수정할 수 있다.

따라서 UserDefaults에 사용자의 비밀번호나 토큰 등 민감한 데이터들을 저장하는 것은 보안상 좋은 선택이 아니다.

Keychain?

Keychain은 비밀번호나 암호키 등 작은 개인정보 등을 안전하게 저장할 수 있는 곳이다. keychain service의 API를 사용해서 키체인 항목을 추가, 삭제, 수정할 수 있다.

데이터는 다음과 같은 과정으로 암호화되어 Keychain에 저장된다.

Keychain에 저장할 데이터를 키체인 아이템으로 감싼다. 그리고 아이템의 접근을 제어하고, 아이템을 검색할 수 있도록 공개적으로 볼 수 있는 속성 값들을 함께 정의한다.

Keychain service는 Keychain에서 데이터를 암호화하고 저장한다. 이때 Keychain은 디스크 내에 암호화되어 저장된 데이터베이스이다. 이후 아이템을 찾고 데이터를 복호화할 때에도 keychain service가 사용된다.

Keychain에 데이터 저장하기

이제 Keychain에 실제로 비밀번호를 저장하는 과정을 보겠다.

1. 쿼리 생성하기

var query: [String: Any] = [kSecClass as String: kSecClassInternetPassword,
                            kSecAttrAccount as String: account,
                            kSecAttrServer as String: server,
                            kSecValueData as String: password]

Keychain service를 사용할 때는 항상 먼저 쿼리를 생성해야 한다. 이때 쿼리는 현재 보고 있는 데이터에 대해 설명해주는 역할을 한다.

• kSecClass: keychain service에게 데이터의 종류를 알려주는 역할. 여기서 저장할 키체인 아이템은 인터넷 비밀번호이다.
• kSecAttrAccount: 사용자 이름
• kSecAttrServer: 이 계정 정보를 사용하는 서버의 도메인명
• kSecValueData: 사용자 비밀번호

2. 키체인 아이템 추가하기

위 쿼리를 사용해서 SecItemAdd(_:_:) 메소드를 호출하면 Keychain에 항목이 추가된다.

let status = SecItemAdd(query as CFDictionary, nil)
guard status == errSecSuccess else { throw KeychainError.unhandledError(status: status) }

이 메소드를 호출하면 keychain에 저장이 잘 되었는지 알려주는 결과 코드가 리턴된다. 이를 사용해서 정상적으로 저장되었는지 여부를 확인할 수 있다.

데이터 수정/삭제하기

키체인 항목을 수정하려면 먼저 키체인에 저장된 항목을 찾아야 한다. 따라서 데이터를 찾기 위한 쿼리를 생성한다.

let query: [String: Any] = [kSecClass as String: kSecClassInternetPassword,
                            kSecAttrServer as String: server]

또한 새로 업데이트할 데이터의 내용에 대한 attribute도 함께 작성한다.

let account = credentials.username
let password = credentials.password.data(using: String.Encoding.utf8)!
let attributes: [String: Any] = [kSecAttrAccount as String: account,
                                 kSecValueData as String: password]

이 둘을 가지고 SecItemUpdate(_:_:) 메소드를 호출하면 키체인 아이템을 업데이트 할 수 있다.

let status = SecItemUpdate(query as CFDictionary, attributes as CFDictionary)
guard status != errSecItemNotFound else { throw KeychainError.noPassword }
guard status == errSecSuccess else { throw KeychainError.unhandledError(status: status) }

아이템을 추가할 때와 마찬가지로 메소드의 리턴 값을 사용해서 업데이트 성공 여부를 확인한다.

아이템을 삭제할 때는 검색 쿼리를 가지고 SecItemDelete(_:) 메소드를 호출하면 된다.

let status = SecItemDelete(query as CFDictionary)
guard status == errSecSuccess || status == errSecItemNotFound else { throw KeychainError.unhandledError(status: status) }

SpeaKing에서 사용 방법

Keychain도 마찬가지로 더 쉽게 데이터를 관리하기 위해 KeychainManager 클래스를 만들어서 사용하였다.

// KeychainManager.swift

class KeychainManager {
    enum KeychainError: Error {
        case duplicateEntry
        case noToken
        case unknown(OSStatus)
    }

    static func save(userId: String, token: Data) throws {
        let query: [String: AnyObject] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: userId as AnyObject,
            kSecValueData as String: token as AnyObject,
        ]

        let status = SecItemAdd(
            query as CFDictionary,
            nil
        )

        guard status != errSecDuplicateItem else {
            throw KeychainError.duplicateEntry
        }

        guard status == errSecSuccess else {
            throw KeychainError.unknown(status)
        }
    }

    static func get() -> (userId: String, token: String)? {
        let query: [String: AnyObject] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecReturnAttributes as String: kCFBooleanTrue,
            kSecReturnData as String: kCFBooleanTrue,
            kSecMatchLimit as String: kSecMatchLimitOne
        ]

        var result: CFTypeRef?
        let status = SecItemCopyMatching(query as CFDictionary, &result)

        guard let data = result as? [String: AnyObject],
              let tokenData = data[kSecValueData as String] as? Data,
              let token = String(data: tokenData, encoding: String.Encoding.utf8),
              let userId = data[kSecAttrAccount as String] as? String
        else {
            return nil
        }

        return (userId, token)
    }

    static func delete() throws {
        let query: [String: AnyObject] = [
            kSecClass as String: kSecClassGenericPassword,
        ]

        let status = SecItemDelete(query as CFDictionary)

        guard status != errSecItemNotFound else { throw KeychainError.noToken }
        guard status == errSecSuccess else { throw KeychainError.unknown(status) }

    }
}

우리 앱에서는 서버에서 지정한 사용자 ID와 JWT 토큰을 함께 저장해주었다.

AF.request(url, method: .post, parameters: userInfo, encoder: JSONParameterEncoder.default)
            .validate()
            .responseDecodable(of: LoginResponseModel.self) { response in
                switch response.result {
                case .success(let response):
                    do {
                        try KeychainManager.save(
                            userId: "\(response.result.userId)",
                            token: response.result.token.data(using: .utf8) ?? Data())
                    }
                    catch {
                        print(error)
                    }
                    completion(response)
                case .failure(let error):
                    print(debugPrint(error))
                }
            }

⬆️ 로그인 API 호출 후 반환받은 사용자 ID와 JWT 토큰을 저장하는 예시

// SceneDelegate.swift

if let token = KeychainManager.get()?.token {
    AuthService().authenticateToken(token) { isSuccess in
        if isSuccess {
            print(token)
            navigationController = UINavigationController(rootViewController: HomeViewController(profileService: ProfileService()))
        } else {
            do {
                try KeychainManager.delete()
            } catch {
                debugPrint(error)
            }
            navigationController = UINavigationController(rootViewController: LoginViewController(loginService: AuthService()))
        }
        window.rootViewController = navigationController
        window.makeKeyAndVisible()
        self.window = window
    }
} else {
    navigationController = UINavigationController(rootViewController: LoginViewController(loginService: AuthService()))
    window.rootViewController = navigationController
    window.makeKeyAndVisible()
    self.window = window
}

⬆️ SceneDelegate에서 JWT 토큰 여부에 따른 첫 화면을 설정하는 예시. 유효한 토큰이 Keychain 내에 저장되어 있으면 홈 화면을 띄우고, 그렇지 않으면 로그인 화면을 띄운다.

3. 파일을 저장할 때는 FileManager

우리 앱에서는 간단한 데이터를 넘어서 음성 녹음 파일도 저장해야 한다. iOS 앱은 각자 디바이스 내에 자신들만의 공간을 가지고 있다. 이 공간은 FileManager 클래스를 사용해서 접근할 수 있다.

FileManager를 사용해서 새 파일 저장하기

1. 파일을 저장할 경로에 접근한다.

let paths = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)

위 경로는 사용자의 문서 경로를 의미한다.

2. 해당 경로에 파일을 추가하기 위해 새로운 경로를 추가한다.

let audioFile = path.appendingPathComponent("recording.wav")

appendingPathComponent 메소드를 사용하여 경로를 새롭게 추가한다.

음성 녹음의 경우는 AVAudioRecorder 의 stop() 메소드를 호출하여 선택한 경로에 음성 파일이 저장할 수 있다.

4. 음성 파일의 메타데이터 저장하기 - Realm

음성 파일들을 재생하려면 음성 파일들의 경로를 알고 있어야 한다. 이런 경로들은 어떻게 저장할 수 있을까?

UserDefaults를 사용해서도 경로를 저장할 수는 있다. 하지만 우리 앱에서는 UserDefaults에서는 간단한 사용자 정보만을 저장하고, 음성 파일의 메타데이터는 다른 데이터베이스를 사용하여 저장하기로 하였다.

iOS에서 사용 가능한 로컬 데이터베이스는 Core Data, SQLite, Realm 등 굉장히 다양한데, 우리 프로젝트에서는 Realm을 사용하였다.

Realm이 뭐지?

Realm은 모바일 환경에 최적화된 데이터베이스이다. Realm을 사용하면 iOS 디바이스 내에 데이터를 영구적으로 저장할 수 있다. 추가로 설치해야 한다는 부담이 있지만, Core Data, SQLite보다 작업 속도가 빠르고 사용법이 간단하기 때문에 이를 사용하기로 하였다.

Realm 사용해보기

참고로 Realm을 사용하려면 먼저 Realm을 설치해야 한다. Realm 공식 문서에서 설치 방법을 확인할 수 있다.

1. 데이터 모델 정의하기

Realm을 설치한 다음에는 데이터베이스에 저장하기 위한 모델을 정의한다.

import Foundation
import RealmSwift

class Audio: Object {
    @Persisted var id: String
    @Persisted var url: String = ""

    override class func primaryKey() -> String? {
        return "id"
    }

    convenience init(id: String, url: String) {
        self.init()
        self.id = id
        self.url = url
    }
}

Realm 데이터베이스에 데이터를 저장할 때는 각 데이터마다 고유한 primary key도 함께 저장되어야 한다. 여기서는 id 를 primary key로 사용하기 위해 primaryKey() 메소드를 사용하였다.

2. 데이터 추가하기

let audioData = Audio(id: audioId, url: audioRecorder.url.absoluteString)

try! realm.write {
    realm.add(audioData)
}

⬆️ 음성 파일의 고유 ID와 파일 경로를 저장하는 예시

추가할 데이터에 대한 객체를 만들고 realm의 add() 메소드를 사용하여 데이터를 추가한다. 이때 파일을 쓰는 작업은 realm 의 권한으로 접근해야 한다. 따라서 add() 메소드 호출 전에 realm.write{ } 을 호출한다.

3. 데이터 읽기

realm.objects(Audio.self)

⬆️ Realm에 저장된 모든 Audio 타입의 데이터를 불러오는 예시

비교해보자!

이렇게 iOS에서의 다양한 데이터 저장 방법을 알아보았다.

마지막으로, 다시 한 번 각 방법들을 비교해보자.

• UserDefault vs Keychain
  • 앱을 제거해도 Keychain의 정보는 유지된다. 반면 UserDefaults의 값들을 지워진다.
• Realm vs Core Data
  • Realm은 설치가 쉽고 무제한으로 사용할 수 있다.
  • Realm이 실행 속도가 더 빠르다. 하지만 서드 파티이기 때문에 Core Data보다 앱의 크기가 커진다.

이번 졸업 프로젝트 덕분에 그동안 이름만 들어봤던 다양한 데이터 저장 방법들을 마음껏 활용해볼 수 있어서 좋았다. 또한, 데이터 저장 방식을 고민하고 선택하는 과정도 재미있었다. 프로젝트도 마지막까지 잘 마무리 하고 싶다. 파이팅! 💪

✏️ 참고 자료

https://developer.apple.com/documentation/foundation/userdefaults

https://developer.apple.com/documentation/security/keychain_services/keychain_items

https://developer.apple.com/documentation/security/certificate_key_and_trust_services/keys/storing_keys_in_the_keychain

https://developer.apple.com/documentation/security/keychain_services/keychain_items/updating_and_deleting_keychain_items

https://developer.apple.com/documentation/foundation/filemanager

https://realm.io/realm-swift/

• DFS를 사용해서 현재 단어와 한 글자만 다른 단어를 계속해서 탐색하고, target 단어에 도달하면 탐색을 종료한다.
  • 단어의 길이와 개수의 수가 작기 때문에 완전 탐색을 이용해서 한 글자만 다른 단어들을 찾아도 된다.
• 단어를 한 글자씩 쪼개서 탐색해야 할 줄 알고 고민했었는데.. 입력값의 크기가 작으면 완전 탐색을 사용해도 된다!! 까먹지 말자!!!

import Foundation

func solution(_ n:Int, _ computers:[[Int]]) -> Int {
    var answer = 0
    var graph: [[Int]] = Array(repeating: [], count: n)
    var visited = Array(repeating: false, count: n)

    // 인접 리스트 만들기
    for i in 0..<n {
        for j in 0..<n {
            if computers[i][j] == 1 && i != j {
                graph[i].append(j)
                graph[j].append(i)
            }
        }
    }

    func dfs(_ num: Int) {
        visited[num] = true

        for next in graph[num] {
            if !visited[next] {
                dfs(next)
            }
        }
    }

    for i in 0..<n {
        if !visited[i] {
            answer += 1
            dfs(i)
        }
    }

    return answer
}

인접 행렬을 사용한 풀이

import Foundation

func solution(_ n:Int, _ computers:[[Int]]) -> Int {
    var answer = 0
    var visited = Array(repeating: false, count: n)

    func dfs(_ num: Int) {
        visited[num] = true

        for i in 0..<n {
            if computers[num][i] == 1 && !visited[i] {
                dfs(i)
            }
        }
    }

    for i in 0..<n {
        if !visited[i] {
            answer += 1
            dfs(i)
        }
    }

    return answer
}

이 블로그 풀이를 참고해서 풀었다.

입력 값의 수가 적을 때는 완전탐색을 쓰되, 차례대로 하나씩 쓰면서 규칙을 찾아보자..!

• 왼쪽부터 각 탑들의 높이를 확인한다.
  • 지금까지 봤던 탑 중 가장 오른쪽에 있는 탑보다 높이가 낮다면 다음에 이 탑이 신호를 수신 받을 가능성이 있다.
  • 지금까지 봤던 탑들보다 높이가 더 크다면, 이전에 있던 낮은 탑들은 더 이상 신호를 수신받을 수 없다.
    • 따라서 이 탑보다 높이가 작은 탑들은 스택에서 모두 pop해준다.
• 위 과정을 거친 후 스택의 top에 저장된 탑이 신호를 수신받는 탑이 된다. 만약 스택이 비어있다면 신호를 수신받는 탑이 없는 것이다.
  • 이 값을 정답 변수에 저장한 후 현재 보고 있는 탑을 스택에 push한다.

다이아몬드 등급을 제외한 모든 등급마다 최대로 과금 가능한 금액 (다음 등급 - 1)을 저장한다.

그리고 모든 달마다 현재 등급 - 이전 달 최대 과금 금액 을 계산하고, 이 값을 정답 변수의 값에 더해준다.