In a previous post we showed how to leverage Observables, and especially their strength of composability to ease complicated async tasks. Today we want to take it one step further.
Want to see things in action first?
As a recap, we built a simple Wikipedia search demo consisting of a
WikipediaService to query a JSONP API.
We also built an
App component that uses this service and applies some Rx gymnastics to tame the user input, prevent duplicate requests and deal with out-of-order responses.
Thinking ahead we can refactor our code even further and let our API design leverage from the power of Observables.
Observables = Promises + Events (in a way!)
In a way Observables may be seen as the clever child of Events and Promises. Promises are first class objects that encapsulate the state of an asynchronous operation. But they are for singular operations only. A request is such an operation. You invoke a method, kicking off some async task and get a first class object that eventually will get you to the result of the operation (ignoring error handling for now).
Events on the other hand are for async operations that can continue to emit new values for an infinite duration. But Unfortunately they are traditionally not represented in a format that matches the criteria of a first class object. You can’t just pass an event of clicks around that skips every third click for instance.
Well, with Observables you can. You get the power of first class objects but without the limitations of singularity.
In fact, in a modern .NET language such as F#, which embraces Observables all the way down, every
IEvent<T> inherits from
IObservable<T>. Angular also went down this path and made
Smart service, dumb component
With that in mind: wouldn’t it be actually nice if we could save the component from dealing with all these edge cases? What if we just make the debounce duration configureable but let the rest of the complexity be handled by our
To let code speak we can transform our
WikipediaService into this.
Notice that the service still exposes the previous api as
rawSearch and builds a more clever
search API on top of it.
This dramatically simplifies our
See what happened? We just wire together event streams like lego blocks!
You can play around with the demo right here. Enjoy!
Get updates on new articles and trainings.
Join over 1400 other developers who get our content first.
Exploring Rx Operators: flatMap
Another post in a series of articles to discover the magic of different Rx operators. In this article we like...
Taking advantage of Observables in Angular 2
Angular 2 favors Observables over Promises when it comes to async. In this article we explore some practical advantages for...
Cold vs Hot Observables
In this article we are going to demystify what the term hot vs cold means when it comes to Observables....
Exploring Rx Operators: map
This is the first article that is part of a new series where we take a look at different operators...
Testing Services with Http in Angular 2
Want to learn how to test services in Angular 2 that have an Http dependency? Read more here!
Two-way Data Binding in Angular 2
Two-way data binding was one of the main selling points of Angular. In Angular 2, we can build directives that...