Previous articles in this series include:. Basic Terms 2. Operators map, filter, and reduce 3. Using Observable. Using RxJS Subject. In some cases, you need to treat each item emitted by an observable as another observable. In other words, the outer observable emits the inner observables. Does it mean that we need to write nested subscribe calls one for the outer observable and another for the inner one?
The flatMap operator takes each item from the outer observable and auto-subscribes to it. Some operators are not explained well in RxJS documentation, and we recommend you to refer to the general ReaciveX reactive extensions documentation for clarification.
This documentation includes the following marble diagram:. As you see, the flatMap operator takes an emitted item from the outer observable the circle and unwraps its content the inner observable of diamonds into the flattened output observable stream. The flatMap operator merges the emissions of the inner observables so their items may interleave.
The following code listing has an observable that emits drinks, but this time it emits not individual drinks, but palettes. The first palette has beers and the second — soft drinks. Each palette is observable. We want to turn these two palettes into an output observable with individual beverages. Creating an async observable from beers 2. Creating an async observable from soft drinks 3. Emitting the beers observable with next 4. Emitting the soft drinks observable with next 5.
Unloading drinks from pallets into a merged observable 6. Subscribing to the merged observable. To see it in CodePen visit this link. Are there any other uses of the flatMap operator besides unloading palettes of drinks? In Angular, HTTP requests return observables and without flatMap this could be done it a bad style with nested subscribe calls:. The method httpClient. Since a flatMap is a special case of mapyou can specify a transforming function while flattening the observables into a common stream.
In the above example, we transform the value customer into a function call httpClient. This example is written in TypeScript and it uses two Subject instances:. Using flatMap allows you to write just one subscribe call, which will be receiving the inner observables from each trader in one stream. Declare the Subject for traders 2. Each trader has its own Subject for orders 3.
Subscribe to RSS
Starting with the outer observable traders 4. Extracting the inner observable from each Trader instance 5. The function subscribe receives a stream of orders. Remember, a Subject has both observable and observer.Clear examples, explanations, and resources for RxJS. Offering a powerful, functional approach for dealing with events and with integration points into a growing number of frameworks, libraries, and utilities, the case for learning Rx has never been more appealing.
Couple this with the ability to utilize your knowledge across nearly any languagehaving a solid grasp on reactive programming and what it can offer seems like a no-brainer. Learning RxJS and reactive programming is hard. There's the multitude of concepts, large API surface, and fundamental shift in mindset from an imperative to declarative style. This site focuses on making these concepts approachable, the examples clear and easy to explore, and features references throughout to the best RxJS related material on the web.
The goal is to supplement the official docs and pre-existing learning material while offering a new, fresh perspective to clear any hurdles and tackle the pain points. Learning Rx may be difficult but it is certainly worth the effort!
Start getting familiar with all the key concepts needed to be productive with our RxJS Primer! Operators are the horse-power behind observables, providing an elegant, declarative solution to complex asynchronous tasks. This section contains all RxJS operatorsincluded with clear, executable examples. Links to additional resources and recipes for each operator are also provided, when applicable.
Operator Categories. A Subject is a special type of Observable which shares a single execution path among observers. Without a solid base knowledge of how Observables work behind the scenes, it's easy for much of RxJS to feel like 'magic'. This section helps solidify the major concepts needed to feel comfortable with reactive programming and Observables. Recipes for common use-cases and interesting solutions with RxJS. New to RxJS and reactive programming? In addition to the content found on this site, these excellent resources will help jump start your learning experience!
Interested in RxJS 4? Check out Denis Stoyanov's excellent eBook! All references included in this GitBook are resources, both free and paid, that helped me tremendously while learning RxJS. If you come across an article or video that you think should be included, please use the edit this page link in the top menu and submit a pull request.
Your feedback is appreciated!This operator is best used when you wish to flatten an inner observable but want to manually control the number of inner subscriptions. For instance, when using switchMap each inner subscription is completed when the source emits, allowing only one active inner subscription. In contrast, mergeMap allows for multiple inner subscriptions to be active at a time.
Because of this, one of the most common use-case for mergeMap is requests that should not be canceled, think writes rather than reads. Note that if order must be maintained concatMap is a better option. Be aware that because mergeMap maintains multiple active inner subscriptions at once it's possible to create a memory leak through long-lived inner subscriptions. A basic example would be if you were mapping to an observable with an inner timer, or a stream of dom events. In these cases, if you still wish to utilize mergeMap you may want to take advantage of another operator to manage the completion of the inner subscription, think take or takeUntil.
You can also limit the number of active inner subscriptions at a time with the concurrent parameter, seen in example 5. Example 1: mergeMap simulating save of click locations. Example 2: mergeMap with ajax observable. Example 3: mergeMap with promise could also use from to convert to observable. Example 4: mergeMap with resultSelector. Example 5: mergeMap with concurrent value. Ben Lesh. Learn RxJS. Error Handling. Full Listing.
Map vs FlatMap
Going back to your example, you have a function which produces promises from an url string. So T' : stringand T : promise. If you have an observable which is produced by an another observable you can not filter, reduce, or map it directly because you have an Observable not the data. If you produce an observable choose flatMap over map; then you are okay. Check out the scenario below where get "posts" returns an Observable that is "flattened" by flatMap.
I swear this definition still confuses me but I am going to explain it in the simplest way which is by using an example. Our Situation : we have an observable which returns data simple URL that we are going to use to make an HTTP call that will return an observable containing the data we need so you can visualize the situation like this:.
When your function returns an Observable, it is not returning a stream, but an instance of Observable. The flatMap operator simply maps that instance to a stream. That is the behaviour of flatMap when compared to map : Execute the given function and flatten the resulting object into a stream. I am not stupid but had to read this 10 times and still don't get it. When I read the code snippet :. Then the merge operator becomes clear to, it does the flattening without the mapping.
Why not calling it mergeMap? It seems there is also an Alias mergeMap with that name for flatMap. Learn more. Why do we need to use flatMap? Ask Question. Asked 4 years, 11 months ago. Active 1 month ago.flatMap Demo
Viewed k times. That's why I recommend instead running simple examples like this one, or more complex examples in the rxjs repo and adding ". I think if flatMap would have been named mapThenFlattenthen it would be less confusing. Active Oldest Votes.The FlatMap operator transforms an Observable by applying a function that you specify to each item emitted by the source Observable, where that function returns an Observable that itself emits items.
FlatMap then merges the emissions of these resulting Observables, emitting these merged results as its own sequence. This method is useful, for example, when you have an Observable that emits a series of items that themselves have Observable members or are in other ways transformable into Observables, so that you can create a new Observable that emits the complete collection of items emitted by the sub-Observables of these items.
Note that FlatMap merges the emissions of these Observables, so that they may interleave. In several of the language-specific implementations there is also an operator that does not interleave the emissions from the transformed Observables, but instead emits these emissions in strict order, often called ConcatMap or something similar.
Note that if any of the individual Observables mapped to the items from the source Observable by flatMap aborts by invoking onErrorthe Observable produced by flatMap will itself immediately abort and invoke onError. A version of this variant of the operator still in Beta as of this writing takes an additional int parameter. This parameter sets the maximum number of concurrent subscriptions that flatMap will attempt to have to the Observables that the items emitted by the source Observable map to.
When it reaches this maximum number, it will wait for one of those Observables to terminate before subscribing to another. Another version of flatMap creates and flattens a new Observable for each item and notification from the source Observable.
Another version combines items from the source Observable with the Observable triggered by those source items, and emits these combinations.
The flatMapIterable variants pair up source items and generated Iterable s rather than source items and generated Observables, but otherwise work in much the same way.
There is also a concatMap operator, which is like the simpler version of the flatMap operator, but it concatenates rather than merges the resulting Observables in order to generate its own sequence. RxGroovy also implements the switchMap operator. It behaves much like flatMapexcept that whenever a new item is emitted by the source Observable, it will unsubscribe to and stop mirroring the Observable that was generated from the previously-emitted item, and begin only mirroring the current one.
In the distinct StringObservable class not part of RxGroovy by default there is also a split operator that converts an Observable of Strings into an Observable of Strings that treats the source sequence as a stream and splits it on a specified regex boundary, then merges the results of this split. RxJava also implements the switchMap operator. In the distinct StringObservable class not part of RxJava by default there is also a split operator that converts an Observable of Strings into an Observable of Strings that treats the source sequence as a stream and splits it on a specified regex boundary, then merges the results of this split.
RxJS has a wealth of operators that perform FlatMap -like operations. In RxJS, the functions that transform items emitted by the source Observable into Observables typically take as parameters both the item and the index of the item in the Observable sequence.
RxJS implements the basic flatMap operator. It has a variant that allows you to apply a transformative function an optional second parameter to flatMap to the items emitted by the Observables generated for each item in the source Observable, before merging and emitting those items. The flatMapLatest operator behaves much like the standard FlatMap operator, except that whenever a new item is emitted by the source Observable, it will unsubscribe to and stop mirroring the Observable that was generated from the previously-emitted item, and begin only mirroring the current one.
It accepts a different transformation function to respond to onNextonErrorand onCompleted notifications and to return an Observable for each. There is also a concatMap operator, which is like the flatMap operator, but it concatenates rather than merges the resulting Observables in order to generate its own sequence. As with flatMapconcatMap works just as well if the function you provide transforms items from the source Observables into Observables, into Promises, or into arrays.
The for operator and its alias, forIn is very similar to concatMapthough it has a converse flexibility. While concatMap operates on an Observable source and can use Observable, Promise, or array intermediaries to generate its output sequence; for always uses Observables as its intermediaries, but can operate on a source that is either an Observable, a Promise, or an array.
There is also a concatMapObserver operator, which is like the flatMapObserver operator, in that it creates Observables to merge from both the emissions and terminal notifications of the source Observable, but it concatenates rather than merges these resulting Observables in order to generate its own sequence.
So, for example, it internally transforms an Observable that emits the numbers 1,2,3 into three Observables: one that emits 1,2,3, one that emits 2,3, and one that emits 3. Then manySelect passes each of these Observables into a function that you provide, and emits, as the emissions from the Observable that manySelect returns, the return values from those function calls. In this way, each item emitted by the resulting Observable is a function of the corresponding item in the source Observable and all of the items emitted by the source Observable after it.
Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence.
Bypasses a specified number of elements in an observable sequence and then returns the remaining elements. Transform the items emitted by an Observable into Observables, and mirror those items emitted by the most-recently transformed Observable. The flatMapLatest operator is similar to the flatMap and concatMap methods described above, however, rather than emitting all of the items emitted by all of the Observables that the operator generates by transforming items from the source Observable, flatMapLatest instead emits items from each such transformed Observable only until the next such Observable is emitted, then it ignores the previous one and begins emitting items emitted by the new one.
SwitchMap only emits the latest observable value and cancel previous observable. ZahiC, cool answer - I like the use of functional composition in the code sample. If I may, like to borrow it to illustrate a couple of extra points using timed observables. These operators are all transformation operators like mapthe common feature is they have an outer and inner observable.
The key difference is the way the outer observable controls the inner observable. To contrast them, my code sample runs them in pairs, outputting values in the form [outerValue,innerValue]. From the output, mergeMap outer emit can be delayed in the sequence, but concatMap follows strict outer emit sequence.
From the output, switchMap throttles any incomplete inner emits, but exhaustMap throttles following emits until the earlier ones complete. I threw this in because switchmap is often used in SO answers where really mergeMap should be used.
The main takeaway is that the switchMap output is unpredictable depending on the timing of the inner observable, e. Taking this from a previous answer :. Here is an example of how each of the operators behaves when the source is immediate items 0,1,2,3,4 and the map function creates an Observable that delays each item by ms:.
Play with this marble diagram here: "mergeMap vs exhaustMap vs switchMap vs concatMap". You can choose between an interval or click for emiting outer observable values. For the inner observable you can choose whether to emit an interval 3 items or a http request. Here is one more way of thinking about the difference between the different types of maps.
This helped me get my head around it. I hope it might help others. To illustrate the difference between different kinds of maps, we will link items from the alphabet source to their "word" sources corresponding to that letter of the alphabet, using each different map to see the different outcomes.
This is unlike the other maps because it does not introduce another source of observable. It just transforms an incoming value to another value.
So output from the lower case source, going through a Map which transforms input to upper case, would just be:. Switch Map. This transforms each input into another source, switching output to come from that new source ie subscribing to that new source. When another alpha input arrives, the "word" source changes we unsubscribe from the previous "word" source. Concat Map. Like switchMap except that Concat waits until each source completes before moving on to the next.
Exhaust Map. Like Concat Map except that it will ignore any inputs that come in while it is still completing the last source.Play Course Now Course Two: Student's T-test If you want to have a solid basic foundation in statistics, it is essential to understand the concepts and theories behind t-tests. Play Course Now Course Three: Analysis of Variance Analysis of Variance is probably one of the most popular and most common used statistical procedures.
ETHICAL GUIDANCE EVERY STEP OF THE WAY ON YOUR JOURNEY TO EARNING YOUR DEGREE. Statistics Solutions is a dissertation editing service with expertise in every aspect of the dissertation from both a quantitative and qualitative approach. Our expertise comes from over 22 years of dissertation experience, in most disciplines, from innumerable institutions.
The other way we make the dissertation process smooth and quick is by using a team approach of 2 -3 specialists. Typically, a methodologist to help with the prospectus, methods and results, a literature review specialist to help with the prospectus, introduction, literature review, and discussion sections, and our APA editor. Additionally, our peer-review process ensures that another thoughtful consultant provides additional input. Let our consultants help you overcome the challenges of a dissertation, reduce the number of revisions, and help you move on to your best life.
At the end of the day, we analogize the dissertation process to climbing a mountain: many can scale a mountain in good weather, but when the storms of revisions from the chair, committee, IRB, URR come, a seasoned, trusted advisor will get you safely home.
Dissertation Topic Selection: Help you swiftly select a topic that is researchable, fits within your discipline, and gets approved. There are several approaches to topic development. One is looking for archival data, backing-out research questions, and developing a methodology from there. Concept Paper, Proposal Writing, and Prospectus: Work with you to develop research questions and testable hypotheses, find gaps in the literature, create a problem statement, select a theoretical framework, and sketch out a methodology.
Introduction: Assist you to identify and articulate the research problem, describe the theoretical construct, and clearly talk about the nature of the study. Literature Review: Assist you to effectively search, select, organize, and summarize articles, then present in a way that tells a story that drives towards your research questions. Help ensure the gap in the literature is clearly stated and aligns with the problem statement. Methodology: The methodology needs to clearly tell the reader how you will conduct your study.
Think about it like a cookbook that is detailed enough that your next door neighbor can replicate your study. We help you select and discuss the research design, and provide the steps necessary to carry out a qualitative or quantitative study. We assist you in completing and navigating through the IRB review process. Help effectively address needed revisions ensures a speedy approval. Data Management: Help code, merge, clean, and overall manage your quantitative or qualitative data.