Why used the RxSwift

Why(referring to :https://github.com/ReactiveX/RxSwift/blob/master/Documentation/Why.md)

Rx enables building apps in a decalrative way.

Bindings

Observable.combinelatest(firstName.rx.text, lastName.rx.text){ 0+“”+ 1}

.map{ “Greetings, (0)”}  

            .bind(to: greetingLabel.rx.text)  

This Also works with UITableViews and UICollectionViews.  

viewModel  

      .rows  

      .bind(to: resultsTableView.rx.items(cellIdentifier: “cell”, cellType:WikipediaSearchCell.self)){ (_, viewModel, cell) in  

               cell.title = viewModel.title  

               cell.url = viewModel.url  

}  

.disposed(by: disposeBag)  

Official suggestion is to always use .disposed(by: disposeBag) even though that’s not necessary for simple bindings.  

Retries  

It would be great if APIs wouldn’t fail,but unfortunately they do. Let’s say there is an API method:  

func doSomethingIncredible(forWho: String) throws -> IncredibleThing  

Ideally,you would want to capture the essence of retrying, and to be able to apply it to any operation.  

This is how you can do simple retries with Rx  

doSomethingIncredible(“me”)  

            .retry(3)  

You can also easily creat custom retry operators.  

Delegate  

Instead of doing the tedious and non-expressive:  

public func scrollViewDidScroll(scrollView: UIScrollView) { [weak self]// what scroll view is this bound to?  

           self?.leftPositionConstraint.constant = scrollView.contentOffset.x  

}  

…write  

self.resultsTableView  

       .rx.contentOffset  

       .map {0.x }

.bind(to: self.leftPositionConstraint.rx.constant)

and

- (void) observeValueForKeyPath:(NSString )keyPath ofObject:(id)object change:(NSDictionary )change context:(void *)context

use rx.observe and rx.observeWeakly

this is how they can be used:

view.rx.observe(CGRect.self,”frame”)

.subscribe(onNext: { frame in

print(“Got new frame (frame)”)

})

.disposed(by: disposeBag)

or

someSusipiciousViewController

.rx.observeWeakly(Bool.self, “behavingOK”)

.subscribe(onNext: { behavingOk in

print(“Cats can purr? (behavingOk)”)

})

.disposed(by: disposeBag)

Insteading of using

@available(iOS 4.0, *)

public func addObserverForName(name: String?, object obj: AnyObject?, queue: NSOperationQueue?, usingBlock block: (NSNotification) -> Void) -> NSObjectProtocol

…just write

NotificationCenter.defaul

.rx.notification(NSNotification.name.UITextViewTextDidBeginEditing, object: myTextView)

.map{ }

searchTextField.rx.text

.throttle(0.3, scheduler: MainScheduler.instance)

.distincUntilChanged()

.flatMapLatest { query in

API.getSearchResults(query)

.retry(3)

.startWith([])//clears results on new search term

.catchErrorJustReturn([])

}

.subscribe(onNext: { results in

//bind to ui

})

.disposed(by: disposeBag)

//this is a conceptual solution

let imageSubsription = imageURLs

.throttle(0.2, scheduler: MainScheduler.instance)

.flatMapLatest { imageURL in

API.fetchImage(imageURL)

}

.obseveOn(operationScheduler)

.map { imageData in

return decodeAndBlurImage(imageData)

}

.observeOn(MainScheduler.instance)

.subscribe(onNext: { blurredImage in

imageView.image = blurredImage

})

.disposed(by: reuseDisposeBag)

let userRequest: Observable = API.getUser(“me”)

let friendsRequest: Observable<[Friend]> = API.getFriends(“me”)

Observable.zip(userRequest, friendsRequest) { users, friends in

return(user, friends)

}

.subscribe(onNext: { user, friends in

// bind them to the user interface

})

.disposed(by: disposeBag)

let userRequest: Observable = API.getUser(“me”)

let friendsRequest: Observable<[Friend]> = API.getFriends(“me”)

Observable.zip(userRequest, friendsRequest) { user, friends in

return (user, friends)

}

.observeOn(MainScheduler.instance)

.subscribe(onNext: {user, friends in

//bind them to the user interface

})

.disposed(by: disposeBag)

extension Reative where Base: URLSession {

public func response(request: URLRequest)) -> Observable<(Data, HTTPURLResponse)> {

return Observable.create { observer in

let task = self.base.dataTask(wih: request)) {(data, reponse,error) in

guard let reponse = reponse, let data = data else {

observer.on(.error(error ?? RxCocoaURLError.unknown))

return

}

guard let httpResponse = response as? HTTPURLResponse else {

observer.on(.error(RxCocoaURLError.nonHttpResponse(reponse: response)))

return

}

observer.on(.next(data, httpResponse))

observer.on(.completed)

}

task.resume()

return Disposables.create(with: task.cancel)

}

}

}