RXSwift demo

//
//  ViewController.swift
//  RXSwiftTest
//
//  Created by wjr on 2018/11/15.
//  Copyright © 2018 wjr. All rights reserved.
//

import UIKit
import RxSwift
import RxCocoa

class NetWork: NSObject {
    
    class func Get(block : @escaping (Int) -> Void) -> Void {
        DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
            block(1);
        }
    }
    
    class func Post(block : @escaping (Int) -> Void) -> Void {
        DispatchQueue.main.asyncAfter(deadline: .now() + 4) {
            block(2);
        }
    }
}

class ViewController: UIViewController {
    let globalScheduler = ConcurrentDispatchQueueScheduler(queue: DispatchQueue.global())
    var disposeBag = DisposeBag();
    var button : UIButton!
    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.
        
        
        button = UIButton(frame: CGRect(x: 0, y: 70, width: 100, height: 100));
        button.setTitle("测试", for: .normal);
        button.backgroundColor = UIColor.red;
        self.view.addSubview(button);
        
        button.rx.tap
            .subscribe(onNext: { [weak self] in
                guard let this = self else {
                    print("出错了")
                    return
                }
                this.button.backgroundColor = UIColor.blue;
                this.testFlatMap();
                this.test()
            })
            .disposed(by: disposeBag)
        
        
        
        
    }
    
    func createObservable() -> Observable<Int>
    {
        return Observable.just(2);
    }
    
    func addFlatMap(a:Int) -> Observable<Int> {
      
        return Observable<Int>.create({ (observer) -> Disposable in
            observer.onNext(a + a)
            observer.onCompleted()
            return Disposables.create();
            }).subscribeOn(globalScheduler).delay(3, scheduler: globalScheduler)
    }
    
    func multiplyFlatMap(a:Int) -> Observable<Int> {
        return Observable<Int>.create{ (observer) -> Disposable in
            observer.onNext(a * a)
            observer.onCompleted()
            return Disposables.create()
        }.subscribeOn(globalScheduler)
    }
    
    
    func testFlatMap() -> Void {
        _ = createObservable().flatMap(addFlatMap)
            .flatMap(multiplyFlatMap)
            .subscribe( onNext:{ num in
                print("结果: \(num)")
            })
    }
    
    //--------------------------------------------------------------
    
    
    func test()
    {
        var students : [Student] = [Student]()
        var student = Student(age:10,sex:"man");
        students.append(student)
        student = Student(age:15,sex:"woman");
        students.append(student);
        student = Student(age:20,sex:"man");
        students.append(student);
        
        let results : [Student] = students.filter{ s -> Bool in
            return s.age <= 15 && s.sex == "man"
        }
        
        
        let observer : Observable<Int> = Observable.create { (observer) -> Disposable in
            
            NetWork.Post(block: { (a : Int) in
                observer.onNext(a)
            })
            
            NetWork.Get(block: { (a : Int) in
                observer.onNext(a)
            })
            
            return Disposables.create()
        }
        
        observer.subscribe(onNext: { (a) in
            print("NetWork Result:\(a)")
        }, onError: {  error in
            print("NetWork Result:onError")
        }, onCompleted: {
            print("NetWork Result:onCompleted")
        }) {
            print("NetWork Result:disposeBag")
        }.disposed(by: disposeBag)
        
       
        NetWorkTest().subscribe(onNext: { (a) in
            print("2 NetWork Result:\(a)")
        }, onError: {  error in
            print("2 NetWork Result:onError")
        }, onCompleted: {
            print("2 NetWork Result:onCompleted")
        }) {
            print("2 NetWork Result:disposeBag")
            }.disposed(by: disposeBag)
        
        
        Observable.zip(
            zipTest1(),
            zipTest2()
            ).subscribe(onNext: { (a:Int,b:Int) in
                
                print("zip 结果: \(a) \(b)")
            }, onError: { error in
                
            }, onCompleted: {
                
            })
            {
                
        }.disposed(by: disposeBag)
        

        
        print("\(results)")
    }
    
    func NetWorkTest() -> Observable<Int> {
        return Observable<Int>.create({ (observer) -> Disposable in
            NetWork.Post(block: { (a : Int) in
                observer.onNext(a)
            })
            
            NetWork.Get(block: { (a : Int) in
                observer.onNext(a)
            })
            
            return Disposables.create()
        })
    }
    
    
    func zipTest1() -> Observable<Int> {
        return Observable<Int>.create({ (observer) -> Disposable in
            NetWork.Get(block: { (a : Int) in
                print("zipTest 1 结果:\(a)")
                observer.onNext(a)
            })
            return Disposables.create();
        })
    }
    
    func zipTest2() -> Observable<Int> {
        return Observable<Int>.create({ (observer) -> Disposable in
            NetWork.Post(block: { (a : Int) in
                print("zipTest 2 结果:\(a)")
                observer.onNext(a)
            })
            return Disposables.create();
        })
    }

}




class Student : NSObject{
    var age : Int = 1
    var sex = "man"
    init(age: Int ,sex: String) {
        self.age = age;
        self.sex = sex;
    }
}