[SwiftUI 开发] Combine使用方法

 这片主要介绍Combine基本用法

 1. Just

    let myPublisher = Just("1")
    
    let myScriber = Subscribers.Sink<String, Never> { completion in
        if completion == .finished {
            print("myScriber1 Finished")
        } else {
            print("myScriber1 Failure")
        }
    } receiveValue: { value in
        print(value)
    }
 
    myPublisher.subscribe(myScriber)
 
 
    打印结果：
    // 1
    // myScriber1 Finished

1. Just发布一个Publisher，just只会发送一次，发送完成结束本次订阅
2. Sink订阅者，订阅了Just，这个Sink后面是个泛型

        第一参数是参数类型，方法Just发送的是String类型，所以咱们观察者类型要保持一致

        第二参数是错误类型，例子中参数是Never,就是不会报错，下面的例子中会介绍其它的
3.  Sink中有两个闭包 (receiveCompletion和receiveValue)

        receiveCompletion: 结束观察订阅
        receiveValue: 订阅结果

extension Publisher { 
    public func sink(receiveCompletion: @escaping ((Subscribers.Completion<Self.Failure>) -> Void), receiveValue: @escaping ((Self.Output) -> Void)) -> AnyCancellable
}
 
extension Publisher where Self.Failure == Never {
    public func sink(receiveValue: @escaping ((Self.Output) -> Void)) -> AnyCancellable
}
 
// 如果不需要receiveCompletion，我们可以用Self.Failure == Never方法

2. Publishers

Publishers处于pipline的最上游，它的主要作用是发送数据

    let arr = 0...3
    arr.publisher.sink { value in
        print(value)
    }
 
    打印结果：
    // 0
    // 1
    // 2
    // 3

Combine给了我们一个简便的写法

适用环境，比如我们在意的是直接拿到结果，不需要中间的Operator
 

3. assign

    class Person {
        var age: Int = 0 {
            didSet {
                print("age: \(age)")
            }
        }
    }
    
    
    let person = Person()
    let range = 0...2
    range.publisher.assign(to: \.age, on: person)
 
    打印结果：
    // 0
    // 1
    // 2

keyPath

将发布者中的每个元素分配给对象上的属性。

使用Publisher/assign(to:on:)订阅者，当你想在每次发行者产生一个值时设置给定的属性。

在这个例子中，Publisher/assign(to:on:) 在person的实例上设置age属性的值

第二种用法

    class Person {
        @Published var age: Int = 0
    }
    
    
    let person = Person()
    Just(1).assign(to: &person.$age)
    print(person.age) 
 
    打印结果： 
    // 1

熟悉SwiftUI的朋友看起来比较喜欢，属性包装器的写法

** assign 都是 Self.Failure == Never

4. Future

    class Person {
        var age: Int = 0
    }
    
    let futurePubliser = Future<Int ,Never> { promise in
        print("异步操作")
        promise(.success(2))
        
    }
    
    let subscribers = Subscribers.Sink<Int,Never> { completion in
        if completion == .finished {
            print("Finished")
        } else {
            print("Failure")
        }
    } receiveValue: { value in
        print(value)
    }
 
    futurePubliser.subscribe(subscribers) 
    
    let person = Person()
    futurePubliser.assign(to: \.age, on: person)
 
    打印结果：
    // 异步操作
    // 2
    // Finished

Future和Just类似，区别在于：

        Just直接发送参数, Failure = Never
        Futrre是调用一个异步闭包，可以选择闭包结束时发送数据, Failure = Error

5. Operator

    let myPubliser2 = Just("1")
    
    let tansValue = Publishers.Map<Just<String>, Int>(upstream: myPubliser2) { value in
        return Int(value) ?? 0
    }
    
    let myScriber2 = Subscribers.Sink<Int,Never>  { completion in
        if completion == .finished {
            print("Finished")
        } else {
            print("Failure")
        }
    } receiveValue: { value in
        print(value)
    }
 
    tansValue.subscribe(myScriber2)
 
    打印结果：
    // 1
    // Finished

使用提供的闭包转换来自上游发布者的所有元素的发布者

Operator处于pipline的中游，它的主要作用是接收数据，处理数据，再发送数据

此发布者可能发布的错误类型, 此发布者使用其上游发布者的失败类型。

6. Operator2

    _ = Just(1).filter({ value in
        return value < 10
    }).sink(receiveCompletion: { completion in
        if completion == .finished {
            print("Finished")
        } else {
            print("Failure")
        }
    }, receiveValue: { value in
        print(value)
    })
 
    打印结果：
    // 1
    // Finished

extension Just {
    public func filter(_ isIncluded: (Output) -> Bool) -> Optional<Output>.Publisher
}

注意这个filter，它不是高阶函数里的那个filter，虽然它们功能都是数据过滤。但它属于Just, 它返回的是Publisher

7. CurrentValueSubject  send

    // 定义一个错误类型
    enum myErrors: Error {
        case wrongValue
    }
 
    // 定义一个publiser
    let publiser = CurrentValueSubject<String, myErrors>("10")
    
 
    // 第一个接收者
    publiser.filter {
        return $0.count < 2
    }.sink { completion in
        if completion == .failure(myErrors.wrongValue) {
            print("Scriber1 Finished")
        } else {
            print("Scriber1: \(completion)")
        }
    } receiveValue: { value in
        print("Scriber1: \(value)")
    }
    
    // 第二个接收者
    let myScriber = Subscribers.Sink<String,myErrors> { completion in
        if completion == .failure(myErrors.wrongValue) {
            print("Scriber2 Finished")
        } else {
            print("Scriber2: \(completion)")
        }
    } receiveValue: { value in
        print("Scriber2: \(value)")
    }
    
    publiser.subscribe(myScriber)
    
    
    // 开始发送数据
    publiser.send("1")
    publiser.send("11")
    publiser.send(completion: .failure(.wrongValue))
    publiser.send("over")
 
    打印结果：
    // Scriber2: 10
    // Scriber1: 1
    // Scriber2: 1
    // Scriber2: 11
    // Scriber1 Finished
    // Scriber2 Finished

CurrentValueSubject可以订阅一个publiser, 它可以多点用send发布数据，直到发送completion结束观察

Failure = Error

8. CurrentValueSubject  Operator

    let subject1: CurrentValueSubject<Int,myErrors> = .init(10)
    let subject2: CurrentValueSubject<Int,myErrors> = .init(20)
 
    // 数据流 subject1 -> subject2
    _ = subject1.subscribe(subject2)
 
    let myScriber = Subscribers.Sink<Int,myErrors> { completion in
        if completion == .finished {
            print("Finished")
        } else {
            print("Failure")
        }
    } receiveValue: { value in
        print(value)
    }
    
    subject2.receive(subscriber: myScriber)
    
    subject1.send(1)
    subject1.send(2)
    subject2.send(3)
    subject1.send(completion: .failure(.wrongValue))
    subject1.send(11)
    subject2.send(12)
 
    打印结果：
    // 10
    // 1
    // 2
    // 3
    // Failure

CurrentValueSubject也可以当作Operator适用
例子中subject1处于pipline的上游，subject2处于pipline的中游

Failure = Error

subject1.send(1)      //  subject1 -> subject2 ->Scriber
subject1.send(2)      //  subject1 -> subject2 ->Scriber
subject2.send(3)      //  subject2 ->Scriber
subject1.send(completion: .failure(.wrongValue))   //  结束myScriber的响应者

9. PassthroughSubject

    let subject1: PassthroughSubject<Int,myErrors> = PassthroughSubject()
    let subject2: PassthroughSubject<Int,myErrors> = PassthroughSubject()
 
    // 数据流 subject1 -> subject2
    let cancelable = subject1.subscribe(subject2)
 
    let myScriber = Subscribers.Sink<Int,myErrors> { completion in
        if completion == .finished {
            print("Finished")
        } else {
            print("Failure")
        }
    } receiveValue: { value in
        print(value)
    }
    
    subject2.receive(subscriber: myScriber)
    
    subject1.send(1)
    subject1.send(2)
    subject2.send(3)
    subject1.send(completion: .failure(.wrongValue))
    subject1.send(11)
    subject2.send(12)
 
    打印结果： 
    // 1
    // 2
    // 3
    // Failure

PassthroughSubject和CurrentValueSubject功能类似

区别在于

        CurrentValueSubject： 有个初始化值

        PassthroughSubject：没有初始化值