링크 배열에서 중복 요소 제거 (최대2개)

접근1

코드

class Solution {
    func removeDuplicates(_ nums: inout [Int]) -> Int {
        var resultIndex = 1
        var duplicates = 0

        for (index, num) in nums.enumerated() {
            if index == 0 {
                continue
            }
            if num != nums[resultIndex - 1] {
                nums[resultIndex] = num
                resultIndex += 1
                duplicates = 0
            } else {
                duplicates += 1
                if duplicates < 2 {
                    nums[resultIndex] = num
                    resultIndex += 1
                }
            }
        }
        return resultIndex
    }
}

• 불필요한 메모리 발생 (duplicates)

접근2

코드

class Solution {
    func removeDuplicates(_ nums: inout [Int]) -> Int {
        // 배열이 비어있거나 요소가 1개 또는 2개만 있는 경우 바로 반환
        if nums.count <= 2 {
            return nums.count
        }

        // 결과 인덱스를 2로 시작 (처음 두 요소는 항상 유효)
        var resultIndex = 2

        // 세 번째 요소부터 순회
        for i in 2..<nums.count {
            // 현재 요소가 결과 배열의 두 칸 전 요소와 다르면 추가
            if nums[i] != nums[resultIndex - 2] {
                nums[resultIndex] = nums[i]
                resultIndex += 1
            }
        }

        return resultIndex
    }
}

• 이전 요소 대신 최대 2개전 요소 비교

링크 배열에서 중복 요소 제거 (최대2개)

접근1

코드

class Solution {
    func removeDuplicates(_ nums: inout [Int]) -> Int {
        var resultIndex = 1
        var duplicates = 0

        for (index, num) in nums.enumerated() {
            if index == 0 {
                continue
            }
            if num != nums[resultIndex - 1] {
                nums[resultIndex] = num
                resultIndex += 1
                duplicates = 0
            } else {
                duplicates += 1
                if duplicates < 2 {
                    nums[resultIndex] = num
                    resultIndex += 1
                }
            }
        }
        return resultIndex
    }
}

• 불필요한 메모리 발생 (duplicates)

접근2

코드

class Solution {
    func removeDuplicates(_ nums: inout [Int]) -> Int {
        // 배열이 비어있거나 요소가 1개 또는 2개만 있는 경우 바로 반환
        if nums.count <= 2 {
            return nums.count
        }

        // 결과 인덱스를 2로 시작 (처음 두 요소는 항상 유효)
        var resultIndex = 2

        // 세 번째 요소부터 순회
        for i in 2..<nums.count {
            // 현재 요소가 결과 배열의 두 칸 전 요소와 다르면 추가
            if nums[i] != nums[resultIndex - 2] {
                nums[resultIndex] = nums[i]
                resultIndex += 1
            }
        }

        return resultIndex
    }
}

• 이전 요소 대신 최대 2개전 요소 비교

링크 배열에서 특정 요소 제거

접근 1 - 뒤에서부터

• 뒤에서부터 접근
• remove, insert 해야하는 단점

코드 1

class Solution {
    func removeElement(_ nums: inout [Int], _ val: Int) -> Int {
        var length = 0
        for (index, num) in nums.reversed().enumerated() {
            if num != val {
                length += 1
                nums.remove(at: index)
                nums.insert(num, at: 0)
            }
        }
        return length
    }
}

접근 2 - 앞에서부터

• 앞 k 까지만 비교한다고 했으므로 앞에넣어버리기

코드 2

class Solution {
    func removeElement(_ nums: inout [Int], _ val: Int) -> Int {
        var k = 0

        for (index, num) in nums.enumerated() {
            if num != val {
                nums[k] = num
                k += 1
            }
        }

        return k
    }
}

• nums[i] 로 접근보다 nums.enumerated() 접근이 메모리 효율적

링크 MergeSort

앞에서부터

• 작은 수 부터 넣기
• rotation: [1, 3, 0, 0] -> [0, 0, 1, 3]
• 불필요한 rotation

코드 1

  class Solution {
    func merge(_ nums1: inout [Int], _ m: Int, _ nums2: [Int], _ n: Int) {
        if n == .zero { return }

        if m > 0 {
            for _ in 0 ... m - 1 {
                nums1.append(nums1.removeFirst())
            }
        } else {
            nums1 = nums2
        }
        var newNums1Index = 0
        var nums1Index = 0
        var nums2Index = 0

        while nums1Index < m && nums2Index < n {
            if nums1[nums1Index + n] < nums2[nums2Index] {
                nums1[newNums1Index] = nums1[nums1Index + n]
                nums1Index += 1
            } else {
                nums1[newNums1Index] = nums2[nums2Index]
                nums2Index += 1
            }
            newNums1Index += 1
        }

        while newNums1Index < n + m {
            if nums1Index < m {
                nums1[newNums1Index] = nums1[nums1Index + n]
                nums1Index += 1
            } else if nums2Index < n {
                nums1[newNums1Index] = nums2[nums2Index]
                nums2Index += 1
            }
            newNums1Index += 1
        }
    }
}

뒤에서부터

• 제일 큰 수부터 넣기
• 남은 요소 넣을 필요 없음

코드 2

 class Solution {
     func merge(_ nums1: inout [Int], _ m: Int, _ nums2: [Int], _ n: Int) {
         // 뒤에서부터 시작하는 인덱스들
         var i = m - 1      // nums1의 실제 요소 인덱스
         var j = n - 1      // nums2의 인덱스
         var k = m + n - 1  // 결과를 저장할 위치 인덱스

         // 두 배열의 요소를 뒤에서부터 비교하여 큰 값을 nums1의 뒤에서부터 채움
         while i >= 0 && j >= 0 {
             if nums1[i] > nums2[j] {
                 nums1[k] = nums1[i]
                 i -= 1
             } else {
                 nums1[k] = nums2[j]
                 j -= 1
             }
             k -= 1
         }

         // nums2에 남은 요소가 있다면 복사
         while j >= 0 {
             nums1[k] = nums2[j]
             j -= 1
             k -= 1
         }

         // nums1에 남은 요소는 이미 올바른 위치에 있으므로 추가 작업 필요 없음
     }
 }

var test = UITableView() {
    didSet {
    // 내부 코드 안불림     
    }
}

@IBOutlet private weak var tableView: UITableView! { didSet{ //불림 } }

## ReferenceType vs Struct Type
### 1. ReferenceType (ex. Class)
``` swift
class Person {
    var name = "youn"
}
var test: Person = Person() {
    didSet {
      print("didSet called") 
    }
}

• 인스턴스 자체를 변경할 때 불림 test.name = "hi" // 안불림 test = Person() // 불림

  2. Value Type (ex. struct)

  struct Person {
    var name = "youn"
  }
  var test: Person = Person() {
    didSet {
      print("didSet called") 
    }
  }
  

- test.name = "hi" // 불림
## Outlet 의 didSet
- didSet 은 init 타임에 불리지 않음
- outlet 의 경우 초기화 시점에 nil 로 세팅 됨
- 해당 object를 nib 으로부터 가져올 때 다시 세팅, 값을 가짐
- `viewDidLoad` 바로 전에 호출 













[참고](https://sujinnaljin.medium.com/swift-class와-struct에서-didset의-차이-f784e34ea33f)

참고

1. Table View

1. Table Header View 생성

// SHTableHeaderView.swift
final class SHTableHeaderView: UIView {
      /**
        init () 
        setSubViews ()
        setSubViewLayouts() -
      */

    func scrollViewDidScroll(scrollView: UIScrollView) {
        let offsetY = -(scrollView.contentOffset.y + scrollView.contentInset.top)
        imageViewHeight.constant = max(offsetY + scrollView.contentInset.top, scrollView.contentInset.top)
    }
}

setSubViewLayouts

1. 이미지 뷰 단독
   • 이미지의 넓이, centerX, bottom 을 superView(headerView) 와 동일하게 설정
   • 이미지의 높이도 superview 와 동일하게 설정, 별도 변수로 저장
2. 컨테이너 뷰 사용
   • 이미지뷰의 bottom constraint 를 통해 아래로 스크롤 시 작아지는 효과를 더할 수 있음
   • 컨테이너 뷰의 넓이, centerX, 높이를 superView 와 동일하게 설정
   • 이미지뷰의 넓이, 높이, bottom 을 컨테이너 뷰와 동일하게 설정

       func scrollViewDidScroll(scrollView: UIScrollView) {
           let offsetY = -(scrollView.contentOffset.y + scrollView.contentInset.top)
           containerView.clipsToBounds = offsetY <= 0
           imageViewBottom.constant = offsetY >= 0 ? 0 : -offsetY / 2 // 추가
           imageViewHeight.constant = max(offsetY + scrollView.contentInset.top, scrollView.contentInset.top)
       }

2. Table Header View 설정

// ViewController.swift
    private lazy var tableViewHeaderView = SHTableHeaderView(frame: CGRect(x: 0, y: 0, width: view.bounds.width, height: 200))

    @IBOutlet private weak var tableView: UITableView! {
        didSet {
            tableView.tableHeaderView = tableViewHeaderView
        }
    }

3. scrollViewDidScroll 호출

// ViewController.swift
    func scrollViewDidScroll(_ scrollView: UIScrollView) {
        let headerView = self.tableView.tableHeaderView as! SHTableHeaderView
        headerView.scrollViewDidScroll(scrollView: scrollView)
    }

결과

좌 - 이미지뷰를 컨테이너로 한번 더 감쌌을 때 우 - 이미지뷰 단독 설정

Source - (private)

2. Collection View

1. 별개의 View

• 컬렉션 뷰와 별개로 헤더용 뷰 생성, scrollViewDidScroll 에서 레이아웃 조절

2. FlowLayout

class CollectionViewFlowLayout: UICollectionViewFlowLayout {
    override func layoutAttributesForElements(in rect: CGRect) -> [UICollectionViewLayoutAttributes]? {
        let layoutAttributes = super.layoutAttributesForElements(in: rect)

        layoutAttributes?.forEach { attribute in
            if attribute.representedElementKind == UICollectionView.elementKindSectionHeader {
                guard let collectionView = collectionView else { return }
                let contentOffsetY = collectionView.contentOffset.y

                if contentOffsetY < 0 {
                    let width = collectionView.frame.width
                    let height = attribute.frame.height - contentOffsetY
                    attribute.frame = CGRect(x: 0, y: contentOffsetY, width: width, height: height)
                }
            }
        }

        return layoutAttributes
    }

    override func shouldInvalidateLayout(forBoundsChange newBounds: CGRect) -> Bool {
        return true
    }

    // ...

}`

3. Compositional Layout

// MARK: - HeaderView 
final class StretchyCollectionHeaderView: UICollectionReusableView {
    // ...
    // MARK: - Init
    override init(frame: CGRect) {
        super.init(frame: frame)
    }

    required init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
    }

    /// Create Subviews
    private func createViews() {
    }

    /// Setup View Constraints
    func setViewConstraints() {
    }

    /// Notify View of scroll change from container
    public func scrollviewDidScroll(scrollView: UIScrollView) {
        containerViewHeight.constant = scrollView.contentInset.top
        let offsetY = -(scrollView.contentOffset.y + scrollView.contentInset.top)
        containerView.clipsToBounds = offsetY <= 0
        imageViewBottom.constant = offsetY >= 0 ? 0 : -offsetY / 2
        imageViewHeight.constant = max(offsetY + scrollView.contentInset.top, scrollView.contentInset.top)
    }

}

// MARK: - ViewController
func scrollViewDidScroll(_ scrollView: UIScrollView) {
    if let header = homePageCollectionView.supplementaryView(forElementKind: HomePageViewController.sectionHeaderElementKind, at: IndexPath(item: 0, section: 0)) as? StretchyCollectionHeaderView {
                header.scrollviewDidScroll(scrollView: homePageCollectionView)
     }
}

• Datasource 를 관리하는 Controller 에게 웹서비스로부터 응답이 왔을 때 UI에게 변경을 알림
• 에러 발생
• reloadData 를 통해 해결 가능하지만 애니메이션적용 X → 사용자 경험을 해침
• ➡️ Data Controller 와 UI 모두 그들만의 one version of the truth 를 가지고 있음 → truth들이 다를경우 문제 발생
• 즉, *centralized 된 truth 가 없음 *

Diffable DataSource

• iOS13+
• UI state 에 선언적 접근
• snapshot = 현재 UI state 의 truth
• sections 과 items 에 Unique Identifiers 부여, IndexPath ❌
  • 빠른 속도
  • 간결성
  • 잘못된 indexpath 로 crash 날 확률이 줄어듬
  • 자동으로 cell 이 사라지고 생기는 애니메이션이 동작함
• Generic Class (Hashable 준수하는 타입 넣어서 사용)

Example

0. 데이터의 변경
1. 새로운 snapshot 생성
2. snapshot 에 section 과 item(변경된 데이터) 추가
3. datasource 에 해당 snapshot apply

apply(animatingDifferences)

Prior to iOS 15, passing true to animatingDifferences would apply the diff and animate updates in the UI, while passing false was equivalent to calling reloadData(). As of iOS 15, applying a snapshot using this API will always perform a diff 참고

• iOS 15 이전 animationgDifference

  • true : diff
  • false : reload

• iOS 15 이후 : 둘다 diff

참고 https://zeddios.tistory.com/1197 https://ios-development.tistory.com/717 https://developer.apple.com/videos/play/wwdc2019/220/ https://brunch.co.kr/@eunjin3786/245

• Swift 5.5
• Completion Handler 없이도 이를 호출한 곳에 알려줌
• 동시성이랑 다름, 동시성 제공 X

async

• 함수 이름 뒤에 async = 비동기 함수

  func getUser() async thorws -> () {}

• 동시 컨텍스트에서만 실행 가능
  • 다른 async 함수 내에서
  • Task {} // 수동으로 concurrent context 제공

await

• async 함수 호출위해 필요

  let (data, response) = try awiat URLSession.shared.data(for: request)
  // URLSession : iOS 이상에서 나온 async 지원 API

• await > potential suspension pont(잠재적 일시 중단 지점)으로 지정 (무조건 suspend가 아님)
  • Suspend : 해당 스레드가 다른 동작을 수행할 수 있게 제어권 넘김
  • Yielding 스레드 양보
  • suspension point 에서 유지되는 모든 정보는 Heap 에 저장됨
  • await 호출 전 코드를 실행한 스레드가, 멈췄던 작업을 재개하는 동일 스레드라는 보장은 없음

스레드 제어권

✅ sync 함수 호출시

✅ async 함수 호출시

• Suspend > 헤딩 thread 에 대한 control 포기
• System : 스레드를 사용하여 다른 작업 수행, suspend 된 비동기 함수를 계속 실행하는 작업이 가장 중요하다고 판단되는 순간 Resume

Task

• Swift 가 코드를 병렬로 실행하는 기본 메커니즘
• 각 Task 는 다른 Task 와 함께 동시(Concurrent)에 실행할 수 있는 새로운 비동기 컨텍스트 제공
• 명시적으로 생성해야함
• Task 로 생성된 작업은 Background Thread 에서 즉시 실행, await 으로 완료된 값이 돌아올 때까지 기다릴 수 있음
• async 에서 또 다른 async 함수 호출 > 동일한 Task 에서 execute call 수행
• Task - 참고

출처 https://sujinnaljin.medium.com/swift-async-await-concurrency-bd7bcf34e26f

Task

• Task : 비동기적으로 실행할 수있는 작업 단위
• 동시(Concurrent)에 실행할 수 있는 새로운 비동기 컨텍스트 제공 💡동시성 = 비동기 + 병렬
• Task 인스턴스 생성시 해당 Task 가 수행할 작업을 포함하는 클로저 함께 제공
• 생성과 동시에 실행됨
• Task Group 을 만들어서 하위 작업을 추가하는 형식.

func getUser() async -> Data {
    /// get user data
}

func process() async {
   let userData = await getUser()
   let contents = await decode(data: userData)
   print(contents)
}


 Task {
     await self.process() // <!doctype html>~~~~
 }

• async/ await 을 쓰면 가장 바깥은 Task{} 로 감싸야 함
• Task 내 /외 는 별개의 스레드로 동작하며 Task 내에서는 순차적으로 코드가 실행됨
• =>sync code block 내에서 async 코드를 실행할 수 있게 함

출처 https://inuplace.tistory.com/1125

• View Controller, Interactor, Presenter
• 단방향 제어 흐름 💡VIPER: 양방향으로 로직이 순환하기 때문에 순환참조에 의한 메모리 누수 발생
• VIP cycle > interactor에 있는 클로저 기반 비동기 메소드들이 주기적으로 업데이트 제공 💡MVVM 의 Reactiveness 문제해결

Data Flow

*1. View 이벤트 > Interactor 메소드 실행 > 비즈니스로직 실행 2. Interactor : 비즈니스 로직 처리 > Presenter 에게 결과 전송 3. Presenter : Interactor 에서 받은 결과에 대한 UI 처리 *

💡VIPER : 액션에 대한 비즈니스로직을 Presenter 를 통해 Interactor 에게 전달

VIP 주기

1. Use Case 트리거 (ex. viewDidLoad())
2. VC : Interactor 호출
3. Interactor : 비즈니스 로직 수행, Presenter 호출
4. Presenter : VC 호출
5. VC : 화면에 보여줌

출처 https://ios-development.tistory.com/340 https://velog.io/@ssionii/Clean-Swift-a.k.a-VIP-에-대해-아라보자

💡 단계별 특징

1. loadView

• viewController 의 View를 만드는 역할, 해당 프로퍼티가 nil 일 때 호출됨
• view를 로드하거나 생성, 해당 view를 viewController 의 view 프로퍼티에 저장 view.backGroudColor = .clear 의 view
• outlet 과 action 생성, 연결

2. viewDidLoad

• viewController 의 view가 메모리에 로드된 지후에 호출
• viewController 에서 사용할 객체들을 초기화할 때 적합
• view의 bound가 아직 정의되지 않은 상태
• 메모리워닝이 실행되는 경우 중복 호출될 가능성

3. viewWillAppear

• view가 화면에 나타나기 직전에 호출 ( ➡️ viewDidLoad가 호출된다고 화면에 view가 보이는 것이 아님)
• view가 스크린에 보이기 바로 전
• view의 bound는 정의됐지만, 오리엔테이션이 설정되진 않은 상태
• 필드를 숨기거나 보여주기에 적합한 시점
• view가 스크린에 보여질 때마다 호출됨

viewWillLayoutSubviews

• view의bound`가 최종적으로 결정되는 최초 시점
• subView의 레이아웃을 업데이트하기 적합한 시점
• 여러 번 중복으로 호출될 수 있다.
  • 메인뷰의 서브뷰가 로드되는 경우
  • LoadView is only called once: when the view needs to be loaded
  • LayoutSubviews, however, is called once per run loop on any view that has had setNeedsLayout or setNeedsDisplayInRect called on it - this includes whenever a subview has been added to the view, scrolling, resizing, etc. 참고

4. viewDidAppear

• view`가 스크린에 보여진 후에 호출
• 애니메이션을 시작하거나, 외부 API를 불러오기에 적합

5. viewWillDisappear

• view가 사라지기 직전에 호출
• ex. 키보드 숨기기

6. viewDidDisappear

• view가 사라진 직후에 호출
• ex. 구독 해제

  7. viewDidUnload

1. 폰트 파일 import

• .ttf .otf 지원
• .wotf 파일 인식 ❌
• Add to targets 에서 프로젝트 반드시 체크
• 디렉토리 상관없이 인식가능, 원하는 경로에 넣어주기

2. info.plist 추가

• Info.plist > Information Property List > Fonts provided by application
• 파일의 확장자를 포함하여 파일명 정의

🎃 폰트 사용하기

1. 코드

    public enum BalooBhai2Type: String {
        case semibold = "-SemiBold"
        case regular = "Regular"
        case extraBold = "-ExtraBold"
        case bold = "-Bold"
        case medium = "-Medium"
    }

    static func BalooBhai2(_ type: BalooBhai2Type = .regular, size: CGFloat = UIFont.systemFontSize) -> UIFont {
        return UIFont(name: "BalooBhai2\(type.rawValue)", size: size)!
    }
    static func Jua(size: CGFloat = UIFont.systemFontSize) -> UIFont {

        return UIFont(name: "Jua-Regular", size: size)!
    }

    numberLabel.font = UIFont.BalooBhai2(.bold, size: 16.0)

💡 위 방법으로 적용이 안될 때 SceneDelegate.swift의 willConnectTo 함수에

for fontFamily in UIFont.familyNames {
    for fontName in UIFont.fontNames(forFamilyName: fontFamily) {
        print(fontName)
    }
}

실제 파일명과 다른 폰트명이 적용되어 있을 수 있으므로 확인해서 해당 폰트명으로 코드를 작성해주면 됨

2. 스토리보드

옵져버블이 방출하는 모든 요소를 하나의 배열로 방출 (종료전까지 전달 x)

let subject = PublishSubject<Int>()
>
subject
    .toArray()
    .subscribe { print$(0) }
    .disposed(by: disposeBag)
>
subject.onNext(1)   // 방출 X
subject.onNext(2)   // 방출 X
subject.onCompleted() // 방출 success([1,2])

map

옵저버블이 방출하는 요소를 대상으로 함수를 실행하고 결과를 새로운 옵저버블로 리턴

Observable.from([1, 2, 3])
    .map { "age : \($0)" }
    .subscribe { print($0) }
    .disposed(by: disposeBag)

• 파라미터와 다른 타입을 리턴해도 됨 (문자열 > 정수)

flatMap

원본 옵져버블이 항목을 방출하면 flatmap 이 변환연산 시작. 원본 옵져버블이 방출하는 값을 지속적으로 감시, 최신 값 확인. 모든 옵져버블이 방출하는 항목을 모아 최종적으로 하나의 옵져버블 방출

let a = BehaviorSubject(value : 1)
let b = BehaviorSubject(value : 2)

let subject = PublishSubject<BehaviorSubject<Int>>()

subject
    .flatMap { $0.asObservable() }  //subject -> observable
    .subscribe { print($0) } 
    .disposed(by: disposeBag)

subject.onNext(a) 
subject.onNext(b)
-- next(1), next(2)

• 네트워크 요청에 주로 사용
• 최신 값도 다 전달

flatMapFirst, flatMapLatest

• 하나로 병합 X

  flatMapFirst

  처음에 변환된 옵져버블이 방출하는 항목만 구독자로 전달, 나머지는 무시

flatMapLatest

가장 최근에 항목을 방출한 옵져버블을 제외한 나머지는 무시

scan

accumulator function을 활용, 작업 결과 누적 + 중간결과도 알고 싶을 때 사용

Observable.range(start: 1, count: 10)
    .scan(0, accmulator: +)

buffer

특정주기동안 옵져버블이 방출하는 항목 수집, 배열 요소를 하나로 방출

Observable<Int>.interval(.seconds(1), scheduler: MainScheduler.instance)
    .buffer(timeSpan: .seconds(2), count: 3, scheduler: MainScheduler.instance)
    .take(5)

window

옵져버블이 방출하는 항목들을 작은단위의 옵져버블로 분해 > 옵져버블을 방출하는 옵져버블(inner observable) 리턴

Observable<Int>.interval(.seconds(1), scheduler: MainScheduler.instance)
    .window(timeSpan : .seconds(2), count: 3, scheduler: MainScheduler.instance)
    .take(5)
    .subscribe {
        print($0)
        if let obs = $0.element { 
            obs.subscribe { print (" inner : " , $0) }
     }

groupBy

방출되는 요소를 조건에 따라 그룹핑, groupedObesrvable 방출

Observable.from(["hi","hello","ad"])
    .groupBy ( $0.count }
    .flatMap ( $0.toArray()) }
    .subscribe {print($0)}
   })

옵져버블이 방출하는 next 이벤트를 필터링, completed 와 error 이벤트만 구독자로 전달

Observable.from([1,2,3])
    .ignoreElements()
    .subscribe {print($0)}
    .disposed(by: disposeBag)

• 작업의 성공/실패에만 관심 있을 때 사용

elementAt

특정 인덱스에 위치한 요소를 제한적으로 방출, 구독자에게 하나의 요소만 전달되고 나머지는 무시

Observable.from([1,2,3])
    .elementAt(1)
    .subscribe {print($0)}
    .disposed(by: disposeBag)

--- 2 요소만 방출

filter

옵져버블이 방출하는 요소 필터링

Observable.from(Array(1...10)
    .filter { $0.isMultiple(of: 2) }
    .subscribe {print($0)}
    .disposed(by: disposeBag)

--- 구독자로 짝수 요소만 방출

skip, skipwhile, skipUntil

특정 요소를 무시

skip

<!-- 1. Skip --> 
Observable.from([1,2,3])
    .skip(3)
    .subscribe {print($0)}
    .disposed(by: disposeBag)

• 정수를 파라미터로 받음
• 파라미터의 값만큼 요소를 무시한 뒤 이후 방출되는 요소가 포함되는 옵져버블 전달
• 파라미터를 count 로 생각하기

skipWhile

<! -- 2. SkipWhile -->
Observable.from([1,2,3])
    .skipWhile { !$0.isMultiple(of: 2) }
    .subscribe {print($0)}
    .disposed(by: disposeBag)

-- 2, 3  전달

• 파라미터로 받은 클로저가 true 를 리턴하는 동안 방출 무시
• false 리턴 이후에는 더이상 조건 판단 X

skipUntil

<! -- 3. skipUntil -->
let subject = PublishSubject<Int>()
let trigger = PublishSubject<Int>()

subject.skipUntil { trigger }
    .subscribe {print($0)}
    .disposed(by: disposeBag)

// subject 에서 요소 방출
subject.onNext(1)

trigger.onNext(0)

subject.onNext(2)
-- next(2)

• 파라미터로 받은 옵져버블(트리거)가 next 이벤트를 전달하기 전까지 원본 옵져버블 전달 X

take, takeWhile, takeUntil, takeLast

요소 방출 조건 설정

take

Observable.from([1,2,3])
    .take(2)
    .subscribe {print($0)}
    .disposed(by: disposeBag)
-- 1, 2 방출

• 파라미터로 정수를 받음, 해당 숫자 만큼만 요소 방출

takeWhile

Observable.from([1,2,3])
    .takeWhile{ !$0.isMultiple(of: 2) }
    .subscribe {print($0)}
    .disposed(by: disposeBag)
-- 1

• 파라미터로 받은 클로져가 true 인동안 방출
• false 를 리턴하면 더이상 요소 방출 X

takeUntil

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

subject.takeUntil { trigger }
    .subscribe {print($0)}
    .disposed(by: disposeBag)

// subject 에서 요소 방출
subject.onNext(1)

trigger.onNext(0)

subject.onNext(2)
-- next(1)

• • 파라미터로 받은 옵져버블(트리거)가 next 이벤트를 전달하기 전까지 원본 옵져버블에서 next 이벤트 전달

takeLast

let subject = PublishSubject<Int>()

subject.takeLast(2)
    .subscribe {print($0)}
    .disposed(by: disposeBag)

[1,2,3].forEach { subject.onNext($0) }  // 버퍼 2,3

subject.onNext(11) // 버퍼 3, 11

subject.onCompleted() // 요소 방출 
subject.onError(MyError.error) // 버퍼 요소 방출 없이 에러이벤트만 방출

• 정수를 파라미터로 받아 observable 리턴
• 리턴되는 observable 에는 원본 옵져버블 마지막 n 개의 요소 포함
• 구독자로 전달되는 시점이 지연됨

single

원본 옵져버블에서 첫번째 요소만 방출 / 조건과 일치하는 첫번째 요소 방출

Observable.just(1)
    .single()
    .subscribe {print($0)}
    .disposed(by: disposeBag)

-- 1 전달 , completed

Observable.from([1,2,3])
    .single()
    .subscribe {print($0)}
    .disposed(by: disposeBag)

-- 1 전달 , error

• 원본 옵졉버블에서 completed 전달될때까지 기다림

distinctUntilChanged

동일한 항목이 연속적으로 방출되지 않도록 필터링 2개의 요소를 비교하여 이전과 동일하면 방출 X

Observable.from(Array(1...10))
    .distinctUntilChanged()
    .subscribe {print($0)}
    .disposed(by: disposeBag)

debounce, throttle

짧은 시간동안 반복적으로 방출되는 이벤트 제어

debounce

• 정해진 시간동안 이벤트가 방출되지 않으면 마지막 이벤트 방출, 이벤트 방출되면 타이머 초기화
• 검색 기능에 활용

throttle

• 정해진 시간동안 하나의 이벤트만 전달
• 탭 이벤트 처리에 활용

just

하나의 항목을 방출하는 observable 생성

Observable.just(element)

```swift
let disposeBag = DisposeBag()
let element = "hi"
Observable.just(element)  // observable 생성 
/* 구독 */.subscribe{event in print(event)}
.disposed(by: disposeBag)

Observable.just([1, 2, 3])
   .subscribe { event in print(event) }
   .disposed(by: disposeBag)
// >> 1,2,3 방출 

• parameter 로 전달한 요소를 그대로 방출함
• 1개 방출

of

2개 이상의 요소 방출

Observable.of("hi", "bye)
Observable.of([1, 2], [3, 4], [5, 6])
// >> next 이벤트가 요소 수만큼 전달됨! 

• 원하는 수만큼 요소 방출 가능

from

배열로 받은 요소를 하나씩 순서대로 방출

Observable.from([1,2,3,4,5])
//>> next(1)
//   next(2)
//   next(3)
//   next(4)
//   next(5)

range

정수를 지정된 수만큼 방출

Observable.range(start: 1, count: 10) 
// >> next(1), next(2), next(3), next(4), next(5), next(6), next(7), next(8), next(9), next(10)

• param (시작할정수, 방출할 개수)
• 정수만 가능

generate

증가 / 감소 폭을 변경할 수 있는 시퀀스 방출

Observable.generate(initialState: 0, condition: {$0 <= 10}, iterate: {$0 + 2})

• param (시작값, condition(true - 요소방출, false - completed), nil, 변경값)
• 정수로 제한되지 않는 parameter

repeatElement

동일한 요소를 반복적(무한)으로 방출하는 옵져버블 생성

Observable.repeatElement(element)

• 무한정 생성되기 때문에 요소 개수를 정하는 것이 중요함 (take 연산자 등으로 정해줄 것)

  Observable.repeatElement(element)
    .take(7)
    .subscribe {print($0)}
    .disposed(by: disposeBag)
    // >> 7개요소 방출 이후 completed event 방출

  deferred

  특정 조건에 따라 옵져버블 생성

  let factory: Observable<String> = Observable.deferred {
    flag.toggle()
  >    
    if flag {
        return Observable.from(animals) // 배열에 있는 요소들이 개별적으로 방출
    } else {
        return Observable.from(fruits)
    }
  }
  factory
    .subscribe {print($0)}
    .disposed(by: disposeBag)
  >
  factory
    .subscribe {print($0)}
    .disposed(by: disposeBag)
    >
  > // >> animals 요소들의 이벤트 방출 이후 fruits 요소들의 이벤트 방출조금

• param(옵져버블을 return 하는 closure)

create

옵져버블이 동작하는 방식을 직접 구현

Observable<String>.create { (observer) -> Disposable in
    guard let url = URL(string: "https://www.apple.com")
    else { // error
        observer.onError(MyError.error)
        return Disposables.create()
    }
    guard let html = try? String(contentsOf: url, encoding: .utf8) else {  // error
        return Disposables.create()
    }
    >
    observer.onNext(html) // 정상적 문자열 방출
    observer.onCompleted()
    >
    return Disposables.create() // 모든 리소스 정리, 옵져버블 정상적으로 종료
}
.subscribe{print($0)}
.disposed(by: disposeBag)

• param(옵져버블을 파라미터로 받아서 disposable return 하는 클로저)
• disposable 을 return 할때는 Disposables.create() 사용
• 요소를 방출할 때 - onNext(방출할 요소)
• 옵져버블을 종료하기 위한 onError, onCompleted 를 반드시 호출해야 함

empty & error -> next 이벤트를 전달하지 않음, 요소 방출 X

empty

completed event 를 전달하고 종료하는 observable 생성

Observable<Void>.empty()
// >> completed()

• param X
• 옵져버가 아무 동작없이 종료해야 할 때 활용

error

error event 를 전달하고 종료하는 observable 생성

enum MyError: Error {
   case error
}
>
Observable<Void>.error(MyError.error)
// >> error(error)

• param (error)
• 에러 처리활 때 활용

observable 인 동시에 observer subject 로 전달되는 이벤트를 observer 에게 전달

Publish Subject

이벤트가 전달 되는 즉시 구독자에게 전달하는 subject -> subject 가 최초로 생성되는 시점과 구독이 시작되는 시점 사이에 생성되는 이벤트는 사라짐 -> 이벤트가 사라지지 않게 하려면 다른 observable 사용 필요

let subject = PublishSubject<String>()  //문자열이 포함된 nextevent 를 받아서 다른 observer 에게
// subject 생성시점에는 내부에 아무 이벤트가 저장되어 있지 않음

/*1. subject 이벤트 전달 이후 구독자 생성*/
subject.onNext("hello")

let o1 = subject.subscribe( {print(">> 1", $0)})
o1.disposed(by: disposeBag)
// 출력 X
// 구독이후에 전달되는 새로운 이벤트만 구독자로 전달되기 때문에
// 구독자가 구독시작전 전달되었던 next 이벤트는 오저버로 전달 X

/*1-2. 구독자 생성 이후 전달된 이벤트*/
subject.onNext("RxSwift")
// 출력됨

/*2. 구독자 추가*/
let o2 = subject.subscribe{print(">> 2", $0)}
subject.onNext("Subject")
// o1 -> subject, RxSwift 전달
// o2 -> subject 만 전달

/*3. 완료*/
subject.onCompleted()     또는
subject.onError(MyError.error)
// o1, o2 에게 이벤트 전달

/*3-1.*/ 새로운 구독자 추가 (완료된 이후에)
let o3 = subject.subscribe{print(">> 3", $0)}
o3.disposed(by: disposeBag)
// o3 에게는 next 없이 완료이벤트만 전달

Behavior Subject

가장 최근 이벤트를 저장하고 새로운 구독자에게 전달

생성

// publish
let p = PublishSubject<Int>() // 비어있는 생성자

// behavior
let b = BehaviorSubject<Int>(value: 0) // 값 전달

• 내부에 next 이벤트가 하나 만들어짐
• 구독자가 생성되면 저장되어 있던 next 이벤트가 바로 전달됨
• 새로운 next event 가 전달되면 새로운 이벤트로 교체됨
• 가장 최근의 next event 전달
• 최신 이벤트를 제외한 나머지 이벤트는 사라짐!

Replay Subject

지정된 수만큼 이벤트를 저장

• 지정된 버퍼크기 만큼 최신 이벤트 저장, 새로운 구독자에게 전달
• 버퍼 : 메모리에 저장, 메모리 사용량에 유의해야 함

let rs = ReplaySubject<Int>.create(bufferSize: 3) // 3개의 next 이벤트전달가능

(1...10).forEach{rs.onNext($0)}

rs.subscribe{print("observer 1 >> ", $0)}.disposed(by: disposeBag)
rs.onNext(11)

Async Subject

completed 이벤트가 전달되는 시점에 가장 최근 next 이벤트 1개를 구독자로 전달

• 이벤트가 전달됐을때, 즉시 구독자로 그 이벤트를 전달하는 다른 subject 들과 달리 completed event 가 전달되기 전까지 구독자로 이벤트를 전달하지 않음
• error 이벤트가 전달됐을 경우 next 이벤트 전달없이 error 이벤트만 전달되고 종료됨

let sub = AsyncSubject<Int>()

sub
    .subscribe{print($0)}
    .disposed(by: bag)

sub.onNext(1)
sub.onNext(2)

sub.onCompleted()

/**-출력-/
next(2)
completed

Relay

subject 를 래핑, 소스로 부터 next 이벤트를 받아서 다른 구독자로 전달

• publish relay, behavior relay

• next 이벤트만 전달받고 전달함

• disposed 전까지 계속 이벤트 전달 ,종료 X

• 주로 UI 처리에 활용

• RxCocoa framework 에 의해 제공

• onnext 대신 accept

publish relay

• 빈생성자로 생성

behavior relay

• value 로 이벤트 값 받아올 수 있음

code

import RxCocoa

let bag = DisposeBag()
let pr = PublishRelay<Int>()
let br = BehaviorRelay<Int>(value: 1)

pr.subscribe{ print("1: \($0)")}.disposed(by: bag)

pr.accept(1)

Example

```swift let bag = DisposeBag()

Observable.from([1, 2, 3, 4, 5, 6, 7, 8, 9]) .take(5) // 처음 5개의 요소만 전달 .filter { $0.isMultiple(of: 2) } .subscribe { print($0) } .disposed(by: bag) > --- 결과 --- next(2) next(4) completed

• 대부분의 연산자는 observable 상에서 동작하고 observable 을 return => 2개 이상의 연산자를 연달아서 호출 가능
• subscribe 앞에 추가 -> 구독자로 전달되는 최종데이터가 내가 원하는 데이터가 됨
• 호출순서에 따라 다른결과를 만들어낼 수 있으므로 호출순서에 유의

• observable 이 전달하는 이벤트가 X
• 리소스가 해제되는 시점에 자동으로 호출됨
• 가능하다면 리소스 정리를 직접 해주는게 좋음

let sub1 = Observable.from([1,2,3])
    .subscribe(onNext: {elem in
        print("Next", elem)
    },onError: {
        error in print("Error", error)
    }, onCompleted: {
        print("Completed")
    }, onDisposed: {
        print("Disposed")
    })

리소스 해제

1. 직접 해제 하기

sub1.dispose()

2. DisposeBag 사용

var bag = DisposeBag()
Observable.from([1, 2, 3])
    .subscribe(
        print($0)
    }.disposed(by: bag)

• 1번 방법보다 더 권장됨
• subscribe 가 return 하는 disposable 이 disposeBag 에 추가됨
• disposeBag 이 해제되는 시점에 함께 해지됨

* 임의의 내가 원하는 시점에 해제하려면?

1. swift bag = DisposeBag() 호출 => 이전에 있던 disposeBag 이 해제됨
2. dispose() 호출

   /* 1씩 증가하는 정수를 1초마다 방출*/
   let sub2 = Observable<Int>.interval(.seconds(1),
    scheduler: MainScheduler.instance)
    .subscribe(onNext: {elem in
        print("Next", elem)
    },onError: { error in
        print("Error", error)
    }, onCompleted: {
        print("Completed")
    }, onDisposed: {
        print("Disposed")
    })
   /*3초 뒤에 dispose*/
   DispatchQueue.main.asyncAfter(deadline: .now() + 3) {sub2.dispose()}

   • next 다음에 completed 메소드가 실행되지 않음
   • 때문에 권장되지 않음 => takeuntil 과 같은 연산자 사용

• 전달하는 이벤트
  • error (notification)
  • completed (notification)
  • next (emmission)
• observerbles - 이벤트의 순서 정의
• observer - subscriber

observable 생성

create 연산자 사용

let o1 = Observable <Int>.create{ (obs) -> Disposable in
    obs.on(next(0)) // 0이 저장되어 있는 이벤트가 구독자로 전달
    obs.onNext(1)
    obs.onCompleted() // observable 종료
    return Disposables.create() // 메모리 정리
 }

from 연산자 사용

 Observable.from ([0, 1])

• param인 배열에 있는 요소를 순서대로 방출한 뒤 completed event 전달

이벤트 전달

• 전달 시점
  • observer가 구독을 하는 시점
  • observer는 동시에 2개의 event 를 처리하지 않는다

/** 1. */
o1.subscribe{
  print($0)
  if let eme = $0.element { // event 에 전달된 값은 optional 임 
     print(eme)
  }
}
/** 2. */
o1.subscribe(onNext: {elem in print(elem)})

정리

Observable.subscribe // 옵져버블'을' 구독한다
Observer.onNext // 옵져버'에' 이벤트를 전달한다
Observable.create{(observer) in 
    observer.onNext()
    return Disposable.create()
    }
 // 구독되기 시작하면 이벤트를 발생시켜 observer 에 전달하기 시작한다. 

• ReactiveX 라이브러리를 swift 언어로 구현한 것
• RxSwift Github

  사용 이유

• 단순하고 직관적인 코드 작성
• 깔끔한 비동기 코드
• 참고