If the operators could talk, how exactly would they tell us what they do?

In order to take full advantage of Rx, you need a clear understanding of what Rx Operators are and what they do.

This is what the Operators would be telling the observables if they could talk when we use them.

For this article, I’ll assume that you already know what Rx is. If not, go read this. Or just simply google Rx and you’ll find a ton of helpful articles, tutorials, and videos.

Creational Operators

Create

I tell you what to emit, when to terminate, and what error to throw. ‘Cause I’m the boss.

Defer

You only get to “create” yourself once someone subscribes to you. And it’ll be a brand new version of yourself every single time.

Empty

Hm. Emit nothing. And then die, please.

Never

Emit nothing. And don’t… ever… terminate.

Throw

Emit nothing, and then throw an error, OK?

From

I’ll give you some objects, then you emit them right back at me.

Interval

How about this: you emit items. But not immediately. Send them back, one by one, after certain “intervals.”

Just

I need just one thing back from you. Just one.

Range

I give you a range of integers, then you emit back all the values in that range.

Repeat

How about you emit that same object repeatedly.

Start

Ok. I have a function. When it returns, you start emitting. But only when it returns. Got it?

Timer

So you got an item. Don’t emit it just yet. I’ll tell you the exact time when you should emit it. Don’t jump the gun.

Transformational Operators

Buffer

Ok, so here’s the deal. Whatever it is you normally emit, well don’t emit that. Instead ,collect the items into bundles over time. And send bundles instead. ‘Cause I want bundles!

FlatMap

So, like, if you have lists of items and there’s another observable that’s full of items, can you please “flatten” yourself and that observable so you can just send items?

Map

Transform each item into another item.

Scan

Transform each item into another item, like you did with map. But also include the “previous” item when you get around to doing a transform.

Filtering Operators

Debounce

Only emit if a certain amount of time is passed.

Distinct

Emit only distinct items. All right?

ElementAt

I tell you the index. You emit the item at that index.

Filter

I give you a criteria. You give me items that pass the criteria.

First

Just give me back the first item.

IgnoreElements

Do not, I repeat, do not emit a single item. And then die.

Last

Just give me back the last item.

Sample

I give you an interval. You give me only the most recent items from that that interval.

Skip

OK, skip the first n items, would you?

SkipLast

Skip the last n item s. Yeah, those ones.

Take

Emit only the first n items.

TakeLast

Emit only the last n items.

Combining Operators

Merge

Here are two observables. Let’s pretend they’re only one observable.

StartWith

Here are two observables. But I get to tell you which one to start with.

CombineLatest

Here are two observables. Between the two, make pairs of the latest items.

Zip

Here are two observables. But I tell you how to combine their items (through a function, of course).

Handling Errors

Catch

After an error is thrown, continue on with the emits.

Retry

After an error is thrown, restart from the very beginning.

Utility

Delay

Just add a delay before you start emitting, OK?

ObserveOn

“Observational” code should run on this particular thread.

SubscribeOn

“Subscription” code should run on this particular thread.

Subscribe

You can start emitting now. music intensifies

TimeInterval

OK, so observables send back items, right? Instead, I want you to send the time intervals back. Like the time differences between each emission.

TimeOut

Set a TimeOut on each emission. And if an item doesn’t get emitted within that time, just throw an error ?

Conditional and Boolean

All

If all items fulfill a certain criteria, return true.

Amb

Here are at least two observables. Give me the one that starts emitting first.

Contains

If I ask for an item, can you tell me whether you already have it?

DefaultIfEmpty

When you have nothing to emit, here’s a default value that you can send back.

SequenceEqual

Here are two observables. Return true if their items (and their sequence) are the same.

SkipUntil

Here are two observables. Skip the items of the first one until the second one starts emitting.

SkipWhile

I give you a condition. You emit items until that condition becomes false.

TakeUntil

Here are two observables. Only give me the items of the first one until the second one starts emitting.

Mathematical Operators

Average

Give me an average of your Integer items.

Count

Give me a count of your items.

Max

Emit only the maximum-valued item.

Min

Emit only the minimum-valued item.

Reduce

Do a scan, but only emit the final value.

Sum

Return the sum of all your items.

Conversion Operators

To

Convert an observable into a List, Map or Array, or whatever I tell you to.

That’s it for now. There are other operators as well, which you can find here. You can also check out RxMarbles, which has cool diagrams for demonstrating each operator.

Anyway, thank you for reading. I hope the article helped you better understand what each of these commands does in a fun way.

Happy coding!