What's the difference between map and pluck in RxJS?

Stop using pluck!

Pluck is now planned to be removed in RxJS v8. Do you know what is the reason?

Because after the addition of the optional chaining operator in JS, it's essentially, just a weak version of Map.

So what's the difference between the two? Both are used to "transform" the data that is going to be emitted. Map can be used to... map an observable emission (like we do in JS with Array.prototype.map), while Pluck is used to select/pick a property to emit (without having to emit properties that we don't care for, hence improving the performance).

But even before the optional chaining operator, you could just map the properties instead of plucking them. The result & performance were/are about the same.

pluck('prop')

is just a shorthand for:

map(x => x.prop)

Well, then what was the reason behind the implementation of Pluck?

It was basically implemented to achieve path traversal safety, meaning you could try to pluck a nested property without getting the error (that Map would throw) if the property is not defined:

pluck('foo', 'bar', 'baz'); // no error if foo is not defined
map(x => x.foo.bar.baz) // error if foo is not defined

With optional chaining, this advantage doesn't exists anymore, since we can just do this:

map(x => x?.foo?.bar?.baz)

This is the main reason why the Pluck operator is going to be deprecated and removed in the future. Another important reason is TS typing for pluck is quite complex and not as robust as the map operator.

Got that info in GitHub: The commit of Pluck deprecation is almost one year old but I still don't see any warning of future deprecation in the docs, hence I am posting here since I think it's a good thing to know. I already stopped plucking for this reason.